From d25d71ff316bc2b0b28eaad7b42e9c19e8baa2d5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Thu, 10 Oct 2024 17:30:09 +0200
Subject: [PATCH 1/2] update zig sources to 0.14.0-dev.1876+41dbd0d0d

---
 README.md                                     |    2 +-
 build                                         |    2 +-
 build.bat                                     |    2 +-
 zig/CMakeLists.txt                            |    6 +-
 zig/README.md                                 |    2 +-
 zig/bootstrap.c                               |    4 +-
 zig/build.zig                                 |    4 +
 zig/doc/langref.html.in                       |   34 +-
 zig/lib/compiler/aro/aro/Compilation.zig      |    2 +-
 zig/lib/compiler/aro/aro/target.zig           |   23 +-
 zig/lib/compiler/fmt.zig                      |    1 +
 zig/lib/compiler/objcopy.zig                  |  343 ++-
 zig/lib/compiler_rt/aulldiv.zig               |    3 +-
 zig/lib/compiler_rt/aullrem.zig               |    3 +-
 zig/lib/compiler_rt/common.zig                |   26 +-
 zig/lib/compiler_rt/emutls.zig                |    2 +-
 zig/lib/compiler_rt/fixdfdi.zig               |    5 +
 zig/lib/compiler_rt/fixsfdi.zig               |    5 +
 zig/lib/compiler_rt/fixunsdfdi.zig            |    5 +
 zig/lib/compiler_rt/fixunssfdi.zig            |    5 +
 zig/lib/compiler_rt/floatdidf.zig             |    5 +
 zig/lib/compiler_rt/floatdisf.zig             |    5 +
 zig/lib/compiler_rt/floatundidf.zig           |    5 +
 zig/lib/compiler_rt/floatundisf.zig           |    5 +
 zig/lib/libc/glibc/abilists                   |  Bin 274738 -> 246035 bytes
 zig/lib/libc/glibc/sysdeps/mips/mips32/crtn.S |    6 +-
 .../libc/glibc/sysdeps/mips/mips64/n32/crtn.S |    6 +-
 .../libc/glibc/sysdeps/mips/mips64/n64/crtn.S |    6 +-
 zig/lib/libc/glibc/sysdeps/unix/mips/sysdep.h |    3 +-
 .../loongarch64-linux-gnusf/bits/endianness.h |   11 +
 .../loongarch64-linux-gnusf/bits/fcntl.h      |   61 +
 .../loongarch64-linux-gnusf/bits/fenv.h       |   90 +
 .../loongarch64-linux-gnusf/bits/hwcap.h      |   38 +
 .../loongarch64-linux-gnusf/bits/link.h       |   76 +
 .../bits/link_lavcurrent.h                    |   25 +
 .../bits/long-double.h                        |   21 +
 .../loongarch64-linux-gnusf/bits/procfs.h     |   52 +
 .../bits/pthread_stack_min.h                  |   20 +
 .../loongarch64-linux-gnusf/bits/setjmp.h     |   42 +
 .../loongarch64-linux-gnusf/bits/shmlba.h     |   24 +
 .../loongarch64-linux-gnusf/bits/sigstack.h   |   32 +
 .../bits/struct_stat.h                        |  127 ++
 .../loongarch64-linux-gnusf/bits/timesize.h   |   20 +
 .../loongarch64-linux-gnusf/bits/wordsize.h   |   19 +
 .../loongarch64-linux-gnusf/fpu_control.h     |  119 ++
 .../gnu/lib-names-lp64s.h                     |   27 +
 .../loongarch64-linux-gnusf/gnu/lib-names.h   |   16 +
 .../loongarch64-linux-gnusf/gnu/stubs-lp64s.h |   38 +
 .../loongarch64-linux-gnusf/gnu/stubs.h       |   12 +
 .../include/loongarch64-linux-gnusf/ieee754.h |  170 ++
 .../include/loongarch64-linux-gnusf/sys/asm.h |   78 +
 .../loongarch64-linux-gnusf/sys/ucontext.h    |   64 +
 .../loongarch64-linux-gnusf/sys/user.h        |   42 +
 zig/lib/libc/musl/crt/arm/crti.s              |    2 +
 zig/lib/libc/musl/crt/mips/crtn.s             |    6 +-
 zig/lib/libc/musl/crt/mips64/crtn.s           |    6 +-
 zig/lib/libunwind/src/gcc_personality_v0.c    |   36 +-
 zig/lib/std/Build.zig                         |  213 +-
 zig/lib/std/Build/Cache.zig                   |    7 +
 zig/lib/std/Build/Cache/Path.zig              |   24 +-
 zig/lib/std/Build/Module.zig                  |   69 +-
 zig/lib/std/Build/Step/CheckObject.zig        |   44 +-
 zig/lib/std/Build/Step/Compile.zig            |   12 +
 zig/lib/std/Build/Step/ObjCopy.zig            |   80 +
 zig/lib/std/Build/Step/TranslateC.zig         |   49 +-
 zig/lib/std/Build/Watch.zig                   |    7 +-
 zig/lib/std/Target.zig                        |  662 ++++--
 zig/lib/std/Target/Query.zig                  |    2 +-
 zig/lib/std/Target/aarch64.zig                |   86 +-
 zig/lib/std/Target/arm.zig                    |    1 -
 zig/lib/std/Target/lanai.zig                  |   37 +
 zig/lib/std/Target/propeller.zig              |   20 +
 zig/lib/std/Target/xcore.zig                  |   37 +
 zig/lib/std/Thread.zig                        |   77 +
 zig/lib/std/Thread/Futex.zig                  |   21 +-
 zig/lib/std/Thread/ResetEvent.zig             |    8 +-
 zig/lib/std/Thread/WaitGroup.zig              |    3 +-
 zig/lib/std/atomic.zig                        |   48 +-
 zig/lib/std/bit_set.zig                       |    3 -
 zig/lib/std/builtin.zig                       |  243 +--
 zig/lib/std/c.zig                             |   99 +-
 zig/lib/std/c/darwin.zig                      |    3 +-
 zig/lib/std/crypto/tls.zig                    |    4 +-
 zig/lib/std/crypto/tls/Client.zig             |   14 +-
 zig/lib/std/debug.zig                         |  168 +-
 zig/lib/std/debug/FormattedPanic.zig          |   45 +
 zig/lib/std/debug/SimplePanic.zig             |   86 +
 zig/lib/std/elf.zig                           |  112 +-
 zig/lib/std/fmt.zig                           |   12 +-
 zig/lib/std/fs/Dir.zig                        |    7 +
 zig/lib/std/fs/test.zig                       |   30 +
 zig/lib/std/heap.zig                          |    2 -
 zig/lib/std/http/test.zig                     |    5 +
 zig/lib/std/io.zig                            |  192 +-
 zig/lib/std/io/Reader/test.zig                |    3 +-
 zig/lib/std/io/buffered_reader.zig            |   72 +-
 zig/lib/std/math/float.zig                    |    3 -
 zig/lib/std/math/gcd.zig                      |   59 +-
 zig/lib/std/math/isnan.zig                    |    8 +-
 zig/lib/std/mem.zig                           |    4 -
 zig/lib/std/meta.zig                          |   11 +-
 zig/lib/std/os/linux.zig                      |  115 +-
 zig/lib/std/os/linux/IoUring.zig              |    8 +-
 .../std/os/linux/{arm64.zig => aarch64.zig}   |    0
 .../std/os/linux/{arm-eabi.zig => arm.zig}    |    0
 zig/lib/std/os/linux/hexagon.zig              |  254 +++
 .../std/os/linux/{start_pie.zig => pie.zig}   |    0
 zig/lib/std/os/linux/powerpc64.zig            |   10 +-
 zig/lib/std/os/linux/s390x.zig                |  276 +++
 zig/lib/std/os/linux/syscalls.zig             |    4 +-
 zig/lib/std/os/linux/thumb.zig                |    2 +-
 zig/lib/std/os/linux/tls.zig                  |   14 +-
 zig/lib/std/os/uefi/pool_allocator.zig        |    7 +-
 zig/lib/std/os/wasi.zig                       |   42 +
 zig/lib/std/os/windows.zig                    |    3 +
 zig/lib/std/os/windows/tls.zig                |    2 +-
 zig/lib/std/posix.zig                         |   25 +-
 zig/lib/std/posix/test.zig                    |    5 +
 zig/lib/std/process/Child.zig                 |    4 +-
 zig/lib/std/sort.zig                          |   37 +-
 zig/lib/std/start.zig                         |    6 +-
 zig/lib/std/tar.zig                           |    1 +
 zig/lib/std/tar/writer.zig                    |   10 +-
 zig/lib/std/time.zig                          |   82 +-
 zig/lib/std/zig.zig                           |    1 -
 zig/lib/std/zig/AstGen.zig                    |   19 +-
 zig/lib/std/zig/AstRlAnnotate.zig             |    1 -
 zig/lib/std/zig/BuiltinFn.zig                 |    8 -
 zig/lib/std/zig/LibCDirs.zig                  |   21 +-
 zig/lib/std/zig/LibCInstallation.zig          |  332 ++-
 zig/lib/std/zig/Zir.zig                       |   18 +-
 zig/lib/std/zig/system.zig                    |   19 +-
 zig/lib/std/zig/target.zig                    |    1 +
 zig/lib/std/zig/tokenizer.zig                 |    3 +
 zig/lib/tsan/builtins/assembly.h              |  293 +++
 zig/lib/tsan/interception/interception.h      |   29 +-
 .../tsan/interception/interception_linux.h    |   16 +-
 .../tsan/interception/interception_win.cpp    |   83 +-
 .../sanitizer_common/sanitizer_allocator.cpp  |   10 +-
 .../sanitizer_allocator_interface.h           |    2 +
 .../sanitizer_allocator_primary32.h           |    2 +-
 .../sanitizer_allocator_primary64.h           |   16 +-
 zig/lib/tsan/sanitizer_common/sanitizer_asm.h |   43 +-
 .../tsan/sanitizer_common/sanitizer_atomic.h  |   14 +-
 .../sanitizer_common/sanitizer_atomic_clang.h |   85 +-
 .../sanitizer_atomic_clang_mips.h             |  117 --
 .../sanitizer_atomic_clang_other.h            |   85 -
 .../sanitizer_atomic_clang_x86.h              |  113 -
 .../sanitizer_common/sanitizer_atomic_msvc.h  |    8 +-
 .../sanitizer_common/sanitizer_bitvector.h    |    8 +-
 .../sanitizer_chained_origin_depot.cpp        |    6 +-
 .../sanitizer_chained_origin_depot.h          |    4 +-
 .../sanitizer_common/sanitizer_common.cpp     |   20 +-
 .../tsan/sanitizer_common/sanitizer_common.h  |   45 +-
 .../sanitizer_common_interceptors.inc         |  203 +-
 .../sanitizer_common_interceptors_format.inc  |   15 +-
 .../sanitizer_common_interface.inc            |    1 +
 .../sanitizer_common_interface_posix.inc      |    1 +
 .../sanitizer_common_libcdep.cpp              |   10 +-
 .../sanitizer_common_syscalls.inc             |   35 +
 .../tsan/sanitizer_common/sanitizer_dl.cpp    |   37 +
 zig/lib/tsan/sanitizer_common/sanitizer_dl.h  |   26 +
 .../tsan/sanitizer_common/sanitizer_file.cpp  |    4 +-
 .../tsan/sanitizer_common/sanitizer_file.h    |    2 +-
 .../sanitizer_flag_parser.cpp                 |    7 +-
 .../sanitizer_common/sanitizer_flag_parser.h  |    4 +-
 .../tsan/sanitizer_common/sanitizer_flags.cpp |    4 +-
 .../tsan/sanitizer_common/sanitizer_flags.inc |   13 +
 .../sanitizer_common/sanitizer_flat_map.h     |    4 +
 .../tsan/sanitizer_common/sanitizer_freebsd.h |  137 --
 .../sanitizer_common/sanitizer_fuchsia.cpp    |  107 +-
 .../tsan/sanitizer_common/sanitizer_hash.h    |    2 +-
 .../sanitizer_internal_defs.h                 |   34 +-
 .../tsan/sanitizer_common/sanitizer_libc.cpp  |   16 +
 .../tsan/sanitizer_common/sanitizer_libc.h    |    3 +-
 .../sanitizer_common/sanitizer_libignore.cpp  |    4 +-
 .../tsan/sanitizer_common/sanitizer_linux.cpp | 1842 +++++++++--------
 .../tsan/sanitizer_common/sanitizer_linux.h   |  114 +-
 .../sanitizer_linux_libcdep.cpp               |  483 ++---
 .../sanitizer_common/sanitizer_linux_s390.cpp |  164 +-
 .../tsan/sanitizer_common/sanitizer_mac.cpp   |    8 +-
 .../sanitizer_common/sanitizer_mallinfo.h     |    4 +
 .../sanitizer_common/sanitizer_malloc_mac.inc |    2 +-
 .../tsan/sanitizer_common/sanitizer_mutex.cpp |    6 +-
 .../sanitizer_placement_new.h                 |    4 +-
 .../sanitizer_common/sanitizer_platform.h     |   24 +-
 .../sanitizer_platform_interceptors.h         |   16 +-
 .../sanitizer_platform_limits_freebsd.cpp     |    2 +
 .../sanitizer_platform_limits_freebsd.h       |   24 +-
 .../sanitizer_platform_limits_openbsd.cpp     |    0
 .../sanitizer_platform_limits_openbsd.h       |    0
 .../sanitizer_platform_limits_posix.h         |    1 +
 .../tsan/sanitizer_common/sanitizer_posix.cpp |   12 +-
 .../tsan/sanitizer_common/sanitizer_posix.h   |   28 +-
 .../sanitizer_posix_libcdep.cpp               |   33 +-
 .../sanitizer_common/sanitizer_printf.cpp     |   11 +-
 .../sanitizer_procmaps_bsd.cpp                |   47 +-
 .../sanitizer_procmaps_common.cpp             |    2 +-
 .../tsan/sanitizer_common/sanitizer_ptrauth.h |   46 +-
 .../sanitizer_redefine_builtins.h             |   16 +-
 .../sanitizer_common/sanitizer_ring_buffer.h  |    4 +-
 .../sanitizer_stack_store.cpp                 |    9 +-
 .../sanitizer_common/sanitizer_stackdepot.cpp |    8 +-
 .../sanitizer_common/sanitizer_stackdepot.h   |    4 +-
 .../sanitizer_stackdepotbase.h                |   31 +-
 .../sanitizer_stacktrace_libcdep.cpp          |   42 +-
 .../sanitizer_stacktrace_printer.cpp          |  133 +-
 .../sanitizer_stacktrace_printer.h            |  143 +-
 .../sanitizer_stacktrace_sparc.cpp            |   11 +-
 .../sanitizer_stoptheworld_linux_libcdep.cpp  |   10 +-
 .../sanitizer_stoptheworld_netbsd_libcdep.cpp |    4 +-
 .../sanitizer_suppressions.cpp                |    7 +-
 .../sanitizer_common/sanitizer_symbolizer.cpp |    5 +-
 .../sanitizer_common/sanitizer_symbolizer.h   |   27 +-
 .../sanitizer_symbolizer_internal.h           |    9 +
 .../sanitizer_symbolizer_libbacktrace.cpp     |    2 +-
 .../sanitizer_symbolizer_libcdep.cpp          |   20 +-
 .../sanitizer_symbolizer_mac.cpp              |    5 +-
 .../sanitizer_symbolizer_markup.cpp           |  228 +-
 .../sanitizer_symbolizer_markup.h             |   79 +
 ...> sanitizer_symbolizer_markup_constants.h} |   19 +-
 .../sanitizer_symbolizer_markup_fuchsia.cpp   |   85 +
 .../sanitizer_symbolizer_posix_libcdep.cpp    |   67 +-
 .../sanitizer_symbolizer_report.cpp           |   80 +-
 .../sanitizer_symbolizer_report_fuchsia.cpp   |   33 +
 .../sanitizer_symbolizer_win.cpp              |    6 +-
 .../sanitizer_syscall_linux_hexagon.inc       |  131 ++
 .../sanitizer_syscall_linux_loongarch64.inc   |  171 ++
 .../sanitizer_syscall_linux_riscv64.inc       |  174 ++
 .../sanitizer_thread_arg_retval.cpp           |   23 +-
 .../sanitizer_thread_arg_retval.h             |    1 +
 .../sanitizer_tls_get_addr.cpp                |   15 +-
 .../sanitizer_unwind_fuchsia.cpp              |   66 +
 .../sanitizer_common/sanitizer_unwind_win.cpp |    7 +
 .../tsan/sanitizer_common/sanitizer_win.cpp   |   25 +-
 zig/lib/tsan/tsan_debugging.cpp               |    4 +-
 zig/lib/tsan/tsan_defs.h                      |    2 +-
 zig/lib/tsan/tsan_dispatch_defs.h             |    7 -
 zig/lib/tsan/tsan_interceptors_posix.cpp      |  135 +-
 zig/lib/tsan/tsan_interface.h                 |    8 +
 zig/lib/tsan/tsan_interface_ann.cpp           |   24 +-
 zig/lib/tsan/tsan_interface_atomic.cpp        |   24 +
 zig/lib/tsan/tsan_mman.cpp                    |   29 +-
 zig/lib/tsan/tsan_mman.h                      |    4 +-
 zig/lib/tsan/tsan_platform.h                  |  151 +-
 zig/lib/tsan/tsan_platform_linux.cpp          |  220 +-
 zig/lib/tsan/tsan_platform_mac.cpp            |    9 +-
 zig/lib/tsan/tsan_platform_posix.cpp          |   43 +-
 zig/lib/tsan/tsan_preinit.cpp                 |   10 +-
 zig/lib/tsan/tsan_report.cpp                  |   38 +-
 zig/lib/tsan/tsan_report.h                    |    3 +-
 zig/lib/tsan/tsan_rtl.cpp                     |   24 +-
 zig/lib/tsan/tsan_rtl.h                       |   12 +-
 zig/lib/tsan/tsan_rtl_aarch64.S               |    7 +
 zig/lib/tsan/tsan_rtl_access.cpp              |   22 +-
 zig/lib/tsan/tsan_rtl_loongarch64.S           |  196 ++
 zig/lib/tsan/tsan_rtl_mutex.cpp               |    2 +-
 zig/lib/tsan/tsan_rtl_riscv64.S               |  203 ++
 zig/lib/tsan/tsan_rtl_s390x.S                 |   49 +
 zig/lib/tsan/tsan_rtl_thread.cpp              |   10 +-
 zig/lib/tsan/tsan_suppressions.cpp            |    3 +-
 zig/lib/tsan/tsan_vector_clock.h              |    2 +-
 zig/lib/zig.h                                 |   60 +-
 zig/src/Air.zig                               |    7 -
 zig/src/Air/types_resolved.zig                |    1 -
 zig/src/Compilation.zig                       |  185 +-
 zig/src/Compilation/Config.zig                |    2 +-
 zig/src/InternPool.zig                        |   34 +-
 zig/src/Liveness.zig                          |    3 -
 zig/src/Liveness/Verify.zig                   |    1 -
 zig/src/Package/Manifest.zig                  |    7 +
 zig/src/Sema.zig                              |  775 +++----
 zig/src/Sema/bitcast.zig                      |   12 +-
 zig/src/Type.zig                              |    6 +-
 zig/src/Value.zig                             |   12 +-
 zig/src/Zcu.zig                               |   23 +-
 zig/src/Zcu/PerThread.zig                     |   96 +-
 zig/src/arch/aarch64/CodeGen.zig              |    6 -
 zig/src/arch/aarch64/Mir.zig                  |    2 +-
 zig/src/arch/arm/CodeGen.zig                  |    6 -
 zig/src/arch/mips/abi.zig                     |    2 -
 zig/src/arch/riscv64/CodeGen.zig              |   21 -
 zig/src/arch/sparc64/CodeGen.zig              |   24 -
 zig/src/arch/wasm/CodeGen.zig                 |   65 +-
 zig/src/arch/x86_64/CodeGen.zig               |  101 +-
 zig/src/arch/x86_64/Emit.zig                  |   24 +
 zig/src/arch/x86_64/Lower.zig                 |    2 +
 zig/src/arch/x86_64/Mir.zig                   |    4 +
 zig/src/arch/x86_64/encoder.zig               |    8 +-
 zig/src/clang.zig                             |    2 +-
 zig/src/codegen/c.zig                         |   12 -
 zig/src/codegen/llvm.zig                      |  131 +-
 zig/src/codegen/spirv.zig                     |    3 +
 zig/src/crash_report.zig                      |   21 +-
 zig/src/glibc.zig                             |   81 +-
 zig/src/libcxx.zig                            |    2 +-
 zig/src/libtsan.zig                           |   16 +-
 zig/src/libunwind.zig                         |    4 +
 zig/src/link.zig                              |   32 +-
 zig/src/link/C.zig                            |    3 +-
 zig/src/link/Coff.zig                         |    1 -
 zig/src/link/Coff/lld.zig                     |   53 +-
 zig/src/link/Dwarf.zig                        |  194 +-
 zig/src/link/Elf.zig                          | 1411 ++++++-------
 zig/src/link/Elf/Archive.zig                  |   23 +-
 zig/src/link/Elf/Atom.zig                     |   41 +-
 zig/src/link/Elf/AtomList.zig                 |   43 +-
 zig/src/link/Elf/LdScript.zig                 |   38 +-
 zig/src/link/Elf/LinkerDefined.zig            |   10 +-
 zig/src/link/Elf/Object.zig                   |  145 +-
 zig/src/link/Elf/SharedObject.zig             |   34 +-
 zig/src/link/Elf/Symbol.zig                   |   16 +-
 zig/src/link/Elf/ZigObject.zig                |  296 ++-
 zig/src/link/Elf/file.zig                     |   52 +-
 zig/src/link/Elf/merge_section.zig            |    4 +
 zig/src/link/Elf/relocatable.zig              |  146 +-
 zig/src/link/Elf/synthetic_sections.zig       |   29 +-
 zig/src/link/MachO.zig                        |  368 ++--
 zig/src/link/MachO/Archive.zig                |   16 +-
 zig/src/link/MachO/Atom.zig                   |    4 +-
 zig/src/link/MachO/Dylib.zig                  |   11 +-
 zig/src/link/MachO/InternalObject.zig         |   44 +-
 zig/src/link/MachO/Object.zig                 |   63 +-
 zig/src/link/MachO/ZigObject.zig              |    4 +-
 zig/src/link/MachO/file.zig                   |   11 +-
 zig/src/link/MachO/load_commands.zig          |    5 +-
 zig/src/link/MachO/relocatable.zig            |   40 +-
 zig/src/link/NvPtx.zig                        |    1 -
 zig/src/link/Plan9.zig                        |    1 -
 zig/src/link/SpirV.zig                        |    1 -
 zig/src/link/StringTable.zig                  |    2 +-
 zig/src/link/Wasm.zig                         |   60 +-
 zig/src/main.zig                              |   82 +-
 zig/src/mingw.zig                             |   42 +-
 zig/src/musl.zig                              |    4 +-
 zig/src/mutable_value.zig                     |    4 +-
 zig/src/print_air.zig                         |    7 -
 zig/src/print_zir.zig                         |    3 +-
 zig/src/target.zig                            |   44 +-
 zig/src/wasi_libc.zig                         |   14 +-
 zig/test/behavior/array.zig                   |   67 +
 zig/test/behavior/atomics.zig                 |   10 -
 zig/test/behavior/basic.zig                   |    1 +
 zig/test/behavior/bitcast.zig                 |    3 -
 ...n_functions_returning_void_or_noreturn.zig |    1 -
 zig/test/behavior/export_keyword.zig          |   13 +
 zig/test/behavior/math.zig                    |    6 -
 zig/test/behavior/union.zig                   |    1 +
 zig/test/behavior/var_args.zig                |    5 +
 ...ray slice sentinel mismatch non-scalar.zig |   13 +
 ...orderings_of_fence_Acquire_or_stricter.zig |    9 -
 .../comptime_var_referenced_at_runtime.zig    |   20 +
 .../comptime_var_referenced_by_decl.zig       |    7 +
 .../destructure_error_union.zig               |   15 +
 .../compile_errors/minmax_missing_args.zig    |    9 +
 .../compile_errors/splat_bad_result_type.zig  |    7 +
 .../splat_result_type_non_vector.zig          |    9 -
 zig/test/cases/errdefer_discard.zig           |    7 +
 zig/test/cases/exit.zig                       |    2 +-
 ...ray slice sentinel mismatch non-scalar.zig |   21 -
 zig/test/incremental/add_decl                 |    4 +-
 zig/test/incremental/add_decl_namespaced      |    4 +-
 zig/test/incremental/delete_comptime_decls    |    4 +-
 zig/test/incremental/hello                    |    4 +-
 zig/test/incremental/modify_inline_fn         |    4 +-
 zig/test/incremental/move_src                 |    4 +-
 zig/test/incremental/remove_enum_field        |    4 +-
 .../incremental/type_becomes_comptime_only    |    4 +-
 zig/test/incremental/unreferenced_error       |    4 +-
 zig/test/link/elf.zig                         |   16 +-
 zig/test/link/link.zig                        |    2 +-
 zig/test/link/macho.zig                       |   26 +
 zig/test/llvm_targets.zig                     |  343 ++-
 zig/test/src/Debugger.zig                     |  485 +++--
 zig/test/standalone/empty_env/build.zig       |    7 +
 zig/test/tests.zig                            |   76 +
 zig/tools/generate_linux_syscalls.zig         |    2 +
 zig/tools/incr-check.zig                      |  427 ++--
 zig/tools/lldb_pretty_printers.py             |   13 +-
 zig/tools/process_headers.zig                 |    5 +
 zig/tools/update_cpu_features.zig             |   36 +-
 381 files changed, 13437 insertions(+), 6724 deletions(-)
 create mode 100644 zig/lib/libc/include/loongarch64-linux-gnusf/bits/endianness.h
 create mode 100644 zig/lib/libc/include/loongarch64-linux-gnusf/bits/fcntl.h
 create mode 100644 zig/lib/libc/include/loongarch64-linux-gnusf/bits/fenv.h
 create mode 100644 zig/lib/libc/include/loongarch64-linux-gnusf/bits/hwcap.h
 create mode 100644 zig/lib/libc/include/loongarch64-linux-gnusf/bits/link.h
 create mode 100644 zig/lib/libc/include/loongarch64-linux-gnusf/bits/link_lavcurrent.h
 create mode 100644 zig/lib/libc/include/loongarch64-linux-gnusf/bits/long-double.h
 create mode 100644 zig/lib/libc/include/loongarch64-linux-gnusf/bits/procfs.h
 create mode 100644 zig/lib/libc/include/loongarch64-linux-gnusf/bits/pthread_stack_min.h
 create mode 100644 zig/lib/libc/include/loongarch64-linux-gnusf/bits/setjmp.h
 create mode 100644 zig/lib/libc/include/loongarch64-linux-gnusf/bits/shmlba.h
 create mode 100644 zig/lib/libc/include/loongarch64-linux-gnusf/bits/sigstack.h
 create mode 100644 zig/lib/libc/include/loongarch64-linux-gnusf/bits/struct_stat.h
 create mode 100644 zig/lib/libc/include/loongarch64-linux-gnusf/bits/timesize.h
 create mode 100644 zig/lib/libc/include/loongarch64-linux-gnusf/bits/wordsize.h
 create mode 100644 zig/lib/libc/include/loongarch64-linux-gnusf/fpu_control.h
 create mode 100644 zig/lib/libc/include/loongarch64-linux-gnusf/gnu/lib-names-lp64s.h
 create mode 100644 zig/lib/libc/include/loongarch64-linux-gnusf/gnu/lib-names.h
 create mode 100644 zig/lib/libc/include/loongarch64-linux-gnusf/gnu/stubs-lp64s.h
 create mode 100644 zig/lib/libc/include/loongarch64-linux-gnusf/gnu/stubs.h
 create mode 100644 zig/lib/libc/include/loongarch64-linux-gnusf/ieee754.h
 create mode 100644 zig/lib/libc/include/loongarch64-linux-gnusf/sys/asm.h
 create mode 100644 zig/lib/libc/include/loongarch64-linux-gnusf/sys/ucontext.h
 create mode 100644 zig/lib/libc/include/loongarch64-linux-gnusf/sys/user.h
 create mode 100644 zig/lib/std/Target/lanai.zig
 create mode 100644 zig/lib/std/Target/propeller.zig
 create mode 100644 zig/lib/std/Target/xcore.zig
 create mode 100644 zig/lib/std/debug/FormattedPanic.zig
 create mode 100644 zig/lib/std/debug/SimplePanic.zig
 rename zig/lib/std/os/linux/{arm64.zig => aarch64.zig} (100%)
 rename zig/lib/std/os/linux/{arm-eabi.zig => arm.zig} (100%)
 create mode 100644 zig/lib/std/os/linux/hexagon.zig
 rename zig/lib/std/os/linux/{start_pie.zig => pie.zig} (100%)
 create mode 100644 zig/lib/std/os/linux/s390x.zig
 create mode 100644 zig/lib/tsan/builtins/assembly.h
 delete mode 100644 zig/lib/tsan/sanitizer_common/sanitizer_atomic_clang_mips.h
 delete mode 100644 zig/lib/tsan/sanitizer_common/sanitizer_atomic_clang_other.h
 delete mode 100644 zig/lib/tsan/sanitizer_common/sanitizer_atomic_clang_x86.h
 create mode 100644 zig/lib/tsan/sanitizer_common/sanitizer_dl.cpp
 create mode 100644 zig/lib/tsan/sanitizer_common/sanitizer_dl.h
 delete mode 100644 zig/lib/tsan/sanitizer_common/sanitizer_freebsd.h
 delete mode 100644 zig/lib/tsan/sanitizer_common/sanitizer_platform_limits_openbsd.cpp
 delete mode 100644 zig/lib/tsan/sanitizer_common/sanitizer_platform_limits_openbsd.h
 create mode 100644 zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_markup.h
 rename zig/lib/tsan/sanitizer_common/{sanitizer_symbolizer_fuchsia.h => sanitizer_symbolizer_markup_constants.h} (69%)
 create mode 100644 zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_markup_fuchsia.cpp
 create mode 100644 zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_report_fuchsia.cpp
 create mode 100644 zig/lib/tsan/sanitizer_common/sanitizer_syscall_linux_hexagon.inc
 create mode 100644 zig/lib/tsan/sanitizer_common/sanitizer_syscall_linux_loongarch64.inc
 create mode 100644 zig/lib/tsan/sanitizer_common/sanitizer_syscall_linux_riscv64.inc
 create mode 100644 zig/lib/tsan/sanitizer_common/sanitizer_unwind_fuchsia.cpp
 create mode 100644 zig/lib/tsan/tsan_rtl_loongarch64.S
 create mode 100644 zig/lib/tsan/tsan_rtl_riscv64.S
 create mode 100644 zig/lib/tsan/tsan_rtl_s390x.S
 create mode 100644 zig/test/cases/compile_errors/array slice sentinel mismatch non-scalar.zig
 delete mode 100644 zig/test/cases/compile_errors/atomic_orderings_of_fence_Acquire_or_stricter.zig
 create mode 100644 zig/test/cases/compile_errors/destructure_error_union.zig
 create mode 100644 zig/test/cases/compile_errors/minmax_missing_args.zig
 create mode 100644 zig/test/cases/compile_errors/splat_bad_result_type.zig
 delete mode 100644 zig/test/cases/compile_errors/splat_result_type_non_vector.zig
 create mode 100644 zig/test/cases/errdefer_discard.zig
 delete mode 100644 zig/test/cases/safety/array slice sentinel mismatch non-scalar.zig

diff --git a/README.md b/README.md
index 70f12ae933..f1e0009a79 100644
--- a/README.md
+++ b/README.md
@@ -11,7 +11,7 @@ to find and inspect the patch diffs.
  * LLVM, LLD, Clang 19.1.0
  * zlib 1.3.1
  * zstd 1.5.2
- * zig 0.14.0-dev.1622+2ac543388
+ * zig 0.14.0-dev.1876+41dbd0d0d
 
 For other versions, check the git tags of this repository.
 
diff --git a/build b/build
index cc5bd56008..b1c233233a 100755
--- a/build
+++ b/build
@@ -7,7 +7,7 @@ TARGET="$1" # Example: riscv64-linux-gnu
 MCPU="$2" # Examples: `baseline`, `native`, `generic+v7a`, or `arm1176jzf_s`
 
 ROOTDIR="$(pwd)"
-ZIG_VERSION="0.14.0-dev.1622+2ac543388"
+ZIG_VERSION="0.14.0-dev.1876+41dbd0d0d"
 
 TARGET_OS_AND_ABI=${TARGET#*-} # Example: linux-gnu
 
diff --git a/build.bat b/build.bat
index 609d7ce87f..331bd1d043 100644
--- a/build.bat
+++ b/build.bat
@@ -35,7 +35,7 @@ if "%VSCMD_ARG_HOST_ARCH%"=="x86" set OUTDIR=out-win-x86
 
 set ROOTDIR=%~dp0
 set "ROOTDIR_CMAKE=%ROOTDIR:\=/%"
-set ZIG_VERSION="0.14.0-dev.1622+2ac543388"
+set ZIG_VERSION="0.14.0-dev.1876+41dbd0d0d"
 set JOBS_ARG=
 
 pushd %ROOTDIR%
diff --git a/zig/CMakeLists.txt b/zig/CMakeLists.txt
index d7dfbfce81..e71f799b54 100644
--- a/zig/CMakeLists.txt
+++ b/zig/CMakeLists.txt
@@ -125,8 +125,8 @@ check_pie_supported(
   OUTPUT_VARIABLE ZIG_PIE_SUPPORTED_BY_CMAKE
   LANGUAGES C CXX
 )
-if(ZIG_PIE AND NOT ZIG_PIE_SUPPORTED_BY_CMAKE)
-  message(SEND_ERROR "ZIG_PIE was requested but CMake does not support it for \"zigcpp\" target")
+if(ZIG_PIE AND NOT CMAKE_CXX_LINK_PIE_SUPPORTED)
+  message(SEND_ERROR "ZIG_PIE was requested but CMake does not support it for \"zigcpp\" target: ${ZIG_PIE_SUPPORTED_BY_CMAKE}")
 endif()
 
 
@@ -894,9 +894,7 @@ set(BUILD_COMPILER_RT_ARGS
   --name compiler_rt
   -femit-bin="${ZIG_COMPILER_RT_C_SOURCE}"
   -target "${ZIG_HOST_TARGET_TRIPLE}"
-  --dep "build_options"
   "-Mroot=lib/compiler_rt.zig"
-  "-Mbuild_options=${ZIG_CONFIG_ZIG_OUT}"
 )
 
 add_custom_command(
diff --git a/zig/README.md b/zig/README.md
index 865bd178b3..818a7d67f8 100644
--- a/zig/README.md
+++ b/zig/README.md
@@ -47,7 +47,7 @@ Ensure you have the required dependencies:
 
  * CMake >= 3.15
  * System C/C++ Toolchain
- * LLVM, Clang, LLD development libraries == 18.x
+ * LLVM, Clang, LLD development libraries == 19.x
 
 Then it is the standard CMake build process:
 
diff --git a/zig/bootstrap.c b/zig/bootstrap.c
index a373522de4..f341740a0e 100644
--- a/zig/bootstrap.c
+++ b/zig/bootstrap.c
@@ -123,7 +123,7 @@ int main(int argc, char **argv) {
         if (f == NULL)
             panic("unable to open config.zig for writing");
 
-        const char *zig_version = "0.14.0-dev.1622+2ac543388";
+        const char *zig_version = "0.14.0-dev.1876+41dbd0d0d";
 
         int written = fprintf(f,
             "pub const have_llvm = false;\n"
@@ -170,9 +170,7 @@ int main(int argc, char **argv) {
             "-ofmt=c", "-OReleaseSmall",
             "--name", "compiler_rt", "-femit-bin=compiler_rt.c",
             "-target", host_triple,
-            "--dep", "build_options",
             "-Mroot=lib/compiler_rt.zig",
-            "-Mbuild_options=config.zig",
             NULL,
         };
         print_and_run(child_argv);
diff --git a/zig/build.zig b/zig/build.zig
index 731b825c07..a5f4cd5675 100644
--- a/zig/build.zig
+++ b/zig/build.zig
@@ -577,6 +577,10 @@ pub fn build(b: *std.Build) !void {
     } else {
         update_mingw_step.dependOn(&b.addFail("The -Dmingw-src=... option is required for this step").step);
     }
+
+    const test_incremental_step = b.step("test-incremental", "Run the incremental compilation test cases");
+    try tests.addIncrementalTests(b, test_incremental_step);
+    test_step.dependOn(test_incremental_step);
 }
 
 fn addWasiUpdateStep(b: *std.Build, version: [:0]const u8) !void {
diff --git a/zig/doc/langref.html.in b/zig/doc/langref.html.in
index 9f12829349..54b923d0d9 100644
--- a/zig/doc/langref.html.in
+++ b/zig/doc/langref.html.in
@@ -4218,11 +4218,10 @@ pub fn print(self: *Writer, arg0: []const u8, arg1: i32) !void {
       {#header_close#}
 
       {#header_open|Atomics#}
-      <p>TODO: @fence()</p>
       <p>TODO: @atomic rmw</p>
       <p>TODO: builtin atomic memory ordering enum</p>
 
-      {#see_also|@atomicLoad|@atomicStore|@atomicRmw|@fence|@cmpxchgWeak|@cmpxchgStrong#}
+      {#see_also|@atomicLoad|@atomicStore|@atomicRmw|@cmpxchgWeak|@cmpxchgStrong#}
 
       {#header_close#}
 
@@ -4307,7 +4306,7 @@ comptime {
       an integer or an enum.
       </p>
       <p>{#syntax#}AtomicOrder{#endsyntax#} can be found with {#syntax#}@import("std").builtin.AtomicOrder{#endsyntax#}.</p>
-      {#see_also|@atomicStore|@atomicRmw|@fence|@cmpxchgWeak|@cmpxchgStrong#}
+      {#see_also|@atomicStore|@atomicRmw||@cmpxchgWeak|@cmpxchgStrong#}
       {#header_close#}
 
       {#header_open|@atomicRmw#}
@@ -4322,7 +4321,7 @@ comptime {
       </p>
       <p>{#syntax#}AtomicOrder{#endsyntax#} can be found with {#syntax#}@import("std").builtin.AtomicOrder{#endsyntax#}.</p>
       <p>{#syntax#}AtomicRmwOp{#endsyntax#} can be found with {#syntax#}@import("std").builtin.AtomicRmwOp{#endsyntax#}.</p>
-      {#see_also|@atomicStore|@atomicLoad|@fence|@cmpxchgWeak|@cmpxchgStrong#}
+      {#see_also|@atomicStore|@atomicLoad|@cmpxchgWeak|@cmpxchgStrong#}
       {#header_close#}
 
       {#header_open|@atomicStore#}
@@ -4335,7 +4334,7 @@ comptime {
       an integer or an enum.
       </p>
       <p>{#syntax#}AtomicOrder{#endsyntax#} can be found with {#syntax#}@import("std").builtin.AtomicOrder{#endsyntax#}.</p>
-      {#see_also|@atomicLoad|@atomicRmw|@fence|@cmpxchgWeak|@cmpxchgStrong#}
+      {#see_also|@atomicLoad|@atomicRmw|@cmpxchgWeak|@cmpxchgStrong#}
       {#header_close#}
 
       {#header_open|@bitCast#}
@@ -4568,7 +4567,7 @@ comptime {
       </p>
       <p>{#syntax#}@typeInfo(@TypeOf(ptr)).pointer.alignment{#endsyntax#} must be {#syntax#}>= @sizeOf(T).{#endsyntax#}</p>
       <p>{#syntax#}AtomicOrder{#endsyntax#} can be found with {#syntax#}@import("std").builtin.AtomicOrder{#endsyntax#}.</p>
-      {#see_also|@atomicStore|@atomicLoad|@atomicRmw|@fence|@cmpxchgWeak#}
+      {#see_also|@atomicStore|@atomicLoad|@atomicRmw|@cmpxchgWeak#}
       {#header_close#}
 
       {#header_open|@cmpxchgWeak#}
@@ -4600,7 +4599,7 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val
       </p>
       <p>{#syntax#}@typeInfo(@TypeOf(ptr)).pointer.alignment{#endsyntax#} must be {#syntax#}>= @sizeOf(T).{#endsyntax#}</p>
       <p>{#syntax#}AtomicOrder{#endsyntax#} can be found with {#syntax#}@import("std").builtin.AtomicOrder{#endsyntax#}.</p>
-      {#see_also|@atomicStore|@atomicLoad|@atomicRmw|@fence|@cmpxchgStrong#}
+      {#see_also|@atomicStore|@atomicLoad|@atomicRmw|@cmpxchgStrong#}
       {#header_close#}
 
       {#header_open|@compileError#}
@@ -4766,10 +4765,10 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val
       Converts an integer into an {#link|enum#} value. The return type is the inferred result type.
       </p>
       <p>
-      Attempting to convert an integer with no corresponding value in the enum invokes 
+      Attempting to convert an integer with no corresponding value in the enum invokes
       safety-checked {#link|Undefined Behavior#}.
       Note that a {#link|non-exhaustive enum|Non-exhaustive enum#} has corresponding values for all
-      integers in the enum's integer tag type: the {#syntax#}_{#endsyntax#} value represents all 
+      integers in the enum's integer tag type: the {#syntax#}_{#endsyntax#} value represents all
       the remaining unnamed integers in the enum's tag type.
       </p>
       {#see_also|@intFromEnum#}
@@ -4857,15 +4856,6 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val
       {#see_also|@export#}
       {#header_close#}
 
-      {#header_open|@fence#}
-      <pre>{#syntax#}@fence(order: AtomicOrder) void{#endsyntax#}</pre>
-      <p>
-      The {#syntax#}fence{#endsyntax#} function is used to introduce happens-before edges between operations.
-      </p>
-      <p>{#syntax#}AtomicOrder{#endsyntax#} can be found with {#syntax#}@import("std").builtin.AtomicOrder{#endsyntax#}.</p>
-      {#see_also|@atomicStore|@atomicLoad|@atomicRmw|@cmpxchgWeak|@cmpxchgStrong#}
-      {#header_close#}
-
       {#header_open|@field#}
       <pre>{#syntax#}@field(lhs: anytype, comptime field_name: []const u8) (field){#endsyntax#}</pre>
       <p>Performs field access by a compile-time string. Works on both fields and declarations.
@@ -6241,11 +6231,13 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val
           </li>
           <li>Are you linking libc? In this case, {#syntax#}std.heap.c_allocator{#endsyntax#} is likely
               the right choice, at least for your main allocator.</li>
+          <li>
+              Need to use the same allocator in multiple threads? Use one of your choice
+              wrapped around {#syntax#}std.heap.ThreadSafeAllocator{#endsyntax#}
+          </li>
           <li>
               Is the maximum number of bytes that you will need bounded by a number known at
-              {#link|comptime#}? In this case, use {#syntax#}std.heap.FixedBufferAllocator{#endsyntax#} or
-              {#syntax#}std.heap.ThreadSafeFixedBufferAllocator{#endsyntax#} depending on whether you need
-              thread-safety or not.
+              {#link|comptime#}? In this case, use {#syntax#}std.heap.FixedBufferAllocator{#endsyntax#}.
           </li>
           <li>
               Is your program a command line application which runs from start to end without any fundamental
diff --git a/zig/lib/compiler/aro/aro/Compilation.zig b/zig/lib/compiler/aro/aro/Compilation.zig
index 22ca9c00ed..414cdb45f0 100644
--- a/zig/lib/compiler/aro/aro/Compilation.zig
+++ b/zig/lib/compiler/aro/aro/Compilation.zig
@@ -308,7 +308,7 @@ fn generateSystemDefines(comp: *Compilation, w: anytype) !void {
         ),
         else => {},
     }
-    if (comp.target.abi == .android) {
+    if (comp.target.isAndroid()) {
         try w.writeAll("#define __ANDROID__ 1\n");
     }
 
diff --git a/zig/lib/compiler/aro/aro/target.zig b/zig/lib/compiler/aro/aro/target.zig
index b84788429a..c07935a420 100644
--- a/zig/lib/compiler/aro/aro/target.zig
+++ b/zig/lib/compiler/aro/aro/target.zig
@@ -482,7 +482,6 @@ pub fn get32BitArchVariant(target: std.Target) ?std.Target {
         .spirv,
         .spirv32,
         .loongarch32,
-        .dxil,
         .xtensa,
         => {}, // Already 32 bit
 
@@ -509,7 +508,6 @@ pub fn get64BitArchVariant(target: std.Target) ?std.Target {
         .arc,
         .avr,
         .csky,
-        .dxil,
         .hexagon,
         .kalimba,
         .lanai,
@@ -578,7 +576,6 @@ pub fn toLLVMTriple(target: std.Target, buf: []u8) []const u8 {
         .bpfel => "bpfel",
         .bpfeb => "bpfeb",
         .csky => "csky",
-        .dxil => "dxil",
         .hexagon => "hexagon",
         .loongarch32 => "loongarch32",
         .loongarch64 => "loongarch64",
@@ -655,7 +652,6 @@ pub fn toLLVMTriple(target: std.Target, buf: []u8) []const u8 {
         .tvos => "tvos",
         .watchos => "watchos",
         .driverkit => "driverkit",
-        .shadermodel => "shadermodel",
         .visionos => "xros",
         .serenity => "serenity",
         .bridgeos => "bridgeos",
@@ -693,6 +689,7 @@ pub fn toLLVMTriple(target: std.Target, buf: []u8) []const u8 {
         .eabi => "eabi",
         .eabihf => "eabihf",
         .android => "android",
+        .androideabi => "androideabi",
         .musl => "musl",
         .musleabi => "musleabi",
         .musleabihf => "musleabihf",
@@ -702,22 +699,8 @@ pub fn toLLVMTriple(target: std.Target, buf: []u8) []const u8 {
         .cygnus => "cygnus",
         .simulator => "simulator",
         .macabi => "macabi",
-        .pixel => "pixel",
-        .vertex => "vertex",
-        .geometry => "geometry",
-        .hull => "hull",
-        .domain => "domain",
-        .compute => "compute",
-        .library => "library",
-        .raygeneration => "raygeneration",
-        .intersection => "intersection",
-        .anyhit => "anyhit",
-        .closesthit => "closesthit",
-        .miss => "miss",
-        .callable => "callable",
-        .mesh => "mesh",
-        .amplification => "amplification",
-        .ohos => "openhos",
+        .ohos => "ohos",
+        .ohoseabi => "ohoseabi",
     };
     writer.writeAll(llvm_abi) catch unreachable;
     return stream.getWritten();
diff --git a/zig/lib/compiler/fmt.zig b/zig/lib/compiler/fmt.zig
index c747addd72..5a4f112c34 100644
--- a/zig/lib/compiler/fmt.zig
+++ b/zig/lib/compiler/fmt.zig
@@ -207,6 +207,7 @@ const FmtError = error{
     LockViolation,
     NetNameDeleted,
     InvalidArgument,
+    ProcessNotFound,
 } || fs.File.OpenError;
 
 fn fmtPath(fmt: *Fmt, file_path: []const u8, check_mode: bool, dir: fs.Dir, sub_path: []const u8) FmtError!void {
diff --git a/zig/lib/compiler/objcopy.zig b/zig/lib/compiler/objcopy.zig
index ac609c94e5..9794671e6f 100644
--- a/zig/lib/compiler/objcopy.zig
+++ b/zig/lib/compiler/objcopy.zig
@@ -40,6 +40,9 @@ fn cmdObjCopy(
     var only_keep_debug: bool = false;
     var compress_debug_sections: bool = false;
     var listen = false;
+    var add_section: ?AddSection = null;
+    var set_section_alignment: ?SetSectionAlignment = null;
+    var set_section_flags: ?SetSectionFlags = null;
     while (i < args.len) : (i += 1) {
         const arg = args[i];
         if (!mem.startsWith(u8, arg, "-")) {
@@ -104,6 +107,37 @@ fn cmdObjCopy(
             i += 1;
             if (i >= args.len) fatal("expected another argument after '{s}'", .{arg});
             opt_extract = args[i];
+        } else if (mem.eql(u8, arg, "--set-section-alignment")) {
+            i += 1;
+            if (i >= args.len) fatal("expected section name and alignment arguments after '{s}'", .{arg});
+
+            if (splitOption(args[i])) |split| {
+                const alignment = std.fmt.parseInt(u32, split.second, 10) catch |err| {
+                    fatal("unable to parse alignment number: '{s}': {s}", .{ split.second, @errorName(err) });
+                };
+                if (!std.math.isPowerOfTwo(alignment)) fatal("alignment must be a power of two", .{});
+                set_section_alignment = .{ .section_name = split.first, .alignment = alignment };
+            } else {
+                fatal("unrecognized argument: '{s}', expecting <name>=<alignment>", .{args[i]});
+            }
+        } else if (mem.eql(u8, arg, "--set-section-flags")) {
+            i += 1;
+            if (i >= args.len) fatal("expected section name and filename arguments after '{s}'", .{arg});
+
+            if (splitOption(args[i])) |split| {
+                set_section_flags = .{ .section_name = split.first, .flags = parseSectionFlags(split.second) };
+            } else {
+                fatal("unrecognized argument: '{s}', expecting <name>=<flags>", .{args[i]});
+            }
+        } else if (mem.eql(u8, arg, "--add-section")) {
+            i += 1;
+            if (i >= args.len) fatal("expected section name and filename arguments after '{s}'", .{arg});
+
+            if (splitOption(args[i])) |split| {
+                add_section = .{ .section_name = split.first, .file_path = split.second };
+            } else {
+                fatal("unrecognized argument: '{s}', expecting <name>=<file>", .{args[i]});
+            }
         } else {
             fatal("unrecognized argument: '{s}'", .{arg});
         }
@@ -151,6 +185,12 @@ fn cmdObjCopy(
                 fatal("zig objcopy: ELF to RAW or HEX copying does not support --strip", .{});
             if (opt_extract != null)
                 fatal("zig objcopy: ELF to RAW or HEX copying does not support --extract-to", .{});
+            if (add_section != null)
+                fatal("zig objcopy: ELF to RAW or HEX copying does not support --add-section", .{});
+            if (set_section_alignment != null)
+                fatal("zig objcopy: ELF to RAW or HEX copying does not support --set_section_alignment", .{});
+            if (set_section_flags != null)
+                fatal("zig objcopy: ELF to RAW or HEX copying does not support --set_section_flags", .{});
 
             try emitElf(arena, in_file, out_file, elf_hdr, .{
                 .ofmt = out_fmt,
@@ -175,6 +215,9 @@ fn cmdObjCopy(
                 .add_debuglink = opt_add_debuglink,
                 .extract_to = opt_extract,
                 .compress_debug = compress_debug_sections,
+                .add_section = add_section,
+                .set_section_alignment = set_section_alignment,
+                .set_section_flags = set_section_flags,
             });
             return std.process.cleanExit();
         },
@@ -217,18 +260,21 @@ const usage =
     \\Usage: zig objcopy [options] input output
     \\
     \\Options:
-    \\  -h, --help                  Print this help and exit
-    \\  --output-target=<value>     Format of the output file
-    \\  -O <value>                  Alias for --output-target
-    \\  --only-section=<section>    Remove all but <section>
-    \\  -j <value>                  Alias for --only-section
-    \\  --pad-to <addr>             Pad the last section up to address <addr>
-    \\  --strip-debug, -g           Remove all debug sections from the output.
-    \\  --strip-all, -S             Remove all debug sections and symbol table from the output.
-    \\  --only-keep-debug           Strip a file, removing contents of any sections that would not be stripped by --strip-debug and leaving the debugging sections intact.
-    \\  --add-gnu-debuglink=<file>  Creates a .gnu_debuglink section which contains a reference to <file> and adds it to the output file.
-    \\  --extract-to <file>         Extract the removed sections into <file>, and add a .gnu-debuglink section.
-    \\  --compress-debug-sections   Compress DWARF debug sections with zlib
+    \\  -h, --help                              Print this help and exit
+    \\  --output-target=<value>                 Format of the output file
+    \\  -O <value>                              Alias for --output-target
+    \\  --only-section=<section>                Remove all but <section>
+    \\  -j <value>                              Alias for --only-section
+    \\  --pad-to <addr>                         Pad the last section up to address <addr>
+    \\  --strip-debug, -g                       Remove all debug sections from the output.
+    \\  --strip-all, -S                         Remove all debug sections and symbol table from the output.
+    \\  --only-keep-debug                       Strip a file, removing contents of any sections that would not be stripped by --strip-debug and leaving the debugging sections intact.
+    \\  --add-gnu-debuglink=<file>              Creates a .gnu_debuglink section which contains a reference to <file> and adds it to the output file.
+    \\  --extract-to <file>                     Extract the removed sections into <file>, and add a .gnu-debuglink section.
+    \\  --compress-debug-sections               Compress DWARF debug sections with zlib
+    \\  --set-section-alignment <name>=<align>  Set alignment of section <name> to <align> bytes. Must be a power of two.
+    \\  --set-section-flags <name>=<file>       Set flags of section <name> to <flags> represented as a comma separated set of flags.
+    \\  --add-section <name>=<file>             Add file content from <file> with the a new section named <name>.
     \\
 ;
 
@@ -236,6 +282,24 @@ pub const EmitRawElfOptions = struct {
     ofmt: std.Target.ObjectFormat,
     only_section: ?[]const u8 = null,
     pad_to: ?u64 = null,
+    add_section: ?AddSection = null,
+    set_section_alignment: ?SetSectionAlignment = null,
+    set_section_flags: ?SetSectionFlags = null,
+};
+
+const AddSection = struct {
+    section_name: []const u8,
+    file_path: []const u8,
+};
+
+const SetSectionAlignment = struct {
+    section_name: []const u8,
+    alignment: u32,
+};
+
+const SetSectionFlags = struct {
+    section_name: []const u8,
+    flags: SectionFlags,
 };
 
 fn emitElf(
@@ -392,7 +456,7 @@ const BinaryElfOutput = struct {
             if (phdr.p_type == elf.PT_LOAD) {
                 const newSegment = try allocator.create(BinaryElfSegment);
 
-                newSegment.physicalAddress = if (phdr.p_paddr != 0) phdr.p_paddr else phdr.p_vaddr;
+                newSegment.physicalAddress = phdr.p_paddr;
                 newSegment.virtualAddress = phdr.p_vaddr;
                 newSegment.fileSize = @intCast(phdr.p_filesz);
                 newSegment.elfOffset = phdr.p_offset;
@@ -678,6 +742,9 @@ const StripElfOptions = struct {
     strip_debug: bool = false,
     only_keep_debug: bool = false,
     compress_debug: bool = false,
+    add_section: ?AddSection,
+    set_section_alignment: ?SetSectionAlignment,
+    set_section_flags: ?SetSectionFlags,
 };
 
 fn stripElf(
@@ -721,6 +788,14 @@ fn stripElf(
             var elf_file = try ElfFile(is_64).parse(allocator, in_file, elf_hdr);
             defer elf_file.deinit();
 
+            if (options.add_section) |user_section| {
+                for (elf_file.sections) |section| {
+                    if (std.mem.eql(u8, section.name, user_section.section_name)) {
+                        fatal("zig objcopy: unable to add section '{s}'. Section already exists in input", .{user_section.section_name});
+                    }
+                }
+            }
+
             if (filter_complement) |flt| {
                 // write the .dbg file and close it, so it can be read back to compute the debuglink checksum.
                 const path = options.extract_to.?;
@@ -733,7 +808,14 @@ fn stripElf(
             }
 
             const debuglink: ?DebugLink = if (debuglink_path) |path| ElfFileHelper.createDebugLink(path) else null;
-            try elf_file.emit(allocator, out_file, in_file, .{ .section_filter = filter, .debuglink = debuglink, .compress_debug = options.compress_debug });
+            try elf_file.emit(allocator, out_file, in_file, .{
+                .section_filter = filter,
+                .debuglink = debuglink,
+                .compress_debug = options.compress_debug,
+                .add_section = options.add_section,
+                .set_section_alignment = options.set_section_alignment,
+                .set_section_flags = options.set_section_flags,
+            });
         },
     }
 }
@@ -786,7 +868,7 @@ fn ElfFile(comptime is_64: bool) type {
             // program header: list of segments
             const program_segments = blk: {
                 if (@sizeOf(Elf_Phdr) != header.phentsize)
-                    fatal("zig objcopy: unsuported ELF file, unexpected phentsize ({d})", .{header.phentsize});
+                    fatal("zig objcopy: unsupported ELF file, unexpected phentsize ({d})", .{header.phentsize});
 
                 const program_header = try allocator.alloc(Elf_Phdr, header.phnum);
                 const bytes_read = try in_file.preadAll(std.mem.sliceAsBytes(program_header), header.phoff);
@@ -798,7 +880,7 @@ fn ElfFile(comptime is_64: bool) type {
             // section header
             const sections = blk: {
                 if (@sizeOf(Elf_Shdr) != header.shentsize)
-                    fatal("zig objcopy: unsuported ELF file, unexpected shentsize ({d})", .{header.shentsize});
+                    fatal("zig objcopy: unsupported ELF file, unexpected shentsize ({d})", .{header.shentsize});
 
                 const section_header = try allocator.alloc(Section, header.shnum);
 
@@ -896,6 +978,9 @@ fn ElfFile(comptime is_64: bool) type {
             section_filter: Filter = .all,
             debuglink: ?DebugLink = null,
             compress_debug: bool = false,
+            add_section: ?AddSection = null,
+            set_section_alignment: ?SetSectionAlignment = null,
+            set_section_flags: ?SetSectionFlags = null,
         };
         fn emit(self: *const Self, gpa: Allocator, out_file: File, in_file: File, options: EmitElfOptions) !void {
             var arena = std.heap.ArenaAllocator.init(gpa);
@@ -934,6 +1019,10 @@ fn ElfFile(comptime is_64: bool) type {
                 if (options.debuglink != null)
                     next_idx += 1;
 
+                if (options.add_section != null) {
+                    next_idx += 1;
+                }
+
                 break :blk next_idx;
             };
 
@@ -959,6 +1048,28 @@ fn ElfFile(comptime is_64: bool) type {
                 break :blk new_offset;
             };
 
+            // add user section to the string table if needed
+            const user_section_name: u32 = blk: {
+                if (options.add_section == null) break :blk elf.SHN_UNDEF;
+                if (self.raw_elf_header.e_shstrndx == elf.SHN_UNDEF)
+                    fatal("zig objcopy: no strtab, cannot add the user section", .{}); // TODO add the section if needed?
+
+                const strtab = &self.sections[self.raw_elf_header.e_shstrndx];
+                const update = &sections_update[self.raw_elf_header.e_shstrndx];
+
+                const name = options.add_section.?.section_name;
+                const new_offset: u32 = @intCast(strtab.payload.?.len);
+                const buf = try allocator.alignedAlloc(u8, section_memory_align, new_offset + name.len + 1);
+                @memcpy(buf[0..new_offset], strtab.payload.?);
+                @memcpy(buf[new_offset..][0..name.len], name);
+                buf[new_offset + name.len] = 0;
+
+                assert(update.action == .keep);
+                update.payload = buf;
+
+                break :blk new_offset;
+            };
+
             // maybe compress .debug sections
             if (options.compress_debug) {
                 for (self.sections[1..], sections_update[1..]) |section, *update| {
@@ -1018,7 +1129,7 @@ fn ElfFile(comptime is_64: bool) type {
                         if (section.section.sh_type == elf.SHT_NOBITS)
                             continue;
                         if (section.section.sh_offset < offset) {
-                            fatal("zig objcopy: unsuported ELF file", .{});
+                            fatal("zig objcopy: unsupported ELF file", .{});
                         }
                         offset = section.section.sh_offset;
                     }
@@ -1134,10 +1245,100 @@ fn ElfFile(comptime is_64: bool) type {
                     eof_offset += @as(Elf_OffSize, @intCast(payload.len));
                 }
 
+                // --add-section
+                if (options.add_section) |add_section| {
+                    var section_file = fs.cwd().openFile(add_section.file_path, .{}) catch |err|
+                        fatal("unable to open '{s}': {s}", .{ add_section.file_path, @errorName(err) });
+                    defer section_file.close();
+
+                    const payload = try section_file.readToEndAlloc(arena.allocator(), std.math.maxInt(usize));
+
+                    dest_sections[dest_section_idx] = Elf_Shdr{
+                        .sh_name = user_section_name,
+                        .sh_type = elf.SHT_PROGBITS,
+                        .sh_flags = 0,
+                        .sh_addr = 0,
+                        .sh_offset = eof_offset,
+                        .sh_size = @intCast(payload.len),
+                        .sh_link = elf.SHN_UNDEF,
+                        .sh_info = elf.SHN_UNDEF,
+                        .sh_addralign = 4,
+                        .sh_entsize = 0,
+                    };
+                    dest_section_idx += 1;
+
+                    cmdbuf.appendAssumeCapacity(.{ .write_data = .{ .data = payload, .out_offset = eof_offset } });
+                    eof_offset += @as(Elf_OffSize, @intCast(payload.len));
+                }
+
                 assert(dest_section_idx == new_shnum);
                 break :blk dest_sections;
             };
 
+            // --set-section-alignment: overwrite alignment
+            if (options.set_section_alignment) |set_align| {
+                if (self.raw_elf_header.e_shstrndx == elf.SHN_UNDEF)
+                    fatal("zig objcopy: no strtab, cannot add the user section", .{}); // TODO add the section if needed?
+
+                const strtab = &sections_update[self.raw_elf_header.e_shstrndx];
+                for (updated_section_header) |*section| {
+                    const section_name = std.mem.span(@as([*:0]const u8, @ptrCast(&strtab.payload.?[section.sh_name])));
+                    if (std.mem.eql(u8, section_name, set_align.section_name)) {
+                        section.sh_addralign = set_align.alignment;
+                        break;
+                    }
+                } else std.log.warn("Skipping --set-section-alignment. Section '{s}' not found", .{set_align.section_name});
+            }
+
+            // --set-section-flags: overwrite flags
+            if (options.set_section_flags) |set_flags| {
+                if (self.raw_elf_header.e_shstrndx == elf.SHN_UNDEF)
+                    fatal("zig objcopy: no strtab, cannot add the user section", .{}); // TODO add the section if needed?
+
+                const strtab = &sections_update[self.raw_elf_header.e_shstrndx];
+                for (updated_section_header) |*section| {
+                    const section_name = std.mem.span(@as([*:0]const u8, @ptrCast(&strtab.payload.?[section.sh_name])));
+                    if (std.mem.eql(u8, section_name, set_flags.section_name)) {
+                        section.sh_flags = std.elf.SHF_WRITE; // default is writable cleared by "readonly"
+                        const f = set_flags.flags;
+
+                        // Supporting a subset of GNU and LLVM objcopy for ELF only
+                        // GNU:
+                        // alloc: add SHF_ALLOC
+                        // contents: if section is SHT_NOBITS, set SHT_PROGBITS, otherwise do nothing
+                        // load: if section is SHT_NOBITS, set SHT_PROGBITS, otherwise do nothing (same as contents)
+                        // noload: not ELF relevant
+                        // readonly: clear default SHF_WRITE flag
+                        // code: add SHF_EXECINSTR
+                        // data: not ELF relevant
+                        // rom: ignored
+                        // exclude: add SHF_EXCLUDE
+                        // share: not ELF relevant
+                        // debug: not ELF relevant
+                        // large: add SHF_X86_64_LARGE. Fatal error if target is not x86_64
+                        if (f.alloc) section.sh_flags |= std.elf.SHF_ALLOC;
+                        if (f.contents or f.load) {
+                            if (section.sh_type == std.elf.SHT_NOBITS) section.sh_type = std.elf.SHT_PROGBITS;
+                        }
+                        if (f.readonly) section.sh_flags &= ~@as(@TypeOf(section.sh_type), std.elf.SHF_WRITE);
+                        if (f.code) section.sh_flags |= std.elf.SHF_EXECINSTR;
+                        if (f.exclude) section.sh_flags |= std.elf.SHF_EXCLUDE;
+                        if (f.large) {
+                            if (updated_elf_header.e_machine != std.elf.EM.X86_64)
+                                fatal("zig objcopy: 'large' section flag is only supported on x86_64 targets", .{});
+                            section.sh_flags |= std.elf.SHF_X86_64_LARGE;
+                        }
+
+                        // LLVM:
+                        // merge: add SHF_MERGE
+                        // strings: add SHF_STRINGS
+                        if (f.merge) section.sh_flags |= std.elf.SHF_MERGE;
+                        if (f.strings) section.sh_flags |= std.elf.SHF_STRINGS;
+                        break;
+                    }
+                } else std.log.warn("Skipping --set-section-flags. Section '{s}' not found", .{set_flags.section_name});
+            }
+
             // write the section header at the tail
             {
                 const offset = std.mem.alignForward(Elf_OffSize, eof_offset, @alignOf(Elf_Shdr));
@@ -1361,3 +1562,111 @@ const ElfFileHelper = struct {
         return hasher.final();
     }
 };
+
+const SectionFlags = packed struct {
+    alloc: bool = false,
+    contents: bool = false,
+    load: bool = false,
+    noload: bool = false,
+    readonly: bool = false,
+    code: bool = false,
+    data: bool = false,
+    rom: bool = false,
+    exclude: bool = false,
+    shared: bool = false,
+    debug: bool = false,
+    large: bool = false,
+    merge: bool = false,
+    strings: bool = false,
+};
+
+fn parseSectionFlags(comma_separated_flags: []const u8) SectionFlags {
+    const P = struct {
+        fn parse(flags: *SectionFlags, string: []const u8) void {
+            if (string.len == 0) return;
+
+            if (std.mem.eql(u8, string, "alloc")) {
+                flags.alloc = true;
+            } else if (std.mem.eql(u8, string, "contents")) {
+                flags.contents = true;
+            } else if (std.mem.eql(u8, string, "load")) {
+                flags.load = true;
+            } else if (std.mem.eql(u8, string, "noload")) {
+                flags.noload = true;
+            } else if (std.mem.eql(u8, string, "readonly")) {
+                flags.readonly = true;
+            } else if (std.mem.eql(u8, string, "code")) {
+                flags.code = true;
+            } else if (std.mem.eql(u8, string, "data")) {
+                flags.data = true;
+            } else if (std.mem.eql(u8, string, "rom")) {
+                flags.rom = true;
+            } else if (std.mem.eql(u8, string, "exclude")) {
+                flags.exclude = true;
+            } else if (std.mem.eql(u8, string, "shared")) {
+                flags.shared = true;
+            } else if (std.mem.eql(u8, string, "debug")) {
+                flags.debug = true;
+            } else if (std.mem.eql(u8, string, "large")) {
+                flags.large = true;
+            } else if (std.mem.eql(u8, string, "merge")) {
+                flags.merge = true;
+            } else if (std.mem.eql(u8, string, "strings")) {
+                flags.strings = true;
+            } else {
+                std.log.warn("Skipping unrecognized section flag '{s}'", .{string});
+            }
+        }
+    };
+
+    var flags = SectionFlags{};
+    var offset: usize = 0;
+    for (comma_separated_flags, 0..) |c, i| {
+        if (c == ',') {
+            defer offset = i + 1;
+            const string = comma_separated_flags[offset..i];
+            P.parse(&flags, string);
+        }
+    }
+    P.parse(&flags, comma_separated_flags[offset..]);
+    return flags;
+}
+
+test "Parse section flags" {
+    const F = SectionFlags;
+    try std.testing.expectEqual(F{}, parseSectionFlags(""));
+    try std.testing.expectEqual(F{}, parseSectionFlags(","));
+    try std.testing.expectEqual(F{}, parseSectionFlags("abc"));
+    try std.testing.expectEqual(F{ .alloc = true }, parseSectionFlags("alloc"));
+    try std.testing.expectEqual(F{ .data = true }, parseSectionFlags("data,"));
+    try std.testing.expectEqual(F{ .alloc = true, .code = true }, parseSectionFlags("alloc,code"));
+    try std.testing.expectEqual(F{ .alloc = true, .code = true }, parseSectionFlags("alloc,code,not_supported"));
+}
+
+const SplitResult = struct { first: []const u8, second: []const u8 };
+
+fn splitOption(option: []const u8) ?SplitResult {
+    const separator = '=';
+    if (option.len < 3) return null; // minimum "a=b"
+    for (1..option.len - 1) |i| {
+        if (option[i] == separator) return .{
+            .first = option[0..i],
+            .second = option[i + 1 ..],
+        };
+    }
+    return null;
+}
+
+test "Split option" {
+    {
+        const split = splitOption(".abc=123");
+        try std.testing.expect(split != null);
+        try std.testing.expectEqualStrings(".abc", split.?.first);
+        try std.testing.expectEqualStrings("123", split.?.second);
+    }
+
+    try std.testing.expectEqual(null, splitOption(""));
+    try std.testing.expectEqual(null, splitOption("=abc"));
+    try std.testing.expectEqual(null, splitOption("abc="));
+    try std.testing.expectEqual(null, splitOption("abc"));
+}
diff --git a/zig/lib/compiler_rt/aulldiv.zig b/zig/lib/compiler_rt/aulldiv.zig
index 21ec61722b..6d822b7b86 100644
--- a/zig/lib/compiler_rt/aulldiv.zig
+++ b/zig/lib/compiler_rt/aulldiv.zig
@@ -1,13 +1,14 @@
 const std = @import("std");
 const builtin = @import("builtin");
 const arch = builtin.cpu.arch;
+const os = builtin.os.tag;
 const abi = builtin.abi;
 const common = @import("common.zig");
 
 pub const panic = common.panic;
 
 comptime {
-    if (arch == .x86 and abi == .msvc and builtin.zig_backend != .stage2_c) {
+    if (arch == .x86 and os == .windows and (abi == .msvc or abi == .itanium) and builtin.zig_backend != .stage2_c) {
         // Don't let LLVM apply the stdcall name mangling on those MSVC builtins
         @export(&_alldiv, .{ .name = "\x01__alldiv", .linkage = common.linkage, .visibility = common.visibility });
         @export(&_aulldiv, .{ .name = "\x01__aulldiv", .linkage = common.linkage, .visibility = common.visibility });
diff --git a/zig/lib/compiler_rt/aullrem.zig b/zig/lib/compiler_rt/aullrem.zig
index c1578aeb8b..5c4d0588f7 100644
--- a/zig/lib/compiler_rt/aullrem.zig
+++ b/zig/lib/compiler_rt/aullrem.zig
@@ -1,13 +1,14 @@
 const std = @import("std");
 const builtin = @import("builtin");
 const arch = builtin.cpu.arch;
+const os = builtin.os.tag;
 const abi = builtin.abi;
 const common = @import("common.zig");
 
 pub const panic = common.panic;
 
 comptime {
-    if (arch == .x86 and abi == .msvc and builtin.zig_backend != .stage2_c) {
+    if (arch == .x86 and os == .windows and (abi == .msvc or abi == .itanium) and builtin.zig_backend != .stage2_c) {
         // Don't let LLVM apply the stdcall name mangling on those MSVC builtins
         @export(&_allrem, .{ .name = "\x01__allrem", .linkage = common.linkage, .visibility = common.visibility });
         @export(&_aullrem, .{ .name = "\x01__aullrem", .linkage = common.linkage, .visibility = common.visibility });
diff --git a/zig/lib/compiler_rt/common.zig b/zig/lib/compiler_rt/common.zig
index 1dfd4be07f..786dc7303a 100644
--- a/zig/lib/compiler_rt/common.zig
+++ b/zig/lib/compiler_rt/common.zig
@@ -1,8 +1,14 @@
 const std = @import("std");
 const builtin = @import("builtin");
 const native_endian = builtin.cpu.arch.endian();
+const ofmt_c = builtin.object_format == .c;
 
-pub const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .internal else .weak;
+pub const linkage: std.builtin.GlobalLinkage = if (builtin.is_test)
+    .internal
+else if (ofmt_c)
+    .strong
+else
+    .weak;
 /// Determines the symbol's visibility to other objects.
 /// For WebAssembly this allows the symbol to be resolved to other modules, but will not
 /// export it to the host runtime.
@@ -16,19 +22,22 @@ pub const want_aeabi = switch (builtin.abi) {
     .gnueabi,
     .gnueabihf,
     .android,
+    .androideabi,
     => switch (builtin.cpu.arch) {
         .arm, .armeb, .thumb, .thumbeb => true,
         else => false,
     },
     else => false,
 };
+pub const want_mingw_arm_abi = builtin.cpu.arch.isArmOrThumb() and builtin.target.isMinGW();
+
 pub const want_ppc_abi = builtin.cpu.arch.isPowerPC();
 
 pub const want_float_exceptions = !builtin.cpu.arch.isWasm();
 
 // Libcalls that involve u128 on Windows x86-64 are expected by LLVM to use the
 // calling convention of @Vector(2, u64), rather than what's standard.
-pub const want_windows_v2u64_abi = builtin.os.tag == .windows and builtin.cpu.arch == .x86_64 and @import("builtin").object_format != .c;
+pub const want_windows_v2u64_abi = builtin.os.tag == .windows and builtin.cpu.arch == .x86_64 and !ofmt_c;
 
 /// This governs whether to use these symbol names for f16/f32 conversions
 /// rather than the standard names:
@@ -67,13 +76,14 @@ pub const gnu_f16_abi = switch (builtin.cpu.arch) {
 
 pub const want_sparc_abi = builtin.cpu.arch.isSPARC();
 
-// Avoid dragging in the runtime safety mechanisms into this .o file,
-// unless we're trying to test compiler-rt.
-pub fn panic(msg: []const u8, error_return_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
-    _ = error_return_trace;
+// Avoid dragging in the runtime safety mechanisms into this .o file, unless
+// we're trying to test compiler-rt.
+pub const Panic = if (builtin.is_test) std.debug.FormattedPanic else struct {};
+
+/// To be deleted after zig1.wasm is updated.
+pub fn panic(msg: []const u8, error_return_trace: ?*std.builtin.StackTrace, ret_addr: ?usize) noreturn {
     if (builtin.is_test) {
-        @branchHint(.cold);
-        std.debug.panic("{s}", .{msg});
+        std.debug.defaultPanic(msg, error_return_trace, ret_addr orelse @returnAddress());
     } else {
         unreachable;
     }
diff --git a/zig/lib/compiler_rt/emutls.zig b/zig/lib/compiler_rt/emutls.zig
index 55927b8b37..b0244a14f5 100644
--- a/zig/lib/compiler_rt/emutls.zig
+++ b/zig/lib/compiler_rt/emutls.zig
@@ -18,7 +18,7 @@ const gcc_word = usize;
 pub const panic = common.panic;
 
 comptime {
-    if (builtin.link_libc and (builtin.abi == .android or builtin.os.tag == .openbsd)) {
+    if (builtin.link_libc and (builtin.abi.isAndroid() or builtin.os.tag == .openbsd)) {
         @export(&__emutls_get_address, .{ .name = "__emutls_get_address", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
diff --git a/zig/lib/compiler_rt/fixdfdi.zig b/zig/lib/compiler_rt/fixdfdi.zig
index 78744b145d..b9bc5797b9 100644
--- a/zig/lib/compiler_rt/fixdfdi.zig
+++ b/zig/lib/compiler_rt/fixdfdi.zig
@@ -1,3 +1,4 @@
+const builtin = @import("builtin");
 const common = @import("./common.zig");
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
 
@@ -8,6 +9,10 @@ comptime {
         @export(&__aeabi_d2lz, .{ .name = "__aeabi_d2lz", .linkage = common.linkage, .visibility = common.visibility });
     } else {
         @export(&__fixdfdi, .{ .name = "__fixdfdi", .linkage = common.linkage, .visibility = common.visibility });
+
+        if (common.want_mingw_arm_abi) {
+            @export(&__fixdfdi, .{ .name = "__dtoi64", .linkage = common.linkage, .visibility = common.visibility });
+        }
     }
 }
 
diff --git a/zig/lib/compiler_rt/fixsfdi.zig b/zig/lib/compiler_rt/fixsfdi.zig
index c75e401475..192614bd79 100644
--- a/zig/lib/compiler_rt/fixsfdi.zig
+++ b/zig/lib/compiler_rt/fixsfdi.zig
@@ -1,3 +1,4 @@
+const builtin = @import("builtin");
 const common = @import("./common.zig");
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
 
@@ -8,6 +9,10 @@ comptime {
         @export(&__aeabi_f2lz, .{ .name = "__aeabi_f2lz", .linkage = common.linkage, .visibility = common.visibility });
     } else {
         @export(&__fixsfdi, .{ .name = "__fixsfdi", .linkage = common.linkage, .visibility = common.visibility });
+
+        if (common.want_mingw_arm_abi) {
+            @export(&__fixsfdi, .{ .name = "__stoi64", .linkage = common.linkage, .visibility = common.visibility });
+        }
     }
 }
 
diff --git a/zig/lib/compiler_rt/fixunsdfdi.zig b/zig/lib/compiler_rt/fixunsdfdi.zig
index 68a0c44ff9..86a4fa9de1 100644
--- a/zig/lib/compiler_rt/fixunsdfdi.zig
+++ b/zig/lib/compiler_rt/fixunsdfdi.zig
@@ -1,3 +1,4 @@
+const builtin = @import("builtin");
 const common = @import("./common.zig");
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
 
@@ -8,6 +9,10 @@ comptime {
         @export(&__aeabi_d2ulz, .{ .name = "__aeabi_d2ulz", .linkage = common.linkage, .visibility = common.visibility });
     } else {
         @export(&__fixunsdfdi, .{ .name = "__fixunsdfdi", .linkage = common.linkage, .visibility = common.visibility });
+
+        if (common.want_mingw_arm_abi) {
+            @export(&__fixunsdfdi, .{ .name = "__dtou64", .linkage = common.linkage, .visibility = common.visibility });
+        }
     }
 }
 
diff --git a/zig/lib/compiler_rt/fixunssfdi.zig b/zig/lib/compiler_rt/fixunssfdi.zig
index 9157a71e2f..81d1c77f06 100644
--- a/zig/lib/compiler_rt/fixunssfdi.zig
+++ b/zig/lib/compiler_rt/fixunssfdi.zig
@@ -1,3 +1,4 @@
+const builtin = @import("builtin");
 const common = @import("./common.zig");
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
 
@@ -8,6 +9,10 @@ comptime {
         @export(&__aeabi_f2ulz, .{ .name = "__aeabi_f2ulz", .linkage = common.linkage, .visibility = common.visibility });
     } else {
         @export(&__fixunssfdi, .{ .name = "__fixunssfdi", .linkage = common.linkage, .visibility = common.visibility });
+
+        if (common.want_mingw_arm_abi) {
+            @export(&__fixunssfdi, .{ .name = "__stou64", .linkage = common.linkage, .visibility = common.visibility });
+        }
     }
 }
 
diff --git a/zig/lib/compiler_rt/floatdidf.zig b/zig/lib/compiler_rt/floatdidf.zig
index 393fa95c19..fc145e836d 100644
--- a/zig/lib/compiler_rt/floatdidf.zig
+++ b/zig/lib/compiler_rt/floatdidf.zig
@@ -1,3 +1,4 @@
+const builtin = @import("builtin");
 const common = @import("./common.zig");
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
@@ -8,6 +9,10 @@ comptime {
         @export(&__aeabi_l2d, .{ .name = "__aeabi_l2d", .linkage = common.linkage, .visibility = common.visibility });
     } else {
         @export(&__floatdidf, .{ .name = "__floatdidf", .linkage = common.linkage, .visibility = common.visibility });
+
+        if (common.want_mingw_arm_abi) {
+            @export(&__floatdidf, .{ .name = "__i64tod", .linkage = common.linkage, .visibility = common.visibility });
+        }
     }
 }
 
diff --git a/zig/lib/compiler_rt/floatdisf.zig b/zig/lib/compiler_rt/floatdisf.zig
index 4f3b42ef79..d1c9515f9a 100644
--- a/zig/lib/compiler_rt/floatdisf.zig
+++ b/zig/lib/compiler_rt/floatdisf.zig
@@ -1,3 +1,4 @@
+const builtin = @import("builtin");
 const common = @import("./common.zig");
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
@@ -8,6 +9,10 @@ comptime {
         @export(&__aeabi_l2f, .{ .name = "__aeabi_l2f", .linkage = common.linkage, .visibility = common.visibility });
     } else {
         @export(&__floatdisf, .{ .name = "__floatdisf", .linkage = common.linkage, .visibility = common.visibility });
+
+        if (common.want_mingw_arm_abi) {
+            @export(&__floatdisf, .{ .name = "__i64tos", .linkage = common.linkage, .visibility = common.visibility });
+        }
     }
 }
 
diff --git a/zig/lib/compiler_rt/floatundidf.zig b/zig/lib/compiler_rt/floatundidf.zig
index 5cb1de0d35..3448f0cf20 100644
--- a/zig/lib/compiler_rt/floatundidf.zig
+++ b/zig/lib/compiler_rt/floatundidf.zig
@@ -1,3 +1,4 @@
+const builtin = @import("builtin");
 const common = @import("./common.zig");
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
@@ -8,6 +9,10 @@ comptime {
         @export(&__aeabi_ul2d, .{ .name = "__aeabi_ul2d", .linkage = common.linkage, .visibility = common.visibility });
     } else {
         @export(&__floatundidf, .{ .name = "__floatundidf", .linkage = common.linkage, .visibility = common.visibility });
+
+        if (common.want_mingw_arm_abi) {
+            @export(&__floatundidf, .{ .name = "__u64tod", .linkage = common.linkage, .visibility = common.visibility });
+        }
     }
 }
 
diff --git a/zig/lib/compiler_rt/floatundisf.zig b/zig/lib/compiler_rt/floatundisf.zig
index 17f9148575..9054982b54 100644
--- a/zig/lib/compiler_rt/floatundisf.zig
+++ b/zig/lib/compiler_rt/floatundisf.zig
@@ -1,3 +1,4 @@
+const builtin = @import("builtin");
 const common = @import("./common.zig");
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
@@ -8,6 +9,10 @@ comptime {
         @export(&__aeabi_ul2f, .{ .name = "__aeabi_ul2f", .linkage = common.linkage, .visibility = common.visibility });
     } else {
         @export(&__floatundisf, .{ .name = "__floatundisf", .linkage = common.linkage, .visibility = common.visibility });
+
+        if (common.want_mingw_arm_abi) {
+            @export(&__floatundisf, .{ .name = "__u64tos", .linkage = common.linkage, .visibility = common.visibility });
+        }
     }
 }
 
diff --git a/zig/lib/libc/glibc/abilists b/zig/lib/libc/glibc/abilists
index 4e617973270d8c6fd227a4d35865cd7aa9a4bc07..3aed1e0f930ed2e4e9f6d558c1a42a9ec24eff14 100644
GIT binary patch
literal 246035
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
W;?=m}X^BlzC5qUfxotzb^#1^!{b`N>

literal 274738
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%0Dv}so_yXS*B=rXpyd(Pd
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
Lgc4wDeE<Idndd?c

diff --git a/zig/lib/libc/glibc/sysdeps/mips/mips32/crtn.S b/zig/lib/libc/glibc/sysdeps/mips/mips32/crtn.S
index 89ecbd9882..4fd4c745d9 100644
--- a/zig/lib/libc/glibc/sysdeps/mips/mips32/crtn.S
+++ b/zig/lib/libc/glibc/sysdeps/mips/mips32/crtn.S
@@ -42,7 +42,8 @@
 	lw $31,28($sp)
 	.set noreorder
 	.set nomacro
-	j $31
+	/* zig patch: j <reg> -> jr <reg> for https://github.com/ziglang/zig/issues/21315 */
+	jr $31
 	addiu $sp,$sp,32
 	.set macro
 	.set reorder
@@ -51,7 +52,8 @@
 	lw $31,28($sp)
 	.set noreorder
 	.set nomacro
-	j $31
+	/* zig patch: j <reg> -> jr <reg> for https://github.com/ziglang/zig/issues/21315 */
+	jr $31
 	addiu $sp,$sp,32
 	.set macro
 	.set reorder
diff --git a/zig/lib/libc/glibc/sysdeps/mips/mips64/n32/crtn.S b/zig/lib/libc/glibc/sysdeps/mips/mips64/n32/crtn.S
index 633d79cfad..f9a6c7ee4c 100644
--- a/zig/lib/libc/glibc/sysdeps/mips/mips64/n32/crtn.S
+++ b/zig/lib/libc/glibc/sysdeps/mips/mips64/n32/crtn.S
@@ -43,7 +43,8 @@
 	ld $28,0($sp)
 	.set noreorder
 	.set nomacro
-	j $31
+	/* zig patch: j <reg> -> jr <reg> for https://github.com/ziglang/zig/issues/21315 */
+	jr $31
 	addiu $sp,$sp,16
 	.set macro
 	.set reorder
@@ -53,7 +54,8 @@
 	ld $28,0($sp)
 	.set noreorder
 	.set nomacro
-	j $31
+	/* zig patch: j <reg> -> jr <reg> for https://github.com/ziglang/zig/issues/21315 */
+	jr $31
 	addiu $sp,$sp,16
 	.set macro
 	.set reorder
diff --git a/zig/lib/libc/glibc/sysdeps/mips/mips64/n64/crtn.S b/zig/lib/libc/glibc/sysdeps/mips/mips64/n64/crtn.S
index 99ed1e3263..2722b2812c 100644
--- a/zig/lib/libc/glibc/sysdeps/mips/mips64/n64/crtn.S
+++ b/zig/lib/libc/glibc/sysdeps/mips/mips64/n64/crtn.S
@@ -43,7 +43,8 @@
 	ld $28,0($sp)
 	.set noreorder
 	.set nomacro
-	j $31
+	/* zig patch: j <reg> -> jr <reg> for https://github.com/ziglang/zig/issues/21315 */
+	jr $31
 	daddiu $sp,$sp,16
 	.set macro
 	.set reorder
@@ -53,7 +54,8 @@
 	ld $28,0($sp)
 	.set noreorder
 	.set nomacro
-	j $31
+	/* zig patch: j <reg> -> jr <reg> for https://github.com/ziglang/zig/issues/21315 */
+	jr $31
 	daddiu $sp,$sp,16
 	.set macro
 	.set reorder
diff --git a/zig/lib/libc/glibc/sysdeps/unix/mips/sysdep.h b/zig/lib/libc/glibc/sysdeps/unix/mips/sysdep.h
index d1e0460260..54e92b26d0 100644
--- a/zig/lib/libc/glibc/sysdeps/unix/mips/sysdep.h
+++ b/zig/lib/libc/glibc/sysdeps/unix/mips/sysdep.h
@@ -39,7 +39,8 @@
 		.end	function;		        \
 		.size	function,.-function
 
-#define ret	j ra ; nop
+// zig patch: j <reg> -> jr <reg> for https://github.com/ziglang/zig/issues/21315
+#define ret	jr ra ; nop
 
 #undef PSEUDO_END
 #define PSEUDO_END(sym) cfi_endproc; .end sym; .size sym,.-sym
diff --git a/zig/lib/libc/include/loongarch64-linux-gnusf/bits/endianness.h b/zig/lib/libc/include/loongarch64-linux-gnusf/bits/endianness.h
new file mode 100644
index 0000000000..989463fb5d
--- /dev/null
+++ b/zig/lib/libc/include/loongarch64-linux-gnusf/bits/endianness.h
@@ -0,0 +1,11 @@
+#ifndef _BITS_ENDIANNESS_H
+#define _BITS_ENDIANNESS_H 1
+
+#ifndef _BITS_ENDIAN_H
+#error "Never use <bits/endianness.h> directly; include <endian.h> instead."
+#endif
+
+/* LoongArch is little-endian.  */
+#define __BYTE_ORDER __LITTLE_ENDIAN
+
+#endif /* bits/endianness.h */
\ No newline at end of file
diff --git a/zig/lib/libc/include/loongarch64-linux-gnusf/bits/fcntl.h b/zig/lib/libc/include/loongarch64-linux-gnusf/bits/fcntl.h
new file mode 100644
index 0000000000..bbbde65d43
--- /dev/null
+++ b/zig/lib/libc/include/loongarch64-linux-gnusf/bits/fcntl.h
@@ -0,0 +1,61 @@
+/* O_*, F_*, FD_* bit values for the generic Linux/LoongArch ABI.
+   Copyright (C) 2022-2024 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library.  If not, see
+   <https://www.gnu.org/licenses/>.  */
+
+#ifndef _FCNTL_H
+#error "Never use <bits/fcntl.h> directly; include <fcntl.h> instead."
+#endif
+
+#include <bits/wordsize.h>
+
+/* In 64-bit ISA files are always with 64bit off_t and F_*LK64 are the same as
+   non-64-bit versions.  It will need to be revised for 128-bit.  */
+#if __WORDSIZE == 64
+#define __O_LARGEFILE 0
+
+#define F_GETLK64 5  /* Get record locking info.  */
+#define F_SETLK64 6  /* Set record locking info (non-blocking).  */
+#define F_SETLKW64 7 /* Set record locking info (blocking).  */
+#endif
+
+struct flock
+{
+  short int l_type;   /* Type of lock: F_RDLCK, F_WRLCK, or F_UNLCK.  */
+  short int l_whence; /* Where `l_start' is relative to (like `lseek').  */
+#ifndef __USE_FILE_OFFSET64
+  __off_t l_start; /* Offset where the lock begins.  */
+  __off_t l_len;   /* Size of the locked area; zero means until EOF.  */
+#else
+  __off64_t l_start; /* Offset where the lock begins.  */
+  __off64_t l_len;   /* Size of the locked area; zero means until EOF.  */
+#endif
+  __pid_t l_pid; /* Process holding the lock.  */
+};
+
+#ifdef __USE_LARGEFILE64
+struct flock64
+{
+  short int l_type;   /* Type of lock: F_RDLCK, F_WRLCK, or F_UNLCK.  */
+  short int l_whence; /* Where `l_start' is relative to (like `lseek').  */
+  __off64_t l_start;  /* Offset where the lock begins.  */
+  __off64_t l_len;    /* Size of the locked area; zero means until EOF.  */
+  __pid_t l_pid;      /* Process holding the lock.  */
+};
+#endif
+
+/* Include generic Linux declarations.  */
+#include <bits/fcntl-linux.h>
\ No newline at end of file
diff --git a/zig/lib/libc/include/loongarch64-linux-gnusf/bits/fenv.h b/zig/lib/libc/include/loongarch64-linux-gnusf/bits/fenv.h
new file mode 100644
index 0000000000..92dc84011a
--- /dev/null
+++ b/zig/lib/libc/include/loongarch64-linux-gnusf/bits/fenv.h
@@ -0,0 +1,90 @@
+/* Floating point environment.
+   Copyright (C) 2022-2024 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library.  If not, see
+   <https://www.gnu.org/licenses/>.  */
+
+#ifndef _FENV_H
+#error "Never use <bits/fenv.h> directly; include <fenv.h> instead."
+#endif
+
+/* Define bits representing the exception.  We use the bit positions
+   of the appropriate bits in the FPU control word.  */
+enum
+{
+  FE_INEXACT =
+#define FE_INEXACT 0x010000
+    FE_INEXACT,
+  FE_UNDERFLOW =
+#define FE_UNDERFLOW 0x020000
+    FE_UNDERFLOW,
+  FE_OVERFLOW =
+#define FE_OVERFLOW 0x040000
+    FE_OVERFLOW,
+  FE_DIVBYZERO =
+#define FE_DIVBYZERO 0x080000
+    FE_DIVBYZERO,
+  FE_INVALID =
+#define FE_INVALID 0x100000
+    FE_INVALID,
+};
+
+#define FE_ALL_EXCEPT \
+  (FE_INEXACT | FE_DIVBYZERO | FE_UNDERFLOW | FE_OVERFLOW | FE_INVALID)
+
+/* The LoongArch FPU supports all of the four defined rounding modes.  We
+   use again the bit positions in the FPU control word as the values
+   for the appropriate macros.  */
+enum
+{
+  FE_TONEAREST =
+#define FE_TONEAREST 0x000
+    FE_TONEAREST,
+  FE_TOWARDZERO =
+#define FE_TOWARDZERO 0x100
+    FE_TOWARDZERO,
+  FE_UPWARD =
+#define FE_UPWARD 0x200
+    FE_UPWARD,
+  FE_DOWNWARD =
+#define FE_DOWNWARD 0x300
+    FE_DOWNWARD
+};
+
+/* Type representing exception flags.  */
+typedef unsigned int fexcept_t;
+
+/* Type representing floating-point environment.  This function corresponds
+   to the layout of the block written by the `fstenv'.  */
+typedef struct
+{
+  unsigned int __fp_control_register;
+} fenv_t;
+
+/* If the default argument is used we use this value.  */
+#define FE_DFL_ENV ((const fenv_t *) -1)
+
+#ifdef __USE_GNU
+/* Floating-point environment where none of the exception is masked.  */
+#define FE_NOMASK_ENV ((const fenv_t *) -257)
+#endif
+
+#if __GLIBC_USE (IEC_60559_BFP_EXT_C23)
+/* Type representing floating-point control modes.  */
+typedef unsigned int femode_t;
+
+/* Default floating-point control modes.  */
+#define FE_DFL_MODE ((const femode_t *) -1L)
+#endif
\ No newline at end of file
diff --git a/zig/lib/libc/include/loongarch64-linux-gnusf/bits/hwcap.h b/zig/lib/libc/include/loongarch64-linux-gnusf/bits/hwcap.h
new file mode 100644
index 0000000000..3b3d1ad463
--- /dev/null
+++ b/zig/lib/libc/include/loongarch64-linux-gnusf/bits/hwcap.h
@@ -0,0 +1,38 @@
+/* Defines for bits in AT_HWCAP.  LoongArch64 Linux version.
+   Copyright (C) 2022-2024 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#if !defined (_SYS_AUXV_H)
+# error "Never include <bits/hwcap.h> directly; use <sys/auxv.h> instead."
+#endif
+
+/* The following must match the kernel's <asm/hwcap.h>.  */
+/* HWCAP flags */
+#define HWCAP_LOONGARCH_CPUCFG          (1 << 0)
+#define HWCAP_LOONGARCH_LAM             (1 << 1)
+#define HWCAP_LOONGARCH_UAL             (1 << 2)
+#define HWCAP_LOONGARCH_FPU             (1 << 3)
+#define HWCAP_LOONGARCH_LSX             (1 << 4)
+#define HWCAP_LOONGARCH_LASX            (1 << 5)
+#define HWCAP_LOONGARCH_CRC32           (1 << 6)
+#define HWCAP_LOONGARCH_COMPLEX         (1 << 7)
+#define HWCAP_LOONGARCH_CRYPTO          (1 << 8)
+#define HWCAP_LOONGARCH_LVZ             (1 << 9)
+#define HWCAP_LOONGARCH_LBT_X86         (1 << 10)
+#define HWCAP_LOONGARCH_LBT_ARM         (1 << 11)
+#define HWCAP_LOONGARCH_LBT_MIPS        (1 << 12)
+#define HWCAP_LOONGARCH_PTW             (1 << 13)
\ No newline at end of file
diff --git a/zig/lib/libc/include/loongarch64-linux-gnusf/bits/link.h b/zig/lib/libc/include/loongarch64-linux-gnusf/bits/link.h
new file mode 100644
index 0000000000..821a54fe54
--- /dev/null
+++ b/zig/lib/libc/include/loongarch64-linux-gnusf/bits/link.h
@@ -0,0 +1,76 @@
+/* Machine-specific declarations for dynamic linker interface.
+   Copyright (C) 2022-2024 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library.  If not, see
+   <https://www.gnu.org/licenses/>.  */
+
+#ifndef _LINK_H
+#error "Never include <bits/link.h> directly; use <link.h> instead."
+#endif
+
+#ifndef __loongarch_soft_float
+typedef float La_loongarch_vr
+    __attribute__ ((__vector_size__ (16), __aligned__ (16)));
+typedef float La_loongarch_xr
+    __attribute__ ((__vector_size__ (32), __aligned__ (16)));
+
+typedef union
+{
+  double fpreg[4];
+  La_loongarch_vr vr[2];
+  La_loongarch_xr xr[1];
+} La_loongarch_vector __attribute__ ((__aligned__ (16)));
+#endif
+
+typedef struct La_loongarch_regs
+{
+  unsigned long int lr_reg[8]; /* a0 - a7 */
+#ifndef __loongarch_soft_float
+  La_loongarch_vector lr_vec[8]; /* fa0 - fa7 or vr0 - vr7 or xr0 - xr7*/
+#endif
+  unsigned long int lr_ra;
+  unsigned long int lr_sp;
+} La_loongarch_regs;
+
+/* Return values for calls from PLT on LoongArch.  */
+typedef struct La_loongarch_retval
+{
+  unsigned long int lrv_a0;
+  unsigned long int lrv_a1;
+#ifndef __loongarch_soft_float
+  La_loongarch_vector lrv_vec0;
+  La_loongarch_vector lrv_vec1;
+#endif
+} La_loongarch_retval;
+
+__BEGIN_DECLS
+
+extern ElfW (Addr) la_loongarch_gnu_pltenter (ElfW (Sym) *__sym,
+					      unsigned int __ndx,
+					      uintptr_t *__refcook,
+					      uintptr_t *__defcook,
+					      La_loongarch_regs *__regs,
+					      unsigned int *__flags,
+					      const char *__symname,
+					      long int *__framesizep);
+extern unsigned int la_loongarch_gnu_pltexit (ElfW (Sym) *__sym,
+					      unsigned int __ndx,
+					      uintptr_t *__refcook,
+					      uintptr_t *__defcook,
+					      const La_loongarch_regs *__inregs,
+					      La_loongarch_retval *__outregs,
+					      const char *__symname);
+
+__END_DECLS
\ No newline at end of file
diff --git a/zig/lib/libc/include/loongarch64-linux-gnusf/bits/link_lavcurrent.h b/zig/lib/libc/include/loongarch64-linux-gnusf/bits/link_lavcurrent.h
new file mode 100644
index 0000000000..36d637cd1f
--- /dev/null
+++ b/zig/lib/libc/include/loongarch64-linux-gnusf/bits/link_lavcurrent.h
@@ -0,0 +1,25 @@
+/* Data structure for communication from the run-time dynamic linker for
+   loaded ELF shared objects.  LAV_CURRENT definition.
+   Copyright (C) 2023-2024 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+#ifndef _LINK_H
+# error "Never include <bits/link_lavcurrent.h> directly; use <link.h> instead."
+#endif
+
+/* Version numbers for la_version handshake interface.  */
+#define LAV_CURRENT	3
\ No newline at end of file
diff --git a/zig/lib/libc/include/loongarch64-linux-gnusf/bits/long-double.h b/zig/lib/libc/include/loongarch64-linux-gnusf/bits/long-double.h
new file mode 100644
index 0000000000..a83f6c746f
--- /dev/null
+++ b/zig/lib/libc/include/loongarch64-linux-gnusf/bits/long-double.h
@@ -0,0 +1,21 @@
+/* Properties of long double type.  ldbl-128 version.
+   Copyright (C) 2016-2024 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License  published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+/* long double is distinct from double, so there is nothing to
+   define here.  */
+#define __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI 0
\ No newline at end of file
diff --git a/zig/lib/libc/include/loongarch64-linux-gnusf/bits/procfs.h b/zig/lib/libc/include/loongarch64-linux-gnusf/bits/procfs.h
new file mode 100644
index 0000000000..4371fd0a8f
--- /dev/null
+++ b/zig/lib/libc/include/loongarch64-linux-gnusf/bits/procfs.h
@@ -0,0 +1,52 @@
+/* Types for registers for sys/procfs.h.
+   Copyright (C) 2022-2024 Free Software Foundation, Inc.
+
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library.  If not, see
+   <https://www.gnu.org/licenses/>.  */
+
+#ifndef _SYS_PROCFS_H
+# error "Never include <bits/procfs.h> directly; use <sys/procfs.h> instead."
+#endif
+
+/* Type for a general-purpose register.  */
+typedef __uint64_t elf_greg_t;
+
+/* And the whole bunch of them.  We could have used `struct
+   pt_regs' directly in the typedef, but tradition says that
+   the register set is an array, which does have some peculiar
+   semantics, so leave it that way.  */
+#define ELF_NGREG (sizeof (struct user_regs_struct) / sizeof (elf_greg_t))
+typedef elf_greg_t elf_gregset_t[ELF_NGREG];
+
+#define ELF_NFPREG 34 /* 32 FPRs + 8-byte byte-vec for fcc + 4-byte FCR */
+typedef union
+{
+  double d;
+  float f;
+} elf_fpreg_t;
+typedef elf_fpreg_t elf_fpregset_t[ELF_NFPREG];
+
+typedef union
+{
+  double d[2];
+  float f[4];
+} __attribute__ ((__aligned__ (16))) elf_lsxregset_t[32];
+
+typedef union
+{
+  double d[4];
+  float f[8];
+} __attribute__ ((__aligned__ (32))) elf_lasxregset_t[32];
\ No newline at end of file
diff --git a/zig/lib/libc/include/loongarch64-linux-gnusf/bits/pthread_stack_min.h b/zig/lib/libc/include/loongarch64-linux-gnusf/bits/pthread_stack_min.h
new file mode 100644
index 0000000000..4a05d0d8a5
--- /dev/null
+++ b/zig/lib/libc/include/loongarch64-linux-gnusf/bits/pthread_stack_min.h
@@ -0,0 +1,20 @@
+/* Definition of PTHREAD_STACK_MIN.  LoongArch Linux version.
+   Copyright (C) 2022-2024 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public License as
+   published by the Free Software Foundation; either version 2.1 of the
+   License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library.  If not, see
+   <https://www.gnu.org/licenses/>.  */
+
+/* Minimum size for a thread.  At least two pages with 64k pages.  */
+#define PTHREAD_STACK_MIN	131072
\ No newline at end of file
diff --git a/zig/lib/libc/include/loongarch64-linux-gnusf/bits/setjmp.h b/zig/lib/libc/include/loongarch64-linux-gnusf/bits/setjmp.h
new file mode 100644
index 0000000000..59214222c8
--- /dev/null
+++ b/zig/lib/libc/include/loongarch64-linux-gnusf/bits/setjmp.h
@@ -0,0 +1,42 @@
+/* Define the machine-dependent type `jmp_buf'.
+   Copyright (C) 2022-2024 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library.  If not, see
+   <https://www.gnu.org/licenses/>.  */
+
+#ifndef _LOONGARCH_BITS_SETJMP_H
+#define _LOONGARCH_BITS_SETJMP_H
+
+typedef struct __jmp_buf_internal_tag
+{
+  /* Program counter.  */
+  long int __pc;
+  /* Stack pointer.  */
+  long int __sp;
+  /* Reserved */
+  long int __x;
+  /* Frame pointer.  */
+  long int __fp;
+  /* Callee-saved registers.  */
+  long int __regs[9];
+
+#ifndef __loongarch_soft_float
+  /* Callee-saved floating point registers.  */
+  double __fpregs[8];
+#endif
+
+} __jmp_buf[1];
+
+#endif /* _LOONGARCH_BITS_SETJMP_H */
\ No newline at end of file
diff --git a/zig/lib/libc/include/loongarch64-linux-gnusf/bits/shmlba.h b/zig/lib/libc/include/loongarch64-linux-gnusf/bits/shmlba.h
new file mode 100644
index 0000000000..166f19c016
--- /dev/null
+++ b/zig/lib/libc/include/loongarch64-linux-gnusf/bits/shmlba.h
@@ -0,0 +1,24 @@
+/* Define SHMLBA.  LoongArch version.
+   Copyright (C) 2023-2024 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+#ifndef _SYS_SHM_H
+# error "Never use <bits/shmlba.h> directly; include <sys/shm.h> instead."
+#endif
+
+/* Segment low boundary address multiple.  */
+#define SHMLBA		0x10000
\ No newline at end of file
diff --git a/zig/lib/libc/include/loongarch64-linux-gnusf/bits/sigstack.h b/zig/lib/libc/include/loongarch64-linux-gnusf/bits/sigstack.h
new file mode 100644
index 0000000000..af2933a8ce
--- /dev/null
+++ b/zig/lib/libc/include/loongarch64-linux-gnusf/bits/sigstack.h
@@ -0,0 +1,32 @@
+/* sigstack, sigaltstack definitions.
+   Copyright (C) 2022-2024 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+#ifndef _BITS_SIGSTACK_H
+#define _BITS_SIGSTACK_H 1
+
+#if !defined _SIGNAL_H && !defined _SYS_UCONTEXT_H
+# error "Never include this file directly.  Use <signal.h> instead"
+#endif
+
+/* Minimum stack size for a signal handler.  */
+#define MINSIGSTKSZ	4096
+
+/* System default stack size.  */
+#define SIGSTKSZ	16384
+
+#endif /* bits/sigstack.h */
\ No newline at end of file
diff --git a/zig/lib/libc/include/loongarch64-linux-gnusf/bits/struct_stat.h b/zig/lib/libc/include/loongarch64-linux-gnusf/bits/struct_stat.h
new file mode 100644
index 0000000000..c8e2d78b57
--- /dev/null
+++ b/zig/lib/libc/include/loongarch64-linux-gnusf/bits/struct_stat.h
@@ -0,0 +1,127 @@
+/* Definition for struct stat.
+   Copyright (C) 2020-2024 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library.  If not, see
+   <https://www.gnu.org/licenses/>.  */
+
+#if !defined _SYS_STAT_H && !defined _FCNTL_H
+# error "Never include <bits/struct_stat.h> directly; use <sys/stat.h> instead."
+#endif
+
+#ifndef _BITS_STRUCT_STAT_H
+#define _BITS_STRUCT_STAT_H	1
+
+#include <bits/endian.h>
+#include <bits/wordsize.h>
+
+#if defined __USE_FILE_OFFSET64
+# define __field64(type, type64, name) type64 name
+#elif __WORDSIZE == 64 || defined __INO_T_MATCHES_INO64_T
+# if defined __INO_T_MATCHES_INO64_T && !defined __OFF_T_MATCHES_OFF64_T
+#  error "ino_t and off_t must both be the same type"
+# endif
+# define __field64(type, type64, name) type name
+#elif __BYTE_ORDER == __LITTLE_ENDIAN
+# define __field64(type, type64, name) \
+  type name __attribute__((__aligned__ (__alignof__ (type64)))); int __##name##_pad
+#else
+# define __field64(type, type64, name) \
+  int __##name##_pad __attribute__((__aligned__ (__alignof__ (type64)))); type name
+#endif
+
+struct stat
+  {
+    __dev_t st_dev;		/* Device.  */
+    __field64(__ino_t, __ino64_t, st_ino);  /* File serial number. */
+    __mode_t st_mode;		/* File mode.  */
+    __nlink_t st_nlink;		/* Link count.  */
+    __uid_t st_uid;		/* User ID of the file's owner.	*/
+    __gid_t st_gid;		/* Group ID of the file's group.*/
+    __dev_t st_rdev;		/* Device number, if device.  */
+    __dev_t __pad1;
+    __field64(__off_t, __off64_t, st_size);  /* Size of file, in bytes. */
+    __blksize_t st_blksize;	/* Optimal block size for I/O.  */
+    int __pad2;
+    __field64(__blkcnt_t, __blkcnt64_t, st_blocks);  /* 512-byte blocks */
+#ifdef __USE_XOPEN2K8
+    /* Nanosecond resolution timestamps are stored in a format
+       equivalent to 'struct timespec'.  This is the type used
+       whenever possible but the Unix namespace rules do not allow the
+       identifier 'timespec' to appear in the <sys/stat.h> header.
+       Therefore we have to handle the use of this header in strictly
+       standard-compliant sources special.  */
+    struct timespec st_atim;		/* Time of last access.  */
+    struct timespec st_mtim;		/* Time of last modification.  */
+    struct timespec st_ctim;		/* Time of last status change.  */
+# define st_atime st_atim.tv_sec	/* Backward compatibility.  */
+# define st_mtime st_mtim.tv_sec
+# define st_ctime st_ctim.tv_sec
+#else
+    __time_t st_atime;			/* Time of last access.  */
+    unsigned long int st_atimensec;	/* Nscecs of last access.  */
+    __time_t st_mtime;			/* Time of last modification.  */
+    unsigned long int st_mtimensec;	/* Nsecs of last modification.  */
+    __time_t st_ctime;			/* Time of last status change.  */
+    unsigned long int st_ctimensec;	/* Nsecs of last status change.  */
+#endif
+    int __glibc_reserved[2];
+  };
+
+#undef __field64
+
+#ifdef __USE_LARGEFILE64
+struct stat64
+  {
+    __dev_t st_dev;		/* Device.  */
+    __ino64_t st_ino;		/* File serial number.	*/
+    __mode_t st_mode;		/* File mode.  */
+    __nlink_t st_nlink;		/* Link count.  */
+    __uid_t st_uid;		/* User ID of the file's owner.	*/
+    __gid_t st_gid;		/* Group ID of the file's group.*/
+    __dev_t st_rdev;		/* Device number, if device.  */
+    __dev_t __pad1;
+    __off64_t st_size;		/* Size of file, in bytes.  */
+    __blksize_t st_blksize;	/* Optimal block size for I/O.  */
+    int __pad2;
+    __blkcnt64_t st_blocks;	/* Nr. 512-byte blocks allocated.  */
+#ifdef __USE_XOPEN2K8
+    /* Nanosecond resolution timestamps are stored in a format
+       equivalent to 'struct timespec'.  This is the type used
+       whenever possible but the Unix namespace rules do not allow the
+       identifier 'timespec' to appear in the <sys/stat.h> header.
+       Therefore we have to handle the use of this header in strictly
+       standard-compliant sources special.  */
+    struct timespec st_atim;		/* Time of last access.  */
+    struct timespec st_mtim;		/* Time of last modification.  */
+    struct timespec st_ctim;		/* Time of last status change.  */
+#else
+    __time_t st_atime;			/* Time of last access.  */
+    unsigned long int st_atimensec;	/* Nscecs of last access.  */
+    __time_t st_mtime;			/* Time of last modification.  */
+    unsigned long int st_mtimensec;	/* Nsecs of last modification.  */
+    __time_t st_ctime;			/* Time of last status change.  */
+    unsigned long int st_ctimensec;	/* Nsecs of last status change.  */
+#endif
+    int __glibc_reserved[2];
+  };
+#endif
+
+/* Tell code we have these members.  */
+#define	_STATBUF_ST_BLKSIZE
+#define _STATBUF_ST_RDEV
+/* Nanosecond resolution time values are supported.  */
+#define _STATBUF_ST_NSEC
+
+#endif /* _BITS_STRUCT_STAT_H  */
\ No newline at end of file
diff --git a/zig/lib/libc/include/loongarch64-linux-gnusf/bits/timesize.h b/zig/lib/libc/include/loongarch64-linux-gnusf/bits/timesize.h
new file mode 100644
index 0000000000..17f828ecfe
--- /dev/null
+++ b/zig/lib/libc/include/loongarch64-linux-gnusf/bits/timesize.h
@@ -0,0 +1,20 @@
+/* Bit size of the time_t type at glibc build time, general case.
+   Copyright (C) 2018-2024 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+/* Size in bits of the 'time_t' type of the default ABI.  */
+#define __TIMESIZE	64
\ No newline at end of file
diff --git a/zig/lib/libc/include/loongarch64-linux-gnusf/bits/wordsize.h b/zig/lib/libc/include/loongarch64-linux-gnusf/bits/wordsize.h
new file mode 100644
index 0000000000..98996fdf03
--- /dev/null
+++ b/zig/lib/libc/include/loongarch64-linux-gnusf/bits/wordsize.h
@@ -0,0 +1,19 @@
+/* Copyright (C) 1999-2024 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+#define __WORDSIZE			64
+#define __WORDSIZE_TIME64_COMPAT32	0
\ No newline at end of file
diff --git a/zig/lib/libc/include/loongarch64-linux-gnusf/fpu_control.h b/zig/lib/libc/include/loongarch64-linux-gnusf/fpu_control.h
new file mode 100644
index 0000000000..d52d6d51cc
--- /dev/null
+++ b/zig/lib/libc/include/loongarch64-linux-gnusf/fpu_control.h
@@ -0,0 +1,119 @@
+/* FPU control word bits.
+   Copyright (C) 2022-2024 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library.  If not, see
+   <https://www.gnu.org/licenses/>.  */
+
+#ifndef _FPU_CONTROL_H
+#define _FPU_CONTROL_H
+
+/* LoongArch FPU floating point control register bits.
+ *
+ * 31-29  -> reserved (read as 0, can not changed by software)
+ * 28     -> cause bit for invalid exception
+ * 27     -> cause bit for division by zero exception
+ * 26     -> cause bit for overflow exception
+ * 25     -> cause bit for underflow exception
+ * 24     -> cause bit for inexact exception
+ * 23-21  -> reserved (read as 0, can not changed by software)
+ * 20     -> flag invalid exception
+ * 19     -> flag division by zero exception
+ * 18     -> flag overflow exception
+ * 17     -> flag underflow exception
+ * 16     -> flag inexact exception
+ *  9-8   -> rounding control
+ *  7-5   -> reserved (read as 0, can not changed by software)
+ *  4     -> enable exception for invalid exception
+ *  3     -> enable exception for division by zero exception
+ *  2     -> enable exception for overflow exception
+ *  1     -> enable exception for underflow exception
+ *  0     -> enable exception for inexact exception
+ *
+ *
+ * Rounding Control:
+ * 00 - rounding ties to even (RNE)
+ * 01 - rounding toward zero (RZ)
+ * 10 - rounding (up) toward plus infinity (RP)
+ * 11 - rounding (down) toward minus infinity (RM)
+ */
+
+#include <features.h>
+
+#ifdef __loongarch_soft_float
+
+#define _FPU_RESERVED 0xffffffff
+#define _FPU_DEFAULT 0x00000000
+typedef unsigned int fpu_control_t;
+#define _FPU_GETCW(cw) (cw) = 0
+#define _FPU_SETCW(cw) (void) (cw)
+extern fpu_control_t __fpu_control;
+
+#else /* __loongarch_soft_float */
+
+/* Masks for interrupts.  */
+#define _FPU_MASK_V 0x10 /* Invalid operation */
+#define _FPU_MASK_Z 0x08 /* Division by zero  */
+#define _FPU_MASK_O 0x04 /* Overflow */
+#define _FPU_MASK_U 0x02 /* Underflow */
+#define _FPU_MASK_I 0x01 /* Inexact operation */
+
+/* Flush denormalized numbers to zero.  */
+#define _FPU_FLUSH_TZ 0x1000000
+
+/* Rounding control.  */
+#define _FPU_RC_NEAREST 0x000 /* RECOMMENDED */
+#define _FPU_RC_ZERO 0x100
+#define _FPU_RC_UP 0x200
+#define _FPU_RC_DOWN 0x300
+/* Mask for rounding control.  */
+#define _FPU_RC_MASK 0x300
+
+#define _FPU_RESERVED 0x0
+
+#define _FPU_DEFAULT 0x0
+#define _FPU_IEEE 0x1F
+
+/* Type of the control word.  */
+typedef unsigned int fpu_control_t __attribute__ ((__mode__ (__SI__)));
+
+/* Macros for accessing the hardware control word.  */
+extern fpu_control_t __loongarch_fpu_getcw (void) __THROW;
+extern void __loongarch_fpu_setcw (fpu_control_t) __THROW;
+#define _FPU_GETCW(cw) __asm__ volatile ("movfcsr2gr %0,$fcsr0" : "=r"(cw))
+#define _FPU_SETCW(cw) __asm__ volatile ("movgr2fcsr $fcsr0,%0" : : "r"(cw))
+
+/* Default control word set at startup.  */
+extern fpu_control_t __fpu_control;
+
+# define _FCLASS_SNAN     (1 << 0)
+# define _FCLASS_QNAN     (1 << 1)
+# define _FCLASS_MINF     (1 << 2)
+# define _FCLASS_MNORM    (1 << 3)
+# define _FCLASS_MSUBNORM (1 << 4)
+# define _FCLASS_MZERO    (1 << 5)
+# define _FCLASS_PINF     (1 << 6)
+# define _FCLASS_PNORM    (1 << 7)
+# define _FCLASS_PSUBNORM (1 << 8)
+# define _FCLASS_PZERO    (1 << 9)
+
+# define _FCLASS_ZERO     (_FCLASS_MZERO | _FCLASS_PZERO)
+# define _FCLASS_SUBNORM  (_FCLASS_MSUBNORM | _FCLASS_PSUBNORM)
+# define _FCLASS_NORM     (_FCLASS_MNORM | _FCLASS_PNORM)
+# define _FCLASS_INF      (_FCLASS_MINF | _FCLASS_PINF)
+# define _FCLASS_NAN      (_FCLASS_SNAN | _FCLASS_QNAN)
+
+#endif /* __loongarch_soft_float */
+
+#endif /* fpu_control.h */
\ No newline at end of file
diff --git a/zig/lib/libc/include/loongarch64-linux-gnusf/gnu/lib-names-lp64s.h b/zig/lib/libc/include/loongarch64-linux-gnusf/gnu/lib-names-lp64s.h
new file mode 100644
index 0000000000..7c8b796194
--- /dev/null
+++ b/zig/lib/libc/include/loongarch64-linux-gnusf/gnu/lib-names-lp64s.h
@@ -0,0 +1,27 @@
+/* This file is automatically generated.  */
+#ifndef __GNU_LIB_NAMES_H
+# error "Never use <gnu/lib-names-lp64s.h> directly; include <gnu/lib-names.h> instead."
+#endif
+
+#define LD_LINUX_LOONGARCH_LP64S_SO     "ld-linux-loongarch-lp64s.so.1"
+#define LD_SO                           "ld-linux-loongarch-lp64s.so.1"
+#define LIBANL_SO                       "libanl.so.1"
+#define LIBBROKENLOCALE_SO              "libBrokenLocale.so.1"
+#define LIBC_MALLOC_DEBUG_SO            "libc_malloc_debug.so.0"
+#define LIBC_SO                         "libc.so.6"
+#define LIBDL_SO                        "libdl.so.2"
+#define LIBGCC_S_SO                     "libgcc_s.so.1"
+#define LIBMVEC_SO                      "libmvec.so.1"
+#define LIBM_SO                         "libm.so.6"
+#define LIBNSL_SO                       "libnsl.so.1"
+#define LIBNSS_COMPAT_SO                "libnss_compat.so.2"
+#define LIBNSS_DB_SO                    "libnss_db.so.2"
+#define LIBNSS_DNS_SO                   "libnss_dns.so.2"
+#define LIBNSS_FILES_SO                 "libnss_files.so.2"
+#define LIBNSS_HESIOD_SO                "libnss_hesiod.so.2"
+#define LIBNSS_LDAP_SO                  "libnss_ldap.so.2"
+#define LIBPTHREAD_SO                   "libpthread.so.0"
+#define LIBRESOLV_SO                    "libresolv.so.2"
+#define LIBRT_SO                        "librt.so.1"
+#define LIBTHREAD_DB_SO                 "libthread_db.so.1"
+#define LIBUTIL_SO                      "libutil.so.1"
\ No newline at end of file
diff --git a/zig/lib/libc/include/loongarch64-linux-gnusf/gnu/lib-names.h b/zig/lib/libc/include/loongarch64-linux-gnusf/gnu/lib-names.h
new file mode 100644
index 0000000000..c3eba41e09
--- /dev/null
+++ b/zig/lib/libc/include/loongarch64-linux-gnusf/gnu/lib-names.h
@@ -0,0 +1,16 @@
+/* This file is automatically generated.
+   It defines macros to allow user program to find the shared
+   library files which come as part of GNU libc.  */
+#ifndef __GNU_LIB_NAMES_H
+#define __GNU_LIB_NAMES_H	1
+
+#include <bits/wordsize.h>
+
+#if __WORDSIZE == 64 && defined __loongarch_soft_float
+# include <gnu/lib-names-lp64s.h>
+#endif
+#if __WORDSIZE == 64 && defined __loongarch_double_float
+# include <gnu/lib-names-lp64d.h>
+#endif
+
+#endif	/* gnu/lib-names.h */
\ No newline at end of file
diff --git a/zig/lib/libc/include/loongarch64-linux-gnusf/gnu/stubs-lp64s.h b/zig/lib/libc/include/loongarch64-linux-gnusf/gnu/stubs-lp64s.h
new file mode 100644
index 0000000000..6ce02418e6
--- /dev/null
+++ b/zig/lib/libc/include/loongarch64-linux-gnusf/gnu/stubs-lp64s.h
@@ -0,0 +1,38 @@
+/* This file is automatically generated.
+   It defines a symbol `__stub_FUNCTION' for each function
+   in the C library which is a stub, meaning it will fail
+   every time called, usually setting errno to ENOSYS.  */
+
+#ifdef _LIBC
+ #error Applications may not define the macro _LIBC
+#endif
+
+#define __stub___compat_bdflush
+#define __stub___compat_create_module
+#define __stub___compat_get_kernel_syms
+#define __stub___compat_query_module
+#define __stub___compat_uselib
+#define __stub_chflags
+#define __stub_fchflags
+#define __stub_feclearexcept
+#define __stub_fedisableexcept
+#define __stub_feenableexcept
+#define __stub_fegetenv
+#define __stub_fegetexcept
+#define __stub_fegetexceptflag
+#define __stub_fegetmode
+#define __stub_fegetround
+#define __stub_feholdexcept
+#define __stub_feraiseexcept
+#define __stub_fesetenv
+#define __stub_fesetexcept
+#define __stub_fesetexceptflag
+#define __stub_fesetmode
+#define __stub_fesetround
+#define __stub_fetestexcept
+#define __stub_feupdateenv
+#define __stub_gtty
+#define __stub_revoke
+#define __stub_setlogin
+#define __stub_sigreturn
+#define __stub_stty
\ No newline at end of file
diff --git a/zig/lib/libc/include/loongarch64-linux-gnusf/gnu/stubs.h b/zig/lib/libc/include/loongarch64-linux-gnusf/gnu/stubs.h
new file mode 100644
index 0000000000..ea3f10c421
--- /dev/null
+++ b/zig/lib/libc/include/loongarch64-linux-gnusf/gnu/stubs.h
@@ -0,0 +1,12 @@
+/* This file is automatically generated.
+   This file selects the right generated file of `__stub_FUNCTION' macros
+   based on the architecture being compiled for.  */
+
+#include <bits/wordsize.h>
+
+#if __WORDSIZE == 64 && defined __loongarch_soft_float
+# include <gnu/stubs-lp64s.h>
+#endif
+#if __WORDSIZE == 64 && defined __loongarch_double_float
+# include <gnu/stubs-lp64d.h>
+#endif
\ No newline at end of file
diff --git a/zig/lib/libc/include/loongarch64-linux-gnusf/ieee754.h b/zig/lib/libc/include/loongarch64-linux-gnusf/ieee754.h
new file mode 100644
index 0000000000..b1e2ec7dc6
--- /dev/null
+++ b/zig/lib/libc/include/loongarch64-linux-gnusf/ieee754.h
@@ -0,0 +1,170 @@
+/* Copyright (C) 1992-2024 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+#ifndef _IEEE754_H
+#define _IEEE754_H 1
+
+#include <features.h>
+
+#include <bits/endian.h>
+
+__BEGIN_DECLS
+
+union ieee754_float
+  {
+    float f;
+
+    /* This is the IEEE 754 single-precision format.  */
+    struct
+      {
+#if	__BYTE_ORDER == __BIG_ENDIAN
+	unsigned int negative:1;
+	unsigned int exponent:8;
+	unsigned int mantissa:23;
+#endif				/* Big endian.  */
+#if	__BYTE_ORDER == __LITTLE_ENDIAN
+	unsigned int mantissa:23;
+	unsigned int exponent:8;
+	unsigned int negative:1;
+#endif				/* Little endian.  */
+      } ieee;
+
+    /* This format makes it easier to see if a NaN is a signalling NaN.  */
+    struct
+      {
+#if	__BYTE_ORDER == __BIG_ENDIAN
+	unsigned int negative:1;
+	unsigned int exponent:8;
+	unsigned int quiet_nan:1;
+	unsigned int mantissa:22;
+#endif				/* Big endian.  */
+#if	__BYTE_ORDER == __LITTLE_ENDIAN
+	unsigned int mantissa:22;
+	unsigned int quiet_nan:1;
+	unsigned int exponent:8;
+	unsigned int negative:1;
+#endif				/* Little endian.  */
+      } ieee_nan;
+  };
+
+#define IEEE754_FLOAT_BIAS	0x7f /* Added to exponent.  */
+
+
+union ieee754_double
+  {
+    double d;
+
+    /* This is the IEEE 754 double-precision format.  */
+    struct
+      {
+#if	__BYTE_ORDER == __BIG_ENDIAN
+	unsigned int negative:1;
+	unsigned int exponent:11;
+	/* Together these comprise the mantissa.  */
+	unsigned int mantissa0:20;
+	unsigned int mantissa1:32;
+#endif				/* Big endian.  */
+#if	__BYTE_ORDER == __LITTLE_ENDIAN
+	/* Together these comprise the mantissa.  */
+	unsigned int mantissa1:32;
+	unsigned int mantissa0:20;
+	unsigned int exponent:11;
+	unsigned int negative:1;
+#endif				/* Little endian.  */
+      } ieee;
+
+    /* This format makes it easier to see if a NaN is a signalling NaN.  */
+    struct
+      {
+#if	__BYTE_ORDER == __BIG_ENDIAN
+	unsigned int negative:1;
+	unsigned int exponent:11;
+	unsigned int quiet_nan:1;
+	/* Together these comprise the mantissa.  */
+	unsigned int mantissa0:19;
+	unsigned int mantissa1:32;
+#else
+	/* Together these comprise the mantissa.  */
+	unsigned int mantissa1:32;
+	unsigned int mantissa0:19;
+	unsigned int quiet_nan:1;
+	unsigned int exponent:11;
+	unsigned int negative:1;
+#endif
+      } ieee_nan;
+  };
+
+#define IEEE754_DOUBLE_BIAS	0x3ff /* Added to exponent.  */
+
+
+union ieee854_long_double
+  {
+    long double d;
+
+    /* This is the IEEE 854 quad-precision format.  */
+    struct
+      {
+#if	__BYTE_ORDER == __BIG_ENDIAN
+	unsigned int negative:1;
+	unsigned int exponent:15;
+	/* Together these comprise the mantissa.  */
+	unsigned int mantissa0:16;
+	unsigned int mantissa1:32;
+	unsigned int mantissa2:32;
+	unsigned int mantissa3:32;
+#endif				/* Big endian.  */
+#if	__BYTE_ORDER == __LITTLE_ENDIAN
+	/* Together these comprise the mantissa.  */
+	unsigned int mantissa3:32;
+	unsigned int mantissa2:32;
+	unsigned int mantissa1:32;
+	unsigned int mantissa0:16;
+	unsigned int exponent:15;
+	unsigned int negative:1;
+#endif				/* Little endian.  */
+      } ieee;
+
+    /* This format makes it easier to see if a NaN is a signalling NaN.  */
+    struct
+      {
+#if	__BYTE_ORDER == __BIG_ENDIAN
+	unsigned int negative:1;
+	unsigned int exponent:15;
+	unsigned int quiet_nan:1;
+	/* Together these comprise the mantissa.  */
+	unsigned int mantissa0:15;
+	unsigned int mantissa1:32;
+	unsigned int mantissa2:32;
+	unsigned int mantissa3:32;
+#else
+	/* Together these comprise the mantissa.  */
+	unsigned int mantissa3:32;
+	unsigned int mantissa2:32;
+	unsigned int mantissa1:32;
+	unsigned int mantissa0:15;
+	unsigned int quiet_nan:1;
+	unsigned int exponent:15;
+	unsigned int negative:1;
+#endif
+      } ieee_nan;
+  };
+
+#define IEEE854_LONG_DOUBLE_BIAS 0x3fff /* Added to exponent.  */
+
+__END_DECLS
+
+#endif /* ieee754.h */
\ No newline at end of file
diff --git a/zig/lib/libc/include/loongarch64-linux-gnusf/sys/asm.h b/zig/lib/libc/include/loongarch64-linux-gnusf/sys/asm.h
new file mode 100644
index 0000000000..282831f10d
--- /dev/null
+++ b/zig/lib/libc/include/loongarch64-linux-gnusf/sys/asm.h
@@ -0,0 +1,78 @@
+/* Miscellaneous macros.
+   Copyright (C) 2022-2024 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library.  If not, see
+   <https://www.gnu.org/licenses/>.  */
+
+#ifndef _SYS_ASM_H
+#define _SYS_ASM_H
+
+#include <sys/regdef.h>
+#include <sysdeps/generic/sysdep.h>
+
+/* Macros to handle different pointer/register sizes for 32/64-bit code.  */
+#define SZREG 8
+#define SZFREG 8
+#define SZVREG 16
+#define SZXREG 32
+#define REG_L ld.d
+#define REG_S st.d
+#define SRLI srli.d
+#define SLLI slli.d
+#define ADDI addi.d
+#define ADD  add.d
+#define SUB  sub.d
+#define BSTRINS  bstrins.d
+#define LI  li.d
+#define FREG_L fld.d
+#define FREG_S fst.d
+
+/*  Declare leaf routine.
+    The usage of macro LEAF/ENTRY is as follows:
+    1. LEAF(fcn) -- the align value of fcn is .align 3 (default value)
+    2. LEAF(fcn, 6) -- the align value of fcn is .align 6
+*/
+#define LEAF_IMPL(symbol, aln, ...)	\
+	.text;				\
+	.globl symbol;			\
+	.align aln;			\
+	.type symbol, @function;	\
+symbol: \
+	cfi_startproc;
+
+
+#define LEAF(...) LEAF_IMPL(__VA_ARGS__, 3)
+#define ENTRY(...) LEAF(__VA_ARGS__)
+
+#define	LEAF_NO_ALIGN(symbol)		\
+	.text;				\
+	.globl	symbol;			\
+	.type	symbol, @function;	\
+symbol: \
+	cfi_startproc;
+
+#define ENTRY_NO_ALIGN(symbol) LEAF_NO_ALIGN(symbol)
+
+
+/* Mark end of function.  */
+#undef END
+#define END(function) \
+  cfi_endproc; \
+  .size function, .- function;
+
+/* Stack alignment.  */
+#define ALMASK ~15
+
+#endif /* sys/asm.h */
\ No newline at end of file
diff --git a/zig/lib/libc/include/loongarch64-linux-gnusf/sys/ucontext.h b/zig/lib/libc/include/loongarch64-linux-gnusf/sys/ucontext.h
new file mode 100644
index 0000000000..5db0d1e09e
--- /dev/null
+++ b/zig/lib/libc/include/loongarch64-linux-gnusf/sys/ucontext.h
@@ -0,0 +1,64 @@
+/* struct ucontext definition.
+   Copyright (C) 2022-2024 Free Software Foundation, Inc.
+
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library.  If not, see
+   <https://www.gnu.org/licenses/>.  */
+
+/* Don't rely on this, the interface is currently messed up and may need to
+   be broken to be fixed.  */
+#ifndef _SYS_UCONTEXT_H
+#define _SYS_UCONTEXT_H 1
+
+#include <features.h>
+
+#include <bits/types/sigset_t.h>
+#include <bits/types/stack_t.h>
+
+#ifdef __USE_MISC
+#define LARCH_NGREG 32
+
+#define LARCH_REG_RA 1
+#define LARCH_REG_SP 3
+#define LARCH_REG_S0 23
+#define LARCH_REG_S1 24
+#define LARCH_REG_A0 4
+#define LARCH_REG_S2 25
+#define LARCH_REG_NARGS 8
+
+typedef unsigned long int greg_t;
+/* Container for all general registers.  */
+typedef greg_t gregset_t[32];
+#endif
+
+typedef struct mcontext_t
+{
+  unsigned long long __pc;
+  unsigned long long __gregs[32];
+  unsigned int __flags;
+  unsigned long long __extcontext[0] __attribute__((__aligned__(16)));
+} mcontext_t;
+
+/* Userlevel context.  */
+typedef struct ucontext_t
+{
+  unsigned long int __uc_flags;
+  struct ucontext_t *uc_link;
+  stack_t uc_stack;
+  sigset_t uc_sigmask;
+  mcontext_t uc_mcontext;
+} ucontext_t;
+
+#endif /* sys/ucontext.h */
\ No newline at end of file
diff --git a/zig/lib/libc/include/loongarch64-linux-gnusf/sys/user.h b/zig/lib/libc/include/loongarch64-linux-gnusf/sys/user.h
new file mode 100644
index 0000000000..5dff8a5443
--- /dev/null
+++ b/zig/lib/libc/include/loongarch64-linux-gnusf/sys/user.h
@@ -0,0 +1,42 @@
+/* struct user_regs_struct definition for LoongArch.
+   Copyright (C) 2022-2024 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+#ifndef _SYS_USER_H
+#define _SYS_USER_H 1
+
+#include <stdint.h>
+
+struct user_regs_struct
+{
+  /* Saved main processor registers. */
+  uint64_t regs[32];
+
+  /* Saved special registers. */
+  uint64_t orig_a0;
+  uint64_t csr_era;
+  uint64_t csr_badv;
+  uint64_t reserved[10];
+};
+
+struct user_fp_struct {
+  uint64_t    fpr[32];
+  uint64_t    fcc;
+  uint32_t    fcsr;
+};
+
+#endif /* _SYS_USER_H */
\ No newline at end of file
diff --git a/zig/lib/libc/musl/crt/arm/crti.s b/zig/lib/libc/musl/crt/arm/crti.s
index 18dc1e4197..cccda3eaef 100644
--- a/zig/lib/libc/musl/crt/arm/crti.s
+++ b/zig/lib/libc/musl/crt/arm/crti.s
@@ -3,11 +3,13 @@
 .section .init
 .global _init
 .type _init,%function
+.align 2
 _init:
 	push {r0,lr}
 
 .section .fini
 .global _fini
 .type _fini,%function
+.align 2
 _fini:
 	push {r0,lr}
diff --git a/zig/lib/libc/musl/crt/mips/crtn.s b/zig/lib/libc/musl/crt/mips/crtn.s
index 506a04b78c..5146d83a0e 100644
--- a/zig/lib/libc/musl/crt/mips/crtn.s
+++ b/zig/lib/libc/musl/crt/mips/crtn.s
@@ -3,11 +3,13 @@
 .section .init
 	lw $gp,24($sp)
 	lw $ra,28($sp)
-	j $ra
+	# zig patch: j <reg> -> jr <reg> for https://github.com/ziglang/zig/issues/21315
+	jr $ra
 	addu $sp,$sp,32
 
 .section .fini
 	lw $gp,24($sp)
 	lw $ra,28($sp)
-	j $ra
+	# zig patch: j <reg> -> jr <reg> for https://github.com/ziglang/zig/issues/21315
+	jr $ra
 	addu $sp,$sp,32
diff --git a/zig/lib/libc/musl/crt/mips64/crtn.s b/zig/lib/libc/musl/crt/mips64/crtn.s
index f3930b2406..dc4dbb03ad 100644
--- a/zig/lib/libc/musl/crt/mips64/crtn.s
+++ b/zig/lib/libc/musl/crt/mips64/crtn.s
@@ -3,11 +3,13 @@
 .section .init
 	ld $gp,16($sp)
 	ld $ra,24($sp)
-	j $ra
+	# zig patch: j <reg> -> jr <reg> for https://github.com/ziglang/zig/issues/21315
+	jr $ra
 	daddu $sp,$sp,32
 
 .section .fini
 	ld $gp,16($sp)
 	ld $ra,24($sp)
-	j $ra
+	# zig patch: j <reg> -> jr <reg> for https://github.com/ziglang/zig/issues/21315
+	jr $ra
 	daddu $sp,$sp,32
diff --git a/zig/lib/libunwind/src/gcc_personality_v0.c b/zig/lib/libunwind/src/gcc_personality_v0.c
index c946497d75..1d9c7f4d17 100644
--- a/zig/lib/libunwind/src/gcc_personality_v0.c
+++ b/zig/lib/libunwind/src/gcc_personality_v0.c
@@ -20,6 +20,15 @@
 
 #include <unwind.h>
 
+#if defined(__SEH__) && !defined(__USING_SJLJ_EXCEPTIONS__)
+#include <windows.h>
+#include <winnt.h>
+
+EXCEPTION_DISPOSITION _GCC_specific_handler(PEXCEPTION_RECORD, void *, PCONTEXT,
+                                            PDISPATCHER_CONTEXT,
+                                            _Unwind_Personality_Fn);
+#endif
+
 // Pointer encodings documented at:
 //   http://refspecs.freestandards.org/LSB_1.3.0/gLSB/gLSB/ehframehdr.html
 
@@ -43,9 +52,9 @@
 #define DW_EH_PE_indirect 0x80 // gcc extension
 
 // read a uleb128 encoded value and advance pointer
-static uintptr_t readULEB128(const uint8_t **data) {
-  uintptr_t result = 0;
-  uintptr_t shift = 0;
+static size_t readULEB128(const uint8_t **data) {
+  size_t result = 0;
+  size_t shift = 0;
   unsigned char byte;
   const uint8_t *p = *data;
   do {
@@ -133,7 +142,7 @@ static uintptr_t readEncodedPointer(const uint8_t **data, uint8_t encoding) {
 }
 
 #if defined(__arm__) && !defined(__USING_SJLJ_EXCEPTIONS__) &&                 \
-    !defined(__ARM_DWARF_EH__)
+    !defined(__ARM_DWARF_EH__) && !defined(__SEH__)
 #define USING_ARM_EHABI 1
 _Unwind_Reason_Code __gnu_unwind_frame(struct _Unwind_Exception *,
                                        struct _Unwind_Context *);
@@ -168,6 +177,10 @@ COMPILER_RT_ABI _Unwind_Reason_Code __gcc_personality_sj0(
 COMPILER_RT_ABI _Unwind_Reason_Code __gcc_personality_v0(
     _Unwind_State state, struct _Unwind_Exception *exceptionObject,
     struct _Unwind_Context *context)
+#elif defined(__SEH__)
+static _Unwind_Reason_Code __gcc_personality_imp(
+    int version, _Unwind_Action actions, uint64_t exceptionClass,
+    struct _Unwind_Exception *exceptionObject, struct _Unwind_Context *context)
 #else
 COMPILER_RT_ABI _Unwind_Reason_Code __gcc_personality_v0(
     int version, _Unwind_Action actions, uint64_t exceptionClass,
@@ -205,14 +218,14 @@ COMPILER_RT_ABI _Unwind_Reason_Code __gcc_personality_v0(
   }
   // Walk call-site table looking for range that includes current PC.
   uint8_t callSiteEncoding = *lsda++;
-  uint32_t callSiteTableLength = readULEB128(&lsda);
+  size_t callSiteTableLength = readULEB128(&lsda);
   const uint8_t *callSiteTableStart = lsda;
   const uint8_t *callSiteTableEnd = callSiteTableStart + callSiteTableLength;
   const uint8_t *p = callSiteTableStart;
   while (p < callSiteTableEnd) {
     uintptr_t start = readEncodedPointer(&p, callSiteEncoding);
-    uintptr_t length = readEncodedPointer(&p, callSiteEncoding);
-    uintptr_t landingPad = readEncodedPointer(&p, callSiteEncoding);
+    size_t length = readEncodedPointer(&p, callSiteEncoding);
+    size_t landingPad = readEncodedPointer(&p, callSiteEncoding);
     readULEB128(&p); // action value not used for C code
     if (landingPad == 0)
       continue; // no landing pad for this entry
@@ -232,3 +245,12 @@ COMPILER_RT_ABI _Unwind_Reason_Code __gcc_personality_v0(
   // No landing pad found, continue unwinding.
   return continueUnwind(exceptionObject, context);
 }
+
+#if defined(__SEH__) && !defined(__USING_SJLJ_EXCEPTIONS__)
+COMPILER_RT_ABI EXCEPTION_DISPOSITION
+__gcc_personality_seh0(PEXCEPTION_RECORD ms_exc, void *this_frame,
+                       PCONTEXT ms_orig_context, PDISPATCHER_CONTEXT ms_disp) {
+  return _GCC_specific_handler(ms_exc, this_frame, ms_orig_context, ms_disp,
+                               __gcc_personality_imp);
+}
+#endif
diff --git a/zig/lib/std/Build.zig b/zig/lib/std/Build.zig
index dbd96441b1..988a72c129 100644
--- a/zig/lib/std/Build.zig
+++ b/zig/lib/std/Build.zig
@@ -90,9 +90,6 @@ modules: std.StringArrayHashMap(*Module),
 
 named_writefiles: std.StringArrayHashMap(*Step.WriteFile),
 named_lazy_paths: std.StringArrayHashMap(LazyPath),
-/// A map from build root dirs to the corresponding `*Dependency`. This is shared with all child
-/// `Build`s.
-initialized_deps: *InitializedDepMap,
 /// The hash of this instance's package. `""` means that this is the root package.
 pkg_hash: []const u8,
 /// A mapping from dependency names to package hashes.
@@ -125,6 +122,7 @@ pub const Graph = struct {
     host: ResolvedTarget,
     incremental: ?bool = null,
     random_seed: u32 = 0,
+    dependency_cache: InitializedDepMap = .empty,
 };
 
 const AvailableDeps = []const struct { []const u8, []const u8 };
@@ -144,7 +142,7 @@ const SystemLibraryMode = enum {
     declared_enabled,
 };
 
-const InitializedDepMap = std.HashMap(InitializedDepKey, *Dependency, InitializedDepContext, std.hash_map.default_max_load_percentage);
+const InitializedDepMap = std.HashMapUnmanaged(InitializedDepKey, *Dependency, InitializedDepContext, std.hash_map.default_max_load_percentage);
 const InitializedDepKey = struct {
     build_root_string: []const u8,
     user_input_options: UserInputOptionsMap,
@@ -219,6 +217,8 @@ const UserValue = union(enum) {
     scalar: []const u8,
     list: ArrayList([]const u8),
     map: StringHashMap(*const UserValue),
+    lazy_path: LazyPath,
+    lazy_path_list: ArrayList(LazyPath),
 };
 
 const TypeId = enum {
@@ -230,6 +230,8 @@ const TypeId = enum {
     string,
     list,
     build_id,
+    lazy_path,
+    lazy_path_list,
 };
 
 const TopLevelStep = struct {
@@ -252,8 +254,6 @@ pub fn create(
     available_deps: AvailableDeps,
 ) !*Build {
     const arena = graph.arena;
-    const initialized_deps = try arena.create(InitializedDepMap);
-    initialized_deps.* = InitializedDepMap.initContext(arena, .{ .allocator = arena });
 
     const b = try arena.create(Build);
     b.* = .{
@@ -304,7 +304,6 @@ pub fn create(
         .modules = .init(arena),
         .named_writefiles = .init(arena),
         .named_lazy_paths = .init(arena),
-        .initialized_deps = initialized_deps,
         .pkg_hash = "",
         .available_deps = available_deps,
         .release_mode = .off,
@@ -398,7 +397,6 @@ fn createChildOnly(
         .modules = .init(allocator),
         .named_writefiles = .init(allocator),
         .named_lazy_paths = .init(allocator),
-        .initialized_deps = parent.initialized_deps,
         .pkg_hash = pkg_hash,
         .available_deps = pkg_deps,
         .release_mode = parent.release_mode,
@@ -439,6 +437,22 @@ fn userInputOptionsFromArgs(allocator: Allocator, args: anytype) UserInputOption
                     .used = false,
                 }) catch @panic("OOM");
             },
+            LazyPath => {
+                user_input_options.put(field.name, .{
+                    .name = field.name,
+                    .value = .{ .lazy_path = v.dupeInner(allocator) },
+                    .used = false,
+                }) catch @panic("OOM");
+            },
+            []const LazyPath => {
+                var list = ArrayList(LazyPath).initCapacity(allocator, v.len) catch @panic("OOM");
+                for (v) |lp| list.appendAssumeCapacity(lp.dupeInner(allocator));
+                user_input_options.put(field.name, .{
+                    .name = field.name,
+                    .value = .{ .lazy_path_list = list },
+                    .used = false,
+                }) catch @panic("OOM");
+            },
             []const u8 => {
                 user_input_options.put(field.name, .{
                     .name = field.name,
@@ -498,6 +512,8 @@ const OrderedUserValue = union(enum) {
     scalar: []const u8,
     list: ArrayList([]const u8),
     map: ArrayList(Pair),
+    lazy_path: LazyPath,
+    lazy_path_list: ArrayList(LazyPath),
 
     const Pair = struct {
         name: []const u8,
@@ -508,6 +524,7 @@ const OrderedUserValue = union(enum) {
     };
 
     fn hash(val: OrderedUserValue, hasher: *std.hash.Wyhash) void {
+        hasher.update(&std.mem.toBytes(std.meta.activeTag(val)));
         switch (val) {
             .flag => {},
             .scalar => |scalar| hasher.update(scalar),
@@ -518,6 +535,31 @@ const OrderedUserValue = union(enum) {
                 hasher.update(map_entry.name);
                 map_entry.value.hash(hasher);
             },
+            .lazy_path => |lp| hashLazyPath(lp, hasher),
+            .lazy_path_list => |lp_list| for (lp_list.items) |lp| {
+                hashLazyPath(lp, hasher);
+            },
+        }
+    }
+
+    fn hashLazyPath(lp: LazyPath, hasher: *std.hash.Wyhash) void {
+        switch (lp) {
+            .src_path => |sp| {
+                hasher.update(sp.owner.pkg_hash);
+                hasher.update(sp.sub_path);
+            },
+            .generated => |gen| {
+                hasher.update(gen.file.step.owner.pkg_hash);
+                hasher.update(std.mem.asBytes(&gen.up));
+                hasher.update(gen.sub_path);
+            },
+            .cwd_relative => |rel_path| {
+                hasher.update(rel_path);
+            },
+            .dependency => |dep| {
+                hasher.update(dep.dependency.builder.pkg_hash);
+                hasher.update(dep.sub_path);
+            },
         }
     }
 
@@ -541,6 +583,8 @@ const OrderedUserValue = union(enum) {
             .scalar => |scalar| .{ .scalar = scalar },
             .list => |list| .{ .list = list },
             .map => |map| .{ .map = OrderedUserValue.mapFromUnordered(allocator, map) },
+            .lazy_path => |lp| .{ .lazy_path = lp },
+            .lazy_path_list => |list| .{ .lazy_path_list = list },
         };
     }
 };
@@ -1029,7 +1073,11 @@ pub fn addConfigHeader(
 
 /// Allocator.dupe without the need to handle out of memory.
 pub fn dupe(b: *Build, bytes: []const u8) []u8 {
-    return b.allocator.dupe(u8, bytes) catch @panic("OOM");
+    return dupeInner(b.allocator, bytes);
+}
+
+pub fn dupeInner(allocator: std.mem.Allocator, bytes: []const u8) []u8 {
+    return allocator.dupe(u8, bytes) catch @panic("OOM");
 }
 
 /// Duplicates an array of strings without the need to handle out of memory.
@@ -1041,7 +1089,11 @@ pub fn dupeStrings(b: *Build, strings: []const []const u8) [][]u8 {
 
 /// Duplicates a path and converts all slashes to the OS's canonical path separator.
 pub fn dupePath(b: *Build, bytes: []const u8) []u8 {
-    const the_copy = b.dupe(bytes);
+    return dupePathInner(b.allocator, bytes);
+}
+
+fn dupePathInner(allocator: std.mem.Allocator, bytes: []const u8) []u8 {
+    const the_copy = dupeInner(allocator, bytes);
     for (the_copy) |*byte| {
         switch (byte.*) {
             '/', '\\' => byte.* = fs.path.sep,
@@ -1155,7 +1207,7 @@ pub fn option(b: *Build, comptime T: type, name_raw: []const u8, description_raw
                     return null;
                 }
             },
-            .list, .map => {
+            .list, .map, .lazy_path, .lazy_path_list => {
                 log.err("Expected -D{s} to be a boolean, but received a {s}.", .{
                     name, @tagName(option_ptr.value),
                 });
@@ -1164,7 +1216,7 @@ pub fn option(b: *Build, comptime T: type, name_raw: []const u8, description_raw
             },
         },
         .int => switch (option_ptr.value) {
-            .flag, .list, .map => {
+            .flag, .list, .map, .lazy_path, .lazy_path_list => {
                 log.err("Expected -D{s} to be an integer, but received a {s}.", .{
                     name, @tagName(option_ptr.value),
                 });
@@ -1188,7 +1240,7 @@ pub fn option(b: *Build, comptime T: type, name_raw: []const u8, description_raw
             },
         },
         .float => switch (option_ptr.value) {
-            .flag, .map, .list => {
+            .flag, .map, .list, .lazy_path, .lazy_path_list => {
                 log.err("Expected -D{s} to be a float, but received a {s}.", .{
                     name, @tagName(option_ptr.value),
                 });
@@ -1205,7 +1257,7 @@ pub fn option(b: *Build, comptime T: type, name_raw: []const u8, description_raw
             },
         },
         .@"enum" => switch (option_ptr.value) {
-            .flag, .map, .list => {
+            .flag, .map, .list, .lazy_path, .lazy_path_list => {
                 log.err("Expected -D{s} to be an enum, but received a {s}.", .{
                     name, @tagName(option_ptr.value),
                 });
@@ -1223,7 +1275,7 @@ pub fn option(b: *Build, comptime T: type, name_raw: []const u8, description_raw
             },
         },
         .string => switch (option_ptr.value) {
-            .flag, .list, .map => {
+            .flag, .list, .map, .lazy_path, .lazy_path_list => {
                 log.err("Expected -D{s} to be a string, but received a {s}.", .{
                     name, @tagName(option_ptr.value),
                 });
@@ -1233,7 +1285,7 @@ pub fn option(b: *Build, comptime T: type, name_raw: []const u8, description_raw
             .scalar => |s| return s,
         },
         .build_id => switch (option_ptr.value) {
-            .flag, .map, .list => {
+            .flag, .map, .list, .lazy_path, .lazy_path_list => {
                 log.err("Expected -D{s} to be an enum, but received a {s}.", .{
                     name, @tagName(option_ptr.value),
                 });
@@ -1251,7 +1303,7 @@ pub fn option(b: *Build, comptime T: type, name_raw: []const u8, description_raw
             },
         },
         .list => switch (option_ptr.value) {
-            .flag, .map => {
+            .flag, .map, .lazy_path, .lazy_path_list => {
                 log.err("Expected -D{s} to be a list, but received a {s}.", .{
                     name, @tagName(option_ptr.value),
                 });
@@ -1264,7 +1316,7 @@ pub fn option(b: *Build, comptime T: type, name_raw: []const u8, description_raw
             .list => |lst| return lst.items,
         },
         .enum_list => switch (option_ptr.value) {
-            .flag, .map => {
+            .flag, .map, .lazy_path, .lazy_path_list => {
                 log.err("Expected -D{s} to be a list, but received a {s}.", .{
                     name, @tagName(option_ptr.value),
                 });
@@ -1282,19 +1334,48 @@ pub fn option(b: *Build, comptime T: type, name_raw: []const u8, description_raw
             },
             .list => |lst| {
                 const Child = @typeInfo(T).pointer.child;
-                var new_list = b.allocator.alloc(Child, lst.items.len) catch @panic("OOM");
-                for (lst.items, 0..) |str, i| {
-                    const value = std.meta.stringToEnum(Child, str) orelse {
+                const new_list = b.allocator.alloc(Child, lst.items.len) catch @panic("OOM");
+                for (new_list, lst.items) |*new_item, str| {
+                    new_item.* = std.meta.stringToEnum(Child, str) orelse {
                         log.err("Expected -D{s} to be of type {s}.", .{ name, @typeName(Child) });
                         b.markInvalidUserInput();
                         b.allocator.free(new_list);
                         return null;
                     };
-                    new_list[i] = value;
                 }
                 return new_list;
             },
         },
+        .lazy_path => switch (option_ptr.value) {
+            .scalar => |s| return .{ .cwd_relative = s },
+            .lazy_path => |lp| return lp,
+            .flag, .map, .list, .lazy_path_list => {
+                log.err("Expected -D{s} to be a path, but received a {s}.", .{
+                    name, @tagName(option_ptr.value),
+                });
+                b.markInvalidUserInput();
+                return null;
+            },
+        },
+        .lazy_path_list => switch (option_ptr.value) {
+            .scalar => |s| return b.allocator.dupe(LazyPath, &[_]LazyPath{.{ .cwd_relative = s }}) catch @panic("OOM"),
+            .lazy_path => |lp| return b.allocator.dupe(LazyPath, &[_]LazyPath{lp}) catch @panic("OOM"),
+            .list => |lst| {
+                const new_list = b.allocator.alloc(LazyPath, lst.items.len) catch @panic("OOM");
+                for (new_list, lst.items) |*new_item, str| {
+                    new_item.* = .{ .cwd_relative = str };
+                }
+                return new_list;
+            },
+            .lazy_path_list => |lp_list| return lp_list.items,
+            .flag, .map => {
+                log.err("Expected -D{s} to be a path, but received a {s}.", .{
+                    name, @tagName(option_ptr.value),
+                });
+                b.markInvalidUserInput();
+                return null;
+            },
+        },
     }
 }
 
@@ -1514,6 +1595,10 @@ pub fn addUserInputOption(b: *Build, name_raw: []const u8, value_raw: []const u8
             log.warn("TODO maps as command line arguments is not implemented yet.", .{});
             return true;
         },
+        .lazy_path, .lazy_path_list => {
+            log.warn("the lazy path value type isn't added from the CLI, but somehow '{s}' is a .{}", .{ name, std.zig.fmtId(@tagName(gop.value_ptr.value)) });
+            return true;
+        },
     }
     return false;
 }
@@ -1536,10 +1621,15 @@ pub fn addUserInputFlag(b: *Build, name_raw: []const u8) !bool {
             log.err("Flag '-D{s}' conflicts with option '-D{s}={s}'.", .{ name, name, s });
             return true;
         },
-        .list, .map => {
+        .list, .map, .lazy_path_list => {
             log.err("Flag '-D{s}' conflicts with multiple options of the same name.", .{name});
             return true;
         },
+        .lazy_path => |lp| {
+            log.err("Flag '-D{s}' conflicts with option '-D{s}={s}'.", .{ name, name, lp.getDisplayName() });
+            return true;
+        },
+
         .flag => {},
     }
     return false;
@@ -1548,6 +1638,7 @@ pub fn addUserInputFlag(b: *Build, name_raw: []const u8) !bool {
 fn typeToEnum(comptime T: type) TypeId {
     return switch (T) {
         std.zig.BuildId => .build_id,
+        LazyPath => .lazy_path,
         else => return switch (@typeInfo(T)) {
             .int => .int,
             .float => .float,
@@ -1556,6 +1647,7 @@ fn typeToEnum(comptime T: type) TypeId {
             .pointer => |pointer| switch (pointer.child) {
                 u8 => .string,
                 []const u8 => .list,
+                LazyPath => .lazy_path_list,
                 else => switch (@typeInfo(pointer.child)) {
                     .@"enum" => .enum_list,
                     else => @compileError("Unsupported type: " ++ @typeName(T)),
@@ -2071,22 +2163,17 @@ pub fn dependencyFromBuildZig(
 }
 
 fn userValuesAreSame(lhs: UserValue, rhs: UserValue) bool {
+    if (std.meta.activeTag(lhs) != rhs) return false;
     switch (lhs) {
         .flag => {},
         .scalar => |lhs_scalar| {
-            const rhs_scalar = switch (rhs) {
-                .scalar => |scalar| scalar,
-                else => return false,
-            };
+            const rhs_scalar = rhs.scalar;
 
             if (!std.mem.eql(u8, lhs_scalar, rhs_scalar))
                 return false;
         },
         .list => |lhs_list| {
-            const rhs_list = switch (rhs) {
-                .list => |list| list,
-                else => return false,
-            };
+            const rhs_list = rhs.list;
 
             if (lhs_list.items.len != rhs_list.items.len)
                 return false;
@@ -2097,10 +2184,7 @@ fn userValuesAreSame(lhs: UserValue, rhs: UserValue) bool {
             }
         },
         .map => |lhs_map| {
-            const rhs_map = switch (rhs) {
-                .map => |map| map,
-                else => return false,
-            };
+            const rhs_map = rhs.map;
 
             if (lhs_map.count() != rhs_map.count())
                 return false;
@@ -2112,11 +2196,54 @@ fn userValuesAreSame(lhs: UserValue, rhs: UserValue) bool {
                     return false;
             }
         },
+        .lazy_path => |lhs_lp| {
+            const rhs_lp = rhs.lazy_path;
+            return userLazyPathsAreTheSame(lhs_lp, rhs_lp);
+        },
+        .lazy_path_list => |lhs_lp_list| {
+            const rhs_lp_list = rhs.lazy_path_list;
+            if (lhs_lp_list.items.len != rhs_lp_list.items.len) return false;
+            for (lhs_lp_list.items, rhs_lp_list.items) |lhs_lp, rhs_lp| {
+                if (!userLazyPathsAreTheSame(lhs_lp, rhs_lp)) return false;
+            }
+            return true;
+        },
     }
 
     return true;
 }
 
+fn userLazyPathsAreTheSame(lhs_lp: LazyPath, rhs_lp: LazyPath) bool {
+    if (std.meta.activeTag(lhs_lp) != rhs_lp) return false;
+    switch (lhs_lp) {
+        .src_path => |lhs_sp| {
+            const rhs_sp = rhs_lp.src_path;
+
+            if (lhs_sp.owner != rhs_sp.owner) return false;
+            if (std.mem.eql(u8, lhs_sp.sub_path, rhs_sp.sub_path)) return false;
+        },
+        .generated => |lhs_gen| {
+            const rhs_gen = rhs_lp.generated;
+
+            if (lhs_gen.file != rhs_gen.file) return false;
+            if (lhs_gen.up != rhs_gen.up) return false;
+            if (std.mem.eql(u8, lhs_gen.sub_path, rhs_gen.sub_path)) return false;
+        },
+        .cwd_relative => |lhs_rel_path| {
+            const rhs_rel_path = rhs_lp.cwd_relative;
+
+            if (!std.mem.eql(u8, lhs_rel_path, rhs_rel_path)) return false;
+        },
+        .dependency => |lhs_dep| {
+            const rhs_dep = rhs_lp.dependency;
+
+            if (lhs_dep.dependency != rhs_dep.dependency) return false;
+            if (!std.mem.eql(u8, lhs_dep.sub_path, rhs_dep.sub_path)) return false;
+        },
+    }
+    return true;
+}
+
 fn dependencyInner(
     b: *Build,
     name: []const u8,
@@ -2127,10 +2254,10 @@ fn dependencyInner(
     args: anytype,
 ) *Dependency {
     const user_input_options = userInputOptionsFromArgs(b.allocator, args);
-    if (b.initialized_deps.get(.{
+    if (b.graph.dependency_cache.getContext(.{
         .build_root_string = build_root_string,
         .user_input_options = user_input_options,
-    })) |dep|
+    }, .{ .allocator = b.graph.arena })) |dep|
         return dep;
 
     const build_root: std.Build.Cache.Directory = .{
@@ -2155,10 +2282,10 @@ fn dependencyInner(
     const dep = b.allocator.create(Dependency) catch @panic("OOM");
     dep.* = .{ .builder = sub_builder };
 
-    b.initialized_deps.put(.{
+    b.graph.dependency_cache.putContext(b.graph.arena, .{
         .build_root_string = build_root_string,
         .user_input_options = user_input_options,
-    }, dep) catch @panic("OOM");
+    }, dep, .{ .allocator = b.graph.arena }) catch @panic("OOM");
     return dep;
 }
 
@@ -2441,16 +2568,20 @@ pub const LazyPath = union(enum) {
     /// The `b` parameter is only used for its allocator. All *Build instances
     /// share the same allocator.
     pub fn dupe(lazy_path: LazyPath, b: *Build) LazyPath {
+        return lazy_path.dupeInner(b.allocator);
+    }
+
+    fn dupeInner(lazy_path: LazyPath, allocator: std.mem.Allocator) LazyPath {
         return switch (lazy_path) {
             .src_path => |sp| .{ .src_path = .{
                 .owner = sp.owner,
                 .sub_path = sp.owner.dupePath(sp.sub_path),
             } },
-            .cwd_relative => |p| .{ .cwd_relative = b.dupePath(p) },
+            .cwd_relative => |p| .{ .cwd_relative = dupePathInner(allocator, p) },
             .generated => |gen| .{ .generated = .{
                 .file = gen.file,
                 .up = gen.up,
-                .sub_path = b.dupePath(gen.sub_path),
+                .sub_path = dupePathInner(allocator, gen.sub_path),
             } },
             .dependency => |dep| .{ .dependency = dep },
         };
diff --git a/zig/lib/std/Build/Cache.zig b/zig/lib/std/Build/Cache.zig
index 93908807eb..53f1dcff29 100644
--- a/zig/lib/std/Build/Cache.zig
+++ b/zig/lib/std/Build/Cache.zig
@@ -398,12 +398,19 @@ pub const Manifest = struct {
         return gop.index;
     }
 
+    /// Deprecated, use `addOptionalFilePath`.
     pub fn addOptionalFile(self: *Manifest, optional_file_path: ?[]const u8) !void {
         self.hash.add(optional_file_path != null);
         const file_path = optional_file_path orelse return;
         _ = try self.addFile(file_path, null);
     }
 
+    pub fn addOptionalFilePath(self: *Manifest, optional_file_path: ?Path) !void {
+        self.hash.add(optional_file_path != null);
+        const file_path = optional_file_path orelse return;
+        _ = try self.addFilePath(file_path, null);
+    }
+
     pub fn addListOfFiles(self: *Manifest, list_of_files: []const []const u8) !void {
         self.hash.add(list_of_files.len);
         for (list_of_files) |file_path| {
diff --git a/zig/lib/std/Build/Cache/Path.zig b/zig/lib/std/Build/Cache/Path.zig
index ee0666b70a..a14c6cd7a4 100644
--- a/zig/lib/std/Build/Cache/Path.zig
+++ b/zig/lib/std/Build/Cache/Path.zig
@@ -11,7 +11,11 @@ pub fn clone(p: Path, arena: Allocator) Allocator.Error!Path {
 }
 
 pub fn cwd() Path {
-    return .{ .root_dir = Cache.Directory.cwd() };
+    return initCwd("");
+}
+
+pub fn initCwd(sub_path: []const u8) Path {
+    return .{ .root_dir = Cache.Directory.cwd(), .sub_path = sub_path };
 }
 
 pub fn join(p: Path, arena: Allocator, sub_path: []const u8) Allocator.Error!Path {
@@ -126,6 +130,14 @@ pub fn makePath(p: Path, sub_path: []const u8) !void {
     return p.root_dir.handle.makePath(joined_path);
 }
 
+pub fn toString(p: Path, allocator: Allocator) Allocator.Error![]u8 {
+    return std.fmt.allocPrint(allocator, "{}", .{p});
+}
+
+pub fn toStringZ(p: Path, allocator: Allocator) Allocator.Error![:0]u8 {
+    return std.fmt.allocPrintZ(allocator, "{}", .{p});
+}
+
 pub fn format(
     self: Path,
     comptime fmt_string: []const u8,
@@ -137,7 +149,7 @@ pub fn format(
         const stringEscape = std.zig.stringEscape;
         const f = switch (fmt_string[0]) {
             'q' => "",
-            '\'' => '\'',
+            '\'' => "\'",
             else => @compileError("unsupported format string: " ++ fmt_string),
         };
         if (self.root_dir.path) |p| {
@@ -182,6 +194,14 @@ pub fn subPathOrDot(self: Path) []const u8 {
     return if (self.sub_path.len == 0) "." else self.sub_path;
 }
 
+pub fn stem(p: Path) []const u8 {
+    return fs.path.stem(p.sub_path);
+}
+
+pub fn basename(p: Path) []const u8 {
+    return fs.path.basename(p.sub_path);
+}
+
 /// Useful to make `Path` a key in `std.ArrayHashMap`.
 pub const TableAdapter = struct {
     pub const Hash = std.hash.Wyhash;
diff --git a/zig/lib/std/Build/Module.zig b/zig/lib/std/Build/Module.zig
index 635e6cc334..253945b3d7 100644
--- a/zig/lib/std/Build/Module.zig
+++ b/zig/lib/std/Build/Module.zig
@@ -135,6 +135,44 @@ pub const IncludeDir = union(enum) {
     framework_path_system: LazyPath,
     other_step: *Step.Compile,
     config_header_step: *Step.ConfigHeader,
+
+    pub fn appendZigProcessFlags(
+        include_dir: IncludeDir,
+        b: *std.Build,
+        zig_args: *std.ArrayList([]const u8),
+        asking_step: ?*Step,
+    ) !void {
+        switch (include_dir) {
+            .path => |include_path| {
+                try zig_args.appendSlice(&.{ "-I", include_path.getPath2(b, asking_step) });
+            },
+            .path_system => |include_path| {
+                try zig_args.appendSlice(&.{ "-isystem", include_path.getPath2(b, asking_step) });
+            },
+            .path_after => |include_path| {
+                try zig_args.appendSlice(&.{ "-idirafter", include_path.getPath2(b, asking_step) });
+            },
+            .framework_path => |include_path| {
+                try zig_args.appendSlice(&.{ "-F", include_path.getPath2(b, asking_step) });
+            },
+            .framework_path_system => |include_path| {
+                try zig_args.appendSlice(&.{ "-iframework", include_path.getPath2(b, asking_step) });
+            },
+            .other_step => |other| {
+                if (other.generated_h) |header| {
+                    try zig_args.appendSlice(&.{ "-isystem", std.fs.path.dirname(header.getPath()).? });
+                }
+                if (other.installed_headers_include_tree) |include_tree| {
+                    try zig_args.appendSlice(&.{ "-I", include_tree.generated_directory.getPath() });
+                }
+            },
+            .config_header_step => |config_header| {
+                const full_file_path = config_header.output_file.getPath();
+                const header_dir_path = full_file_path[0 .. full_file_path.len - config_header.include_path.len];
+                try zig_args.appendSlice(&.{ "-I", header_dir_path });
+            },
+        }
+    }
 };
 
 pub const LinkFrameworkOptions = struct {
@@ -690,36 +728,7 @@ pub fn appendZigProcessFlags(
     }
 
     for (m.include_dirs.items) |include_dir| {
-        switch (include_dir) {
-            .path => |include_path| {
-                try zig_args.appendSlice(&.{ "-I", include_path.getPath2(b, asking_step) });
-            },
-            .path_system => |include_path| {
-                try zig_args.appendSlice(&.{ "-isystem", include_path.getPath2(b, asking_step) });
-            },
-            .path_after => |include_path| {
-                try zig_args.appendSlice(&.{ "-idirafter", include_path.getPath2(b, asking_step) });
-            },
-            .framework_path => |include_path| {
-                try zig_args.appendSlice(&.{ "-F", include_path.getPath2(b, asking_step) });
-            },
-            .framework_path_system => |include_path| {
-                try zig_args.appendSlice(&.{ "-iframework", include_path.getPath2(b, asking_step) });
-            },
-            .other_step => |other| {
-                if (other.generated_h) |header| {
-                    try zig_args.appendSlice(&.{ "-isystem", std.fs.path.dirname(header.getPath()).? });
-                }
-                if (other.installed_headers_include_tree) |include_tree| {
-                    try zig_args.appendSlice(&.{ "-I", include_tree.generated_directory.getPath() });
-                }
-            },
-            .config_header_step => |config_header| {
-                const full_file_path = config_header.output_file.getPath();
-                const header_dir_path = full_file_path[0 .. full_file_path.len - config_header.include_path.len];
-                try zig_args.appendSlice(&.{ "-I", header_dir_path });
-            },
-        }
+        try include_dir.appendZigProcessFlags(b, zig_args, asking_step);
     }
 
     try zig_args.appendSlice(m.c_macros.items);
diff --git a/zig/lib/std/Build/Step/CheckObject.zig b/zig/lib/std/Build/Step/CheckObject.zig
index 54f7bc7412..00ea5013de 100644
--- a/zig/lib/std/Build/Step/CheckObject.zig
+++ b/zig/lib/std/Build/Step/CheckObject.zig
@@ -557,15 +557,15 @@ fn make(step: *Step, make_options: Step.MakeOptions) !void {
     const check_object: *CheckObject = @fieldParentPtr("step", step);
     try step.singleUnchangingWatchInput(check_object.source);
 
-    const src_path = check_object.source.getPath2(b, step);
-    const contents = fs.cwd().readFileAllocOptions(
+    const src_path = check_object.source.getPath3(b, step);
+    const contents = src_path.root_dir.handle.readFileAllocOptions(
         gpa,
-        src_path,
+        src_path.sub_path,
         check_object.max_bytes,
         null,
         @alignOf(u64),
         null,
-    ) catch |err| return step.fail("unable to read '{s}': {s}", .{ src_path, @errorName(err) });
+    ) catch |err| return step.fail("unable to read '{'}': {s}", .{ src_path, @errorName(err) });
 
     var vars = std.StringHashMap(u64).init(gpa);
     for (check_object.checks.items) |chk| {
@@ -640,8 +640,13 @@ fn make(step: *Step, make_options: Step.MakeOptions) !void {
                             \\{s}
                             \\========= but parsed file does not contain it: =======
                             \\{s}
-                            \\======================================================
-                        , .{ fmtMessageString(chk.kind, act.phrase.resolve(b, step)), fmtMessageString(chk.kind, output) });
+                            \\========= file path: =================================
+                            \\{}
+                        , .{
+                            fmtMessageString(chk.kind, act.phrase.resolve(b, step)),
+                            fmtMessageString(chk.kind, output),
+                            src_path,
+                        });
                     }
                 },
 
@@ -655,8 +660,13 @@ fn make(step: *Step, make_options: Step.MakeOptions) !void {
                             \\*{s}*
                             \\========= but parsed file does not contain it: =======
                             \\{s}
-                            \\======================================================
-                        , .{ fmtMessageString(chk.kind, act.phrase.resolve(b, step)), fmtMessageString(chk.kind, output) });
+                            \\========= file path: =================================
+                            \\{}
+                        , .{
+                            fmtMessageString(chk.kind, act.phrase.resolve(b, step)),
+                            fmtMessageString(chk.kind, output),
+                            src_path,
+                        });
                     }
                 },
 
@@ -669,8 +679,13 @@ fn make(step: *Step, make_options: Step.MakeOptions) !void {
                             \\{s}
                             \\========= but parsed file does contain it: ========
                             \\{s}
-                            \\===================================================
-                        , .{ fmtMessageString(chk.kind, act.phrase.resolve(b, step)), fmtMessageString(chk.kind, output) });
+                            \\========= file path: ==============================
+                            \\{}
+                        , .{
+                            fmtMessageString(chk.kind, act.phrase.resolve(b, step)),
+                            fmtMessageString(chk.kind, output),
+                            src_path,
+                        });
                     }
                 },
 
@@ -684,8 +699,13 @@ fn make(step: *Step, make_options: Step.MakeOptions) !void {
                             \\{s}
                             \\========= but parsed file does not contain it: =======
                             \\{s}
-                            \\======================================================
-                        , .{ act.phrase.resolve(b, step), fmtMessageString(chk.kind, output) });
+                            \\========= file path: ==============================
+                            \\{}
+                        , .{
+                            act.phrase.resolve(b, step),
+                            fmtMessageString(chk.kind, output),
+                            src_path,
+                        });
                     }
                 },
 
diff --git a/zig/lib/std/Build/Step/Compile.zig b/zig/lib/std/Build/Step/Compile.zig
index 0f0b5d3201..a977dc3056 100644
--- a/zig/lib/std/Build/Step/Compile.zig
+++ b/zig/lib/std/Build/Step/Compile.zig
@@ -235,6 +235,7 @@ sanitize_coverage_trace_pc_guard: ?bool = null,
 pub const ExpectedCompileErrors = union(enum) {
     contains: []const u8,
     exact: []const []const u8,
+    starts_with: []const u8,
 };
 
 pub const Entry = union(enum) {
@@ -1958,6 +1959,17 @@ fn checkCompileErrors(compile: *Compile) !void {
 
     // TODO merge this with the testing.expectEqualStrings logic, and also CheckFile
     switch (expect_errors) {
+        .starts_with => |expect_starts_with| {
+            if (std.mem.startsWith(u8, actual_stderr, expect_starts_with)) return;
+            return compile.step.fail(
+                \\
+                \\========= should start with: ============
+                \\{s}
+                \\========= but not found: ================
+                \\{s}
+                \\=========================================
+            , .{ expect_starts_with, actual_stderr });
+        },
         .contains => |expect_line| {
             while (actual_line_it.next()) |actual_line| {
                 if (!matchCompileError(actual_line, expect_line)) continue;
diff --git a/zig/lib/std/Build/Step/ObjCopy.zig b/zig/lib/std/Build/Step/ObjCopy.zig
index 6ed23d3fb4..8f0f62e222 100644
--- a/zig/lib/std/Build/Step/ObjCopy.zig
+++ b/zig/lib/std/Build/Step/ObjCopy.zig
@@ -26,6 +26,50 @@ pub const Strip = enum {
     debug_and_symbols,
 };
 
+pub const SectionFlags = packed struct {
+    /// add SHF_ALLOC
+    alloc: bool = false,
+
+    /// if section is SHT_NOBITS, set SHT_PROGBITS, otherwise do nothing
+    contents: bool = false,
+
+    /// if section is SHT_NOBITS, set SHT_PROGBITS, otherwise do nothing (same as contents)
+    load: bool = false,
+
+    /// readonly: clear default SHF_WRITE flag
+    readonly: bool = false,
+
+    /// add SHF_EXECINSTR
+    code: bool = false,
+
+    /// add SHF_EXCLUDE
+    exclude: bool = false,
+
+    /// add SHF_X86_64_LARGE. Fatal error if target is not x86_64
+    large: bool = false,
+
+    /// add SHF_MERGE
+    merge: bool = false,
+
+    /// add SHF_STRINGS
+    strings: bool = false,
+};
+
+pub const AddSection = struct {
+    section_name: []const u8,
+    file_path: std.Build.LazyPath,
+};
+
+pub const SetSectionAlignment = struct {
+    section_name: []const u8,
+    alignment: u32,
+};
+
+pub const SetSectionFlags = struct {
+    section_name: []const u8,
+    flags: SectionFlags,
+};
+
 step: Step,
 input_file: std.Build.LazyPath,
 basename: []const u8,
@@ -38,6 +82,10 @@ pad_to: ?u64,
 strip: Strip,
 compress_debug: bool,
 
+add_section: ?AddSection,
+set_section_alignment: ?SetSectionAlignment,
+set_section_flags: ?SetSectionFlags,
+
 pub const Options = struct {
     basename: ?[]const u8 = null,
     format: ?RawFormat = null,
@@ -51,6 +99,10 @@ pub const Options = struct {
     /// note: the `basename` is baked into the elf file to specify the link to the separate debug file.
     /// see https://sourceware.org/gdb/onlinedocs/gdb/Separate-Debug-Files.html
     extract_to_separate_file: bool = false,
+
+    add_section: ?AddSection = null,
+    set_section_alignment: ?SetSectionAlignment = null,
+    set_section_flags: ?SetSectionFlags = null,
 };
 
 pub fn create(
@@ -75,6 +127,9 @@ pub fn create(
         .pad_to = options.pad_to,
         .strip = options.strip,
         .compress_debug = options.compress_debug,
+        .add_section = options.add_section,
+        .set_section_alignment = options.set_section_alignment,
+        .set_section_flags = options.set_section_flags,
     };
     input_file.addStepDependencies(&objcopy.step);
     return objcopy;
@@ -155,6 +210,31 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
     if (objcopy.output_file_debug != null) {
         try argv.appendSlice(&.{b.fmt("--extract-to={s}", .{full_dest_path_debug})});
     }
+    if (objcopy.add_section) |section| {
+        try argv.append("--add-section");
+        try argv.appendSlice(&.{b.fmt("{s}={s}", .{ section.section_name, section.file_path.getPath(b) })});
+    }
+    if (objcopy.set_section_alignment) |set_align| {
+        try argv.append("--set-section-alignment");
+        try argv.appendSlice(&.{b.fmt("{s}={d}", .{ set_align.section_name, set_align.alignment })});
+    }
+    if (objcopy.set_section_flags) |set_flags| {
+        const f = set_flags.flags;
+        // trailing comma is allowed
+        try argv.append("--set-section-flags");
+        try argv.appendSlice(&.{b.fmt("{s}={s}{s}{s}{s}{s}{s}{s}{s}{s}", .{
+            set_flags.section_name,
+            if (f.alloc) "alloc," else "",
+            if (f.contents) "contents," else "",
+            if (f.load) "load," else "",
+            if (f.readonly) "readonly," else "",
+            if (f.code) "code," else "",
+            if (f.exclude) "exclude," else "",
+            if (f.large) "large," else "",
+            if (f.merge) "merge," else "",
+            if (f.strings) "strings," else "",
+        })});
+    }
 
     try argv.appendSlice(&.{ full_src_path, full_dest_path });
 
diff --git a/zig/lib/std/Build/Step/TranslateC.zig b/zig/lib/std/Build/Step/TranslateC.zig
index 9ef5f7acdf..13f4375999 100644
--- a/zig/lib/std/Build/Step/TranslateC.zig
+++ b/zig/lib/std/Build/Step/TranslateC.zig
@@ -1,5 +1,6 @@
 const std = @import("std");
 const Step = std.Build.Step;
+const LazyPath = std.Build.LazyPath;
 const fs = std.fs;
 const mem = std.mem;
 
@@ -9,7 +10,7 @@ pub const base_id: Step.Id = .translate_c;
 
 step: Step,
 source: std.Build.LazyPath,
-include_dirs: std.ArrayList([]const u8),
+include_dirs: std.ArrayList(std.Build.Module.IncludeDir),
 c_macros: std.ArrayList([]const u8),
 out_basename: []const u8,
 target: std.Build.ResolvedTarget,
@@ -37,7 +38,7 @@ pub fn create(owner: *std.Build, options: Options) *TranslateC {
             .makeFn = make,
         }),
         .source = source,
-        .include_dirs = std.ArrayList([]const u8).init(owner.allocator),
+        .include_dirs = std.ArrayList(std.Build.Module.IncludeDir).init(owner.allocator),
         .c_macros = std.ArrayList([]const u8).init(owner.allocator),
         .out_basename = undefined,
         .target = options.target,
@@ -95,8 +96,45 @@ pub fn createModule(translate_c: *TranslateC) *std.Build.Module {
     });
 }
 
-pub fn addIncludeDir(translate_c: *TranslateC, include_dir: []const u8) void {
-    translate_c.include_dirs.append(translate_c.step.owner.dupePath(include_dir)) catch @panic("OOM");
+pub fn addAfterIncludePath(translate_c: *TranslateC, lazy_path: LazyPath) void {
+    const b = translate_c.step.owner;
+    translate_c.include_dirs.append(.{ .path_after = lazy_path.dupe(b) }) catch
+        @panic("OOM");
+    lazy_path.addStepDependencies(&translate_c.step);
+}
+
+pub fn addSystemIncludePath(translate_c: *TranslateC, lazy_path: LazyPath) void {
+    const b = translate_c.step.owner;
+    translate_c.include_dirs.append(.{ .path_system = lazy_path.dupe(b) }) catch
+        @panic("OOM");
+    lazy_path.addStepDependencies(&translate_c.step);
+}
+
+pub fn addIncludePath(translate_c: *TranslateC, lazy_path: LazyPath) void {
+    const b = translate_c.step.owner;
+    translate_c.include_dirs.append(.{ .path = lazy_path.dupe(b) }) catch
+        @panic("OOM");
+    lazy_path.addStepDependencies(&translate_c.step);
+}
+
+pub fn addConfigHeader(translate_c: *TranslateC, config_header: *Step.ConfigHeader) void {
+    translate_c.include_dirs.append(.{ .config_header_step = config_header }) catch
+        @panic("OOM");
+    translate_c.step.dependOn(&config_header.step);
+}
+
+pub fn addSystemFrameworkPath(translate_c: *TranslateC, directory_path: LazyPath) void {
+    const b = translate_c.step.owner;
+    translate_c.include_dirs.append(.{ .framework_path_system = directory_path.dupe(b) }) catch
+        @panic("OOM");
+    directory_path.addStepDependencies(&translate_c.step);
+}
+
+pub fn addFrameworkPath(translate_c: *TranslateC, directory_path: LazyPath) void {
+    const b = translate_c.step.owner;
+    translate_c.include_dirs.append(.{ .framework_path = directory_path.dupe(b) }) catch
+        @panic("OOM");
+    directory_path.addStepDependencies(&translate_c.step);
 }
 
 pub fn addCheckFile(translate_c: *TranslateC, expected_matches: []const []const u8) *Step.CheckFile {
@@ -147,8 +185,7 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
     }
 
     for (translate_c.include_dirs.items) |include_dir| {
-        try argv_list.append("-I");
-        try argv_list.append(include_dir);
+        try include_dir.appendZigProcessFlags(b, &argv_list, step);
     }
 
     for (translate_c.c_macros.items) |c_macro| {
diff --git a/zig/lib/std/Build/Watch.zig b/zig/lib/std/Build/Watch.zig
index c1a9e80b8e..c8f6c0d64f 100644
--- a/zig/lib/std/Build/Watch.zig
+++ b/zig/lib/std/Build/Watch.zig
@@ -516,7 +516,7 @@ const Os = switch (builtin.os.tag) {
 pub fn init() !Watch {
     switch (builtin.os.tag) {
         .linux => {
-            const fan_fd = try std.posix.fanotify_init(.{
+            const fan_fd = std.posix.fanotify_init(.{
                 .CLASS = .NOTIF,
                 .CLOEXEC = true,
                 .NONBLOCK = true,
@@ -524,7 +524,10 @@ pub fn init() !Watch {
                 .REPORT_DIR_FID = true,
                 .REPORT_FID = true,
                 .REPORT_TARGET_FID = true,
-            }, 0);
+            }, 0) catch |err| switch (err) {
+                error.UnsupportedFlags => fatal("fanotify_init failed due to old kernel; requires 5.17+", .{}),
+                else => |e| return e,
+            };
             return .{
                 .dir_table = .{},
                 .os = switch (builtin.os.tag) {
diff --git a/zig/lib/std/Target.zig b/zig/lib/std/Target.zig
index 58fbaab8b1..efe8ad4809 100644
--- a/zig/lib/std/Target.zig
+++ b/zig/lib/std/Target.zig
@@ -66,13 +66,13 @@ pub const Os = struct {
         nvcl,
         opencl,
         opengl,
-        shadermodel,
         vulkan,
 
         // LLVM tags deliberately omitted:
         // - darwin
         // - kfreebsd
         // - nacl
+        // - shadermodel
 
         pub inline fn isDarwin(tag: Tag) bool {
             return switch (tag) {
@@ -113,7 +113,7 @@ pub const Os = struct {
 
         pub fn staticLibSuffix(tag: Tag, abi: Abi) [:0]const u8 {
             return switch (abi) {
-                .msvc => ".lib",
+                .msvc, .itanium => ".lib",
                 else => switch (tag) {
                     .windows, .uefi => ".lib",
                     else => ".a",
@@ -138,7 +138,7 @@ pub const Os = struct {
 
         pub fn libPrefix(tag: Os.Tag, abi: Abi) [:0]const u8 {
             return switch (abi) {
-                .msvc => "",
+                .msvc, .itanium => "",
                 else => switch (tag) {
                     .windows, .uefi => "",
                     else => "lib",
@@ -178,7 +178,6 @@ pub const Os = struct {
                 .hermit,
                 .hurd,
                 .emscripten,
-                .shadermodel,
                 .uefi,
                 .opencl, // TODO: OpenCL versions
                 .opengl, // TODO: GLSL versions
@@ -189,7 +188,9 @@ pub const Os = struct {
                 .other,
                 => .none,
 
-                .bridgeos,
+                // This should use semver once we determine the version history.
+                .bridgeos => .none,
+
                 .driverkit,
                 .freebsd,
                 .macos,
@@ -408,7 +409,6 @@ pub const Os = struct {
                 .hermit,
                 .hurd,
                 .emscripten,
-                .shadermodel,
                 .uefi,
                 .opencl, // TODO: OpenCL versions
                 .opengl, // TODO: GLSL versions
@@ -613,7 +613,6 @@ pub const Os = struct {
             .hurd,
             .wasi,
             .emscripten,
-            .shadermodel,
             .uefi,
             .opencl,
             .opengl,
@@ -633,6 +632,7 @@ pub const avr = @import("Target/avr.zig");
 pub const bpf = @import("Target/bpf.zig");
 pub const csky = @import("Target/csky.zig");
 pub const hexagon = @import("Target/hexagon.zig");
+pub const lanai = @import("Target/lanai.zig");
 pub const loongarch = @import("Target/loongarch.zig");
 pub const m68k = @import("Target/m68k.zig");
 pub const mips = @import("Target/mips.zig");
@@ -646,7 +646,9 @@ pub const s390x = @import("Target/s390x.zig");
 pub const ve = @import("Target/ve.zig");
 pub const wasm = @import("Target/wasm.zig");
 pub const x86 = @import("Target/x86.zig");
+pub const xcore = @import("Target/xcore.zig");
 pub const xtensa = @import("Target/xtensa.zig");
+pub const propeller = @import("Target/propeller.zig");
 
 pub const Abi = enum {
     none,
@@ -664,6 +666,7 @@ pub const Abi = enum {
     eabihf,
     ilp32,
     android,
+    androideabi,
     musl,
     musleabi,
     musleabihf,
@@ -673,75 +676,136 @@ pub const Abi = enum {
     cygnus,
     simulator,
     macabi,
-    pixel,
-    vertex,
-    geometry,
-    hull,
-    domain,
-    compute,
-    library,
-    raygeneration,
-    intersection,
-    anyhit,
-    closesthit,
-    miss,
-    callable,
-    mesh,
-    amplification,
     ohos,
+    ohoseabi,
 
     // LLVM tags deliberately omitted:
-    // - gnuf64
+    // - amplification
+    // - anyhit
+    // - callable
+    // - closesthit
+    // - compute
     // - coreclr
+    // - domain
+    // - geometry
+    // - gnuf64
+    // - hull
+    // - intersection
+    // - library
+    // - mesh
+    // - miss
+    // - pixel
+    // - raygeneration
+    // - vertex
 
     pub fn default(arch: Cpu.Arch, os: Os) Abi {
         return if (arch.isWasm()) .musl else switch (os.tag) {
             .freestanding,
-            .dragonfly,
-            .ps3,
-            .zos,
-            .rtems,
-            .aix,
-            .cuda,
-            .nvcl,
-            .amdhsa,
-            .ps4,
-            .ps5,
-            .elfiamcu,
-            .mesa3d,
-            .contiki,
-            .amdpal,
-            .hermit,
             .other,
-            => .eabi,
-            .openbsd,
-            .freebsd,
-            .fuchsia,
-            .netbsd,
-            .hurd,
-            .haiku,
-            .windows,
-            => .gnu,
-            .uefi => .msvc,
+            => switch (arch) {
+                // Soft float is usually a sane default for freestanding.
+                .arm,
+                .armeb,
+                .thumb,
+                .thumbeb,
+                .csky,
+                .mips,
+                .mipsel,
+                .powerpc,
+                .powerpcle,
+                => .eabi,
+                else => .none,
+            },
+            .aix,
+            => if (arch == .powerpc) .eabihf else .none,
             .linux,
             .wasi,
             .emscripten,
             => .musl,
-            .bridgeos,
-            .opencl,
-            .opengl,
-            .vulkan,
-            .plan9, // TODO specify abi
-            .macos,
+            .rtems,
+            => switch (arch) {
+                .arm,
+                .armeb,
+                .thumb,
+                .thumbeb,
+                .mips,
+                .mipsel,
+                => .eabi,
+                .powerpc,
+                => .eabihf,
+                else => .none,
+            },
+            .hurd,
+            .windows,
+            => .gnu,
+            .freebsd,
+            => switch (arch) {
+                .arm,
+                .armeb,
+                .thumb,
+                .thumbeb,
+                .powerpc,
+                => .eabihf,
+                .mips,
+                .mipsel,
+                => .eabi,
+                else => .none,
+            },
+            .netbsd,
+            => switch (arch) {
+                .arm,
+                .armeb,
+                .thumb,
+                .thumbeb,
+                .powerpc,
+                => .eabihf,
+                .mips,
+                .mipsel,
+                => .eabi,
+                else => .none,
+            },
+            .openbsd,
+            => switch (arch) {
+                .arm,
+                .thumb,
+                => .eabi,
+                .powerpc,
+                => .eabihf,
+                else => .none,
+            },
             .ios,
+            => if (arch == .x86_64) .macabi else .none,
             .tvos,
-            .watchos,
             .visionos,
+            => if (arch == .x86_64) .simulator else .none,
+            .uefi,
+            => .msvc,
+            .contiki,
+            .elfiamcu,
+            .fuchsia,
+            .hermit,
+            .haiku,
+            .plan9,
+            .serenity,
+            .zos,
+            .dragonfly,
+            .bridgeos,
             .driverkit,
-            .shadermodel,
-            .solaris,
+            .macos,
+            .watchos,
             .illumos,
-            .serenity,
+            .solaris,
+            .ps3,
+            .ps4,
+            .ps5,
+            .amdhsa,
+            .amdpal,
+            .cuda,
+            .mesa3d,
+            .nvcl,
+            .opencl,
+            .opengl,
+            .vulkan,
             => .none,
         };
     }
@@ -764,19 +828,37 @@ pub const Abi = enum {
 
     pub inline fn isMusl(abi: Abi) bool {
         return switch (abi) {
-            .musl, .musleabi, .musleabihf, .muslx32 => true,
-            .ohos => true,
+            .musl,
+            .musleabi,
+            .musleabihf,
+            .muslx32,
+            => true,
+            else => abi.isOpenHarmony(),
+        };
+    }
+
+    pub inline fn isOpenHarmony(abi: Abi) bool {
+        return switch (abi) {
+            .ohos, .ohoseabi => true,
+            else => false,
+        };
+    }
+
+    pub inline fn isAndroid(abi: Abi) bool {
+        return switch (abi) {
+            .android, .androideabi => true,
             else => false,
         };
     }
 
     pub inline fn floatAbi(abi: Abi) FloatAbi {
         return switch (abi) {
+            .androideabi,
             .eabi,
             .gnueabi,
             .musleabi,
             .gnusf,
-            .ohos,
+            .ohoseabi,
             => .soft,
             else => .hard,
         };
@@ -788,8 +870,6 @@ pub const ObjectFormat = enum {
     c,
     /// The Common Object File Format used by Windows and UEFI.
     coff,
-    /// The DirectX Container format containing either DXIL or DXBC.
-    dxcontainer,
     /// The Executable and Linkable Format used by many Unixes.
     elf,
     /// The Generalized Object File Format used by z/OS.
@@ -811,11 +891,13 @@ pub const ObjectFormat = enum {
     /// The eXtended Common Object File Format used by AIX.
     xcoff,
 
+    // LLVM tags deliberately omitted:
+    // - dxcontainer
+
     pub fn fileExt(of: ObjectFormat, arch: Cpu.Arch) [:0]const u8 {
         return switch (of) {
             .c => ".c",
             .coff => ".obj",
-            .dxcontainer => ".dxil",
             .elf, .goff, .macho, .wasm, .xcoff => ".o",
             .hex => ".ihex",
             .nvptx => ".ptx",
@@ -833,7 +915,6 @@ pub const ObjectFormat = enum {
             .uefi, .windows => .coff,
             .zos => .goff,
             else => switch (arch) {
-                .dxil => .dxcontainer,
                 .nvptx, .nvptx64 => .nvptx,
                 .spirv, .spirv32, .spirv64 => .spirv,
                 .wasm32, .wasm64 => .wasm,
@@ -848,7 +929,7 @@ pub fn toElfMachine(target: Target) std.elf.EM {
 
     return switch (target.cpu.arch) {
         .amdgcn => .AMDGPU,
-        .arc => .ARC_COMPACT2,
+        .arc => .ARC_COMPACT,
         .arm, .armeb, .thumb, .thumbeb => .ARM,
         .aarch64, .aarch64_be => .AARCH64,
         .avr => .AVR,
@@ -868,18 +949,20 @@ pub fn toElfMachine(target: Target) std.elf.EM {
         .sparc => if (Target.sparc.featureSetHas(target.cpu.features, .v9)) .SPARC32PLUS else .SPARC,
         .sparc64 => .SPARCV9,
         .spu_2 => .SPU_2,
+        .ve => .VE,
         .x86 => .@"386",
         .x86_64 => .X86_64,
         .xcore => .XCORE,
         .xtensa => .XTENSA,
 
-        .dxil,
+        .propeller1 => .PROPELLER,
+        .propeller2 => .PROPELLER2,
+
         .nvptx,
         .nvptx64,
         .spirv,
         .spirv32,
         .spirv64,
-        .ve,
         .wasm32,
         .wasm64,
         => .NONE,
@@ -907,7 +990,6 @@ pub fn toCoffMachine(target: Target) std.coff.MachineType {
         .bpfel,
         .bpfeb,
         .csky,
-        .dxil,
         .hexagon,
         .kalimba,
         .lanai,
@@ -935,6 +1017,8 @@ pub fn toCoffMachine(target: Target) std.coff.MachineType {
         .wasm64,
         .xcore,
         .xtensa,
+        .propeller1,
+        .propeller2,
         => .UNKNOWN,
     };
 }
@@ -1133,7 +1217,6 @@ pub const Cpu = struct {
         bpfel,
         bpfeb,
         csky,
-        dxil,
         hexagon,
         kalimba,
         lanai,
@@ -1151,6 +1234,8 @@ pub const Cpu = struct {
         powerpcle,
         powerpc64,
         powerpc64le,
+        propeller1,
+        propeller2,
         riscv32,
         riscv64,
         s390x,
@@ -1172,6 +1257,7 @@ pub const Cpu = struct {
         // - aarch64_32
         // - amdil
         // - amdil64
+        // - dxil
         // - le32
         // - le64
         // - r600
@@ -1303,6 +1389,14 @@ pub const Cpu = struct {
             };
         }
 
+        /// Returns if the architecture is a Parallax propeller architecture.
+        pub inline fn isPropeller(arch: Arch) bool {
+            return switch (arch) {
+                .propeller1, .propeller2 => true,
+                else => false,
+            };
+        }
+
         pub fn parseCpuModel(arch: Arch, cpu_name: []const u8) !*const Cpu.Model {
             for (arch.allCpuModels()) |cpu| {
                 if (std.mem.eql(u8, cpu_name, cpu.name)) {
@@ -1344,10 +1438,11 @@ pub const Cpu = struct {
                 .spirv,
                 .spirv32,
                 .spirv64,
-                .dxil,
                 .loongarch32,
                 .loongarch64,
                 .arc,
+                .propeller1,
+                .propeller2,
                 => .little,
 
                 .armeb,
@@ -1380,6 +1475,10 @@ pub const Cpu = struct {
                 .input, .output, .uniform => is_spirv,
                 // TODO this should also check how many flash banks the cpu has
                 .flash, .flash1, .flash2, .flash3, .flash4, .flash5 => arch == .avr,
+
+                // Propeller address spaces:
+                .cog, .hub => arch.isPropeller(),
+                .lut => (arch == .propeller2),
             };
         }
 
@@ -1400,6 +1499,7 @@ pub const Cpu = struct {
                 .nvptx, .nvptx64 => "nvptx",
                 .wasm32, .wasm64 => "wasm",
                 .spirv, .spirv32, .spirv64 => "spirv",
+                .propeller1, .propeller2 => "propeller",
                 else => @tagName(arch),
             };
         }
@@ -1414,6 +1514,7 @@ pub const Cpu = struct {
                 .bpfel, .bpfeb => &bpf.all_features,
                 .csky => &csky.all_features,
                 .hexagon => &hexagon.all_features,
+                .lanai => &lanai.all_features,
                 .loongarch32, .loongarch64 => &loongarch.all_features,
                 .m68k => &m68k.all_features,
                 .mips, .mipsel, .mips64, .mips64el => &mips.all_features,
@@ -1425,6 +1526,7 @@ pub const Cpu = struct {
                 .spirv, .spirv32, .spirv64 => &spirv.all_features,
                 .s390x => &s390x.all_features,
                 .x86, .x86_64 => &x86.all_features,
+                .xcore => &xcore.all_features,
                 .xtensa => &xtensa.all_features,
                 .nvptx, .nvptx64 => &nvptx.all_features,
                 .ve => &ve.all_features,
@@ -1444,6 +1546,7 @@ pub const Cpu = struct {
                 .bpfel, .bpfeb => comptime allCpusFromDecls(bpf.cpu),
                 .csky => comptime allCpusFromDecls(csky.cpu),
                 .hexagon => comptime allCpusFromDecls(hexagon.cpu),
+                .lanai => comptime allCpusFromDecls(lanai.cpu),
                 .loongarch32, .loongarch64 => comptime allCpusFromDecls(loongarch.cpu),
                 .m68k => comptime allCpusFromDecls(m68k.cpu),
                 .mips, .mipsel, .mips64, .mips64el => comptime allCpusFromDecls(mips.cpu),
@@ -1455,6 +1558,7 @@ pub const Cpu = struct {
                 .spirv, .spirv32, .spirv64 => comptime allCpusFromDecls(spirv.cpu),
                 .s390x => comptime allCpusFromDecls(s390x.cpu),
                 .x86, .x86_64 => comptime allCpusFromDecls(x86.cpu),
+                .xcore => comptime allCpusFromDecls(xcore.cpu),
                 .xtensa => comptime allCpusFromDecls(xtensa.cpu),
                 .nvptx, .nvptx64 => comptime allCpusFromDecls(nvptx.cpu),
                 .ve => comptime allCpusFromDecls(ve.cpu),
@@ -1524,11 +1628,14 @@ pub const Cpu = struct {
                 };
             };
             return switch (arch) {
+                .arc => &arc.cpu.generic,
                 .arm, .armeb, .thumb, .thumbeb => &arm.cpu.generic,
                 .aarch64, .aarch64_be => &aarch64.cpu.generic,
                 .avr => &avr.cpu.avr2,
                 .bpfel, .bpfeb => &bpf.cpu.generic,
+                .csky => &csky.cpu.generic,
                 .hexagon => &hexagon.cpu.generic,
+                .lanai => &lanai.cpu.generic,
                 .loongarch32 => &loongarch.cpu.generic_la32,
                 .loongarch64 => &loongarch.cpu.generic_la64,
                 .m68k => &m68k.cpu.generic,
@@ -1539,6 +1646,8 @@ pub const Cpu = struct {
                 .powerpcle => &powerpc.cpu.ppc,
                 .powerpc64 => &powerpc.cpu.ppc64,
                 .powerpc64le => &powerpc.cpu.ppc64le,
+                .propeller1 => &propeller.cpu.generic,
+                .propeller2 => &propeller.cpu.generic,
                 .amdgcn => &amdgpu.cpu.generic,
                 .riscv32 => &riscv.cpu.generic_rv32,
                 .riscv64 => &riscv.cpu.generic_rv64,
@@ -1551,8 +1660,12 @@ pub const Cpu = struct {
                 .nvptx, .nvptx64 => &nvptx.cpu.sm_20,
                 .ve => &ve.cpu.generic,
                 .wasm32, .wasm64 => &wasm.cpu.generic,
+                .xcore => &xcore.cpu.generic,
+                .xtensa => &xtensa.cpu.generic,
 
-                else => &S.generic_model,
+                .kalimba,
+                .spu_2,
+                => &S.generic_model,
             };
         }
 
@@ -1621,7 +1734,7 @@ pub inline fn isMusl(target: Target) bool {
 }
 
 pub inline fn isAndroid(target: Target) bool {
-    return target.abi == .android;
+    return target.abi.isAndroid();
 }
 
 pub inline fn isWasm(target: Target) bool {
@@ -1727,156 +1840,332 @@ pub const DynamicLinker = struct {
         return std.mem.eql(u8, lhs.buffer[0..lhs.len], rhs.buffer[0..rhs.len]);
     }
 
-    pub fn standard(cpu: Cpu, os_tag: Os.Tag, abi: Abi) DynamicLinker {
-        return if (abi == .android) initFmt("/system/bin/linker{s}", .{
-            if (ptrBitWidth_cpu_abi(cpu, abi) == 64) "64" else "",
-        }) catch unreachable else if (abi.isMusl()) return initFmt("/lib/ld-musl-{s}{s}.so.1", .{
-            @tagName(switch (cpu.arch) {
-                .thumb => .arm,
-                .thumbeb => .armeb,
-                else => cpu.arch,
-            }),
-            if (cpu.arch.isArmOrThumb() and abi.floatAbi() == .hard) "hf" else "",
-        }) catch unreachable else switch (os_tag) {
-            .freebsd => init("/libexec/ld-elf.so.1"),
-            .netbsd => init("/libexec/ld.elf_so"),
-            .openbsd => init("/usr/libexec/ld.so"),
-            .dragonfly => init("/libexec/ld-elf.so.2"),
-            .solaris, .illumos => init("/lib/64/ld.so.1"),
-            .linux => switch (cpu.arch) {
-                .x86,
-                .sparc,
-                => init("/lib/ld-linux.so.2"),
+    pub fn standard(cpu: Cpu, os: Os, abi: Abi) DynamicLinker {
+        return switch (os.tag) {
+            .fuchsia => init("ld.so.1"), // Fuchsia is unusual in that `DT_INTERP` is just a basename.
+
+            .haiku => init("/system/runtime_loader"),
+
+            .hurd => switch (cpu.arch) {
+                .aarch64,
+                .aarch64_be,
+                => |arch| initFmt("/lib/ld-{s}{s}.so.1", .{
+                    @tagName(arch),
+                    if (abi == .gnuilp32) "_ilp32" else "",
+                }),
 
-                .aarch64 => init("/lib/ld-linux-aarch64.so.1"),
-                .aarch64_be => init("/lib/ld-linux-aarch64_be.so.1"),
+                .x86 => init("/lib/ld.so.1"),
+                .x86_64 => initFmt("/lib/ld-{s}.so.1", .{if (abi == .gnux32) "x32" else "x86-64"}),
 
+                // These are unsupported by Hurd/glibc.
+                .amdgcn,
+                .arc,
                 .arm,
                 .armeb,
                 .thumb,
                 .thumbeb,
-                => initFmt("/lib/ld-linux{s}.so.3", .{switch (abi.floatAbi()) {
-                    .hard => "-armhf",
-                    else => "",
-                }}) catch unreachable,
-
-                .loongarch64 => init("/lib64/ld-linux-loongarch-lp64d.so.1"),
-
+                .avr,
+                .bpfel,
+                .bpfeb,
+                .csky,
+                .hexagon,
+                .kalimba,
+                .lanai,
+                .loongarch32,
+                .loongarch64,
+                .m68k,
                 .mips,
                 .mipsel,
                 .mips64,
                 .mips64el,
-                => initFmt("/lib{s}/{s}", .{
-                    switch (abi) {
-                        .gnuabin32, .gnux32 => "32",
-                        .gnuabi64 => "64",
-                        else => "",
-                    },
-                    if (mips.featureSetHas(cpu.features, .nan2008))
-                        "ld-linux-mipsn8.so.1"
-                    else
-                        "ld.so.1",
-                }) catch unreachable,
-
-                .powerpc, .powerpcle => init("/lib/ld.so.1"),
-                .powerpc64, .powerpc64le => init("/lib64/ld64.so.2"),
-                .s390x => init("/lib64/ld64.so.1"),
-                .sparc64 => init("/lib64/ld-linux.so.2"),
-                .x86_64 => init(switch (abi) {
-                    .gnux32 => "/libx32/ld-linux-x32.so.2",
-                    else => "/lib64/ld-linux-x86-64.so.2",
-                }),
-
-                .riscv32 => init("/lib/ld-linux-riscv32-ilp32d.so.1"),
-                .riscv64 => init("/lib/ld-linux-riscv64-lp64d.so.1"),
-
-                // Architectures in this list have been verified as not having a standard
-                // dynamic linker path.
-                .wasm32,
-                .wasm64,
-                .bpfel,
-                .bpfeb,
+                .msp430,
                 .nvptx,
                 .nvptx64,
-                .spu_2,
-                .avr,
+                .powerpc,
+                .powerpcle,
+                .powerpc64,
+                .powerpc64le,
+                .propeller1,
+                .propeller2,
+                .riscv32,
+                .riscv64,
+                .s390x,
+                .sparc,
+                .sparc64,
                 .spirv,
                 .spirv32,
                 .spirv64,
-                => none,
-
-                // TODO go over each item in this list and either move it to the above list, or
-                // implement the standard dynamic linker path code for it.
-                .arc,
-                .csky,
-                .hexagon,
-                .m68k,
-                .msp430,
-                .amdgcn,
-                .xcore,
-                .kalimba,
-                .lanai,
+                .spu_2,
                 .ve,
-                .dxil,
-                .loongarch32,
+                .wasm32,
+                .wasm64,
+                .xcore,
                 .xtensa,
                 => none,
             },
 
+            .linux => if (abi.isAndroid())
+                initFmt("/system/bin/linker{s}", .{if (ptrBitWidth_cpu_abi(cpu, abi) == 64) "64" else ""})
+            else if (abi.isMusl())
+                switch (cpu.arch) {
+                    .arm,
+                    .armeb,
+                    .thumb,
+                    .thumbeb,
+                    .aarch64,
+                    .aarch64_be,
+                    .loongarch64,
+                    .m68k,
+                    .powerpc,
+                    .powerpc64,
+                    .powerpc64le,
+                    .riscv32,
+                    .riscv64,
+                    .s390x,
+                    .x86,
+                    .x86_64,
+                    => |arch| initFmt("/lib/ld-musl-{s}{s}.so.1", .{
+                        switch (arch) {
+                            .thumb => "arm",
+                            .thumbeb => "armeb",
+                            .x86 => "i386",
+                            .x86_64 => if (abi == .muslx32) "x32" else "x86_64",
+                            else => @tagName(arch),
+                        },
+                        switch (arch) {
+                            .arm, .armeb, .thumb, .thumbeb => if (abi.floatAbi() == .hard) "hf" else "",
+                            .aarch64, .aarch64_be => if (abi == .gnuilp32) "_ilp32" else "",
+                            .riscv32, .riscv64 => if (std.Target.riscv.featureSetHas(cpu.features, .d))
+                                ""
+                            else if (std.Target.riscv.featureSetHas(cpu.features, .f))
+                                "-sp"
+                            else
+                                "-sf",
+                            else => if (abi.floatAbi() == .soft) "-sf" else "",
+                        },
+                    }),
+
+                    // The naming scheme for MIPS is a bit irregular.
+                    .mips,
+                    .mipsel,
+                    .mips64,
+                    .mips64el,
+                    => |arch| initFmt("/lib/ld-musl-mips{s}{s}{s}{s}.so.1", .{
+                        if (arch.isMIPS64()) "64" else "", // TODO: `n32` ABI support in LLVM 20.
+                        if (mips.featureSetHas(cpu.features, if (arch.isMIPS64()) .mips64r6 else .mips32r6)) "r6" else "",
+                        if (arch.endian() == .little) "el" else "",
+                        if (abi.floatAbi() == .soft) "-sf" else "",
+                    }),
+
+                    // These are unsupported by musl.
+                    .amdgcn,
+                    .arc,
+                    .avr,
+                    .csky,
+                    .bpfel,
+                    .bpfeb,
+                    .hexagon,
+                    .kalimba,
+                    .lanai,
+                    .loongarch32,
+                    .msp430,
+                    .nvptx,
+                    .nvptx64,
+                    .powerpcle,
+                    .propeller1,
+                    .propeller2,
+                    .sparc,
+                    .sparc64,
+                    .spirv,
+                    .spirv32,
+                    .spirv64,
+                    .spu_2,
+                    .ve,
+                    .wasm32,
+                    .wasm64,
+                    .xcore,
+                    .xtensa,
+                    => none,
+                }
+            else if (abi.isGnu())
+                switch (cpu.arch) {
+                    // TODO: `eb` architecture support.
+                    // TODO: `700` ABI support.
+                    .arc => init("/lib/ld-linux-arc.so.2"),
+
+                    // TODO: OABI support (`/lib/ld-linux.so.2`).
+                    .arm,
+                    .armeb,
+                    .thumb,
+                    .thumbeb,
+                    => initFmt("/lib/ld-linux{s}.so.3", .{if (abi.floatAbi() == .hard) "-armhf" else ""}),
+
+                    .aarch64,
+                    .aarch64_be,
+                    => |arch| initFmt("/lib/ld-linux-{s}{s}.so.1", .{
+                        @tagName(arch),
+                        if (abi == .gnuilp32) "_ilp32" else "",
+                    }),
+
+                    // TODO: `-be` architecture support.
+                    .csky => initFmt("/lib/ld-linux-cskyv2{s}.so.1", .{if (abi.floatAbi() == .hard) "-hf" else ""}),
+
+                    .loongarch64 => initFmt("/lib64/ld-linux-loongarch-{s}.so.1", .{switch (abi) {
+                        .gnuf32 => "lp64f",
+                        .gnusf => "lp64s",
+                        else => "lp64d",
+                    }}),
+
+                    .m68k => init("/lib/ld.so.1"),
+
+                    .mips,
+                    .mipsel,
+                    .mips64,
+                    .mips64el,
+                    => initFmt("/lib{s}/ld{s}.so.1", .{
+                        switch (abi) {
+                            .gnuabin32 => "32",
+                            .gnuabi64 => "64",
+                            else => "",
+                        },
+                        if (mips.featureSetHas(cpu.features, .nan2008)) "-linux-mipsn8" else "",
+                    }),
+
+                    .powerpc => init("/lib/ld.so.1"),
+                    // TODO: ELFv2 ABI opt-in support.
+                    .powerpc64 => init("/lib64/ld64.so.1"),
+                    .powerpc64le => init("/lib64/ld64.so.2"),
+
+                    .riscv32,
+                    .riscv64,
+                    => |arch| initFmt("/lib/ld-linux-{s}-{s}{s}.so.1", .{
+                        @tagName(arch),
+                        switch (arch) {
+                            .riscv32 => "ilp32",
+                            .riscv64 => "lp64",
+                            else => unreachable,
+                        },
+                        if (riscv.featureSetHas(cpu.features, .d))
+                            "d"
+                        else if (riscv.featureSetHas(cpu.features, .f))
+                            "f"
+                        else
+                            "",
+                    }),
+
+                    .s390x => init("/lib/ld64.so.1"),
+
+                    .sparc => init("/lib/ld-linux.so.2"),
+                    .sparc64 => init("/lib64/ld-linux.so.2"),
+
+                    .x86 => init("/lib/ld-linux.so.2"),
+                    .x86_64 => init(if (abi == .gnux32) "/libx32/ld-linux-x32.so.2" else "/lib64/ld-linux-x86-64.so.2"),
+
+                    .xtensa => init("/lib/ld.so.1"),
+
+                    // These are unsupported by glibc.
+                    .amdgcn,
+                    .avr,
+                    .bpfeb,
+                    .bpfel,
+                    .hexagon,
+                    .kalimba,
+                    .lanai,
+                    .loongarch32,
+                    .msp430,
+                    .nvptx,
+                    .nvptx64,
+                    .powerpcle,
+                    .propeller1,
+                    .propeller2,
+                    .spirv,
+                    .spirv32,
+                    .spirv64,
+                    .spu_2,
+                    .ve,
+                    .wasm32,
+                    .wasm64,
+                    .xcore,
+                    => none,
+                }
+            else
+                none, // Not a known Linux libc.
+
+            .serenity => init("/usr/lib/Loader.so"),
+
+            .dragonfly => initFmt("{s}/libexec/ld-elf.so.2", .{
+                if (os.version_range.semver.isAtLeast(.{ .major = 3, .minor = 8, .patch = 0 }) orelse false)
+                    ""
+                else
+                    "/usr",
+            }),
+
+            .freebsd => initFmt("{s}/libexec/ld-elf.so.1", .{
+                if (os.version_range.semver.isAtLeast(.{ .major = 6, .minor = 0, .patch = 0 }) orelse false)
+                    ""
+                else
+                    "/usr",
+            }),
+
+            .netbsd => init("/libexec/ld.elf_so"),
+
+            .openbsd => init("/usr/libexec/ld.so"),
+
             .bridgeos,
             .driverkit,
             .ios,
-            .tvos,
-            .watchos,
             .macos,
+            .tvos,
             .visionos,
+            .watchos,
             => init("/usr/lib/dyld"),
 
-            .serenity => init("/usr/lib/Loader.so"),
+            .illumos,
+            .solaris,
+            => initFmt("/lib/{s}ld.so.1", .{if (ptrBitWidth_cpu_abi(cpu, abi) == 64) "64/" else ""}),
 
             // Operating systems in this list have been verified as not having a standard
             // dynamic linker path.
             .freestanding,
+            .other,
+
+            .contiki,
+            .elfiamcu,
+            .hermit,
+
+            .aix,
+            .plan9,
+            .rtems,
+            .zos,
+
             .uefi,
             .windows,
+
             .emscripten,
             .wasi,
+
+            .amdhsa,
+            .amdpal,
+            .cuda,
+            .mesa3d,
+            .nvcl,
             .opencl,
             .opengl,
             .vulkan,
-            .other,
-            .plan9,
             => none,
 
-            // TODO revisit when multi-arch for Haiku is available
-            .haiku => init("/system/runtime_loader"),
-
             // TODO go over each item in this list and either move it to the above list, or
             // implement the standard dynamic linker path code for it.
-            .fuchsia,
             .ps3,
-            .zos,
-            .rtems,
-            .aix,
-            .cuda,
-            .nvcl,
-            .amdhsa,
             .ps4,
             .ps5,
-            .elfiamcu,
-            .mesa3d,
-            .contiki,
-            .amdpal,
-            .hermit,
-            .hurd,
-            .shadermodel,
             => none,
-        };
+        } catch unreachable;
     }
 };
 
 pub fn standardDynamicLinkerPath(target: Target) DynamicLinker {
-    return DynamicLinker.standard(target.cpu, target.os.tag, target.abi);
+    return DynamicLinker.standard(target.cpu, target.os, target.abi);
 }
 
 pub fn ptrBitWidth_cpu_abi(cpu: Cpu, abi: Abi) u16 {
@@ -1913,8 +2202,9 @@ pub fn ptrBitWidth_cpu_abi(cpu: Cpu, abi: Abi) u16 {
         .sparc,
         .spirv32,
         .loongarch32,
-        .dxil,
         .xtensa,
+        .propeller1,
+        .propeller2,
         => 32,
 
         .aarch64,
@@ -2363,7 +2653,6 @@ pub fn cTypeBitSize(target: Target, c_type: CType) u16 {
         .hermit,
         .hurd,
         .opengl,
-        .shadermodel,
         => @panic("TODO specify the C integer and float type sizes for this OS"),
     }
 }
@@ -2397,6 +2686,7 @@ pub fn cTypeAlignment(target: Target, c_type: CType) u16 {
                     .eabi,
                     .eabihf,
                     .android,
+                    .androideabi,
                     .musleabi,
                     .musleabihf,
                     => 8,
@@ -2408,18 +2698,18 @@ pub fn cTypeAlignment(target: Target, c_type: CType) u16 {
             },
 
             .msp430,
-            .avr,
             => 2,
 
             .arc,
             .csky,
             .x86,
             .xcore,
-            .dxil,
             .loongarch32,
             .kalimba,
             .spu_2,
             .xtensa,
+            .propeller1,
+            .propeller2,
             => 4,
 
             .amdgcn,
@@ -2456,6 +2746,9 @@ pub fn cTypeAlignment(target: Target, c_type: CType) u16 {
             .wasm32,
             .wasm64,
             => 16,
+
+            .avr,
+            => unreachable, // Handled above.
         }),
     );
 }
@@ -2470,6 +2763,7 @@ pub fn cTypePreferredAlignment(target: Target, c_type: CType) u16 {
                 .eabi,
                 .eabihf,
                 .android,
+                .androideabi,
                 .musleabi,
                 .musleabihf,
                 => {},
@@ -2489,12 +2783,7 @@ pub fn cTypePreferredAlignment(target: Target, c_type: CType) u16 {
             .longdouble => return 4,
             else => {},
         },
-        .avr => switch (c_type) {
-            .char, .int, .uint, .long, .ulong, .float, .longdouble => return 1,
-            .short, .ushort => return 2,
-            .double => return 4,
-            .longlong, .ulonglong => return 8,
-        },
+        .avr => return 1,
         .x86 => switch (target.os.tag) {
             .windows, .uefi => switch (c_type) {
                 .longdouble => switch (target.abi) {
@@ -2519,17 +2808,17 @@ pub fn cTypePreferredAlignment(target: Target, c_type: CType) u16 {
 
             .csky,
             .xcore,
-            .dxil,
             .loongarch32,
             .kalimba,
             .spu_2,
             .xtensa,
+            .propeller1,
+            .propeller2,
             => 4,
 
             .arc,
             .arm,
             .armeb,
-            .avr,
             .thumb,
             .thumbeb,
             .amdgcn,
@@ -2567,6 +2856,9 @@ pub fn cTypePreferredAlignment(target: Target, c_type: CType) u16 {
             .wasm32,
             .wasm64,
             => 16,
+
+            .avr,
+            => unreachable, // Handled above.
         }),
     );
 }
diff --git a/zig/lib/std/Target/Query.zig b/zig/lib/std/Target/Query.zig
index f18d211853..e22fbcbf53 100644
--- a/zig/lib/std/Target/Query.zig
+++ b/zig/lib/std/Target/Query.zig
@@ -374,7 +374,7 @@ pub fn canDetectLibC(self: Query) bool {
     if (self.isNativeOs()) return true;
     if (self.os_tag) |os| {
         if (builtin.os.tag == .macos and os.isDarwin()) return true;
-        if (os == .linux and self.abi == .android) return true;
+        if (os == .linux and self.abi.isAndroid()) return true;
     }
     return false;
 }
diff --git a/zig/lib/std/Target/aarch64.zig b/zig/lib/std/Target/aarch64.zig
index ac7dba124e..8b501e2dc2 100644
--- a/zig/lib/std/Target/aarch64.zig
+++ b/zig/lib/std/Target/aarch64.zig
@@ -1373,6 +1373,7 @@ pub const all_features = blk: {
         .llvm_name = "v8.3a",
         .description = "Support ARM v8.3a architecture",
         .dependencies = featureSet(&[_]Feature{
+            .ccidx,
             .complxnum,
             .jsconv,
             .pauth,
@@ -1409,6 +1410,7 @@ pub const all_features = blk: {
             .predres,
             .sb,
             .specrestrict,
+            .ssbs,
             .v8_4a,
         }),
     };
@@ -1470,18 +1472,26 @@ pub const all_features = blk: {
         .llvm_name = "v8r",
         .description = "Support ARM v8r architecture",
         .dependencies = featureSet(&[_]Feature{
+            .ccidx,
             .ccpp,
+            .complxnum,
             .contextidr_el2,
             .crc,
             .dit,
+            .dotprod,
             .flagm,
+            .fp16fml,
+            .jsconv,
             .lse,
             .pan_rwv,
             .pauth,
             .ras,
             .rcpc_immo,
+            .rdm,
+            .sb,
             .sel2,
             .specrestrict,
+            .ssbs,
             .tlb_rmi,
             .tracev8_4,
             .uaops,
@@ -1491,6 +1501,7 @@ pub const all_features = blk: {
         .llvm_name = "v9.1a",
         .description = "Support ARM v9.1a architecture",
         .dependencies = featureSet(&[_]Feature{
+            .rme,
             .v8_6a,
             .v9a,
         }),
@@ -1499,6 +1510,7 @@ pub const all_features = blk: {
         .llvm_name = "v9.2a",
         .description = "Support ARM v9.2a architecture",
         .dependencies = featureSet(&[_]Feature{
+            .mec,
             .v8_7a,
             .v9_1a,
         }),
@@ -1524,6 +1536,8 @@ pub const all_features = blk: {
         .description = "Support ARM v9.5a architecture",
         .dependencies = featureSet(&[_]Feature{
             .cpa,
+            .faminmax,
+            .lut,
             .v9_4a,
         }),
     };
@@ -1531,6 +1545,7 @@ pub const all_features = blk: {
         .llvm_name = "v9a",
         .description = "Support ARM v9a architecture",
         .dependencies = featureSet(&[_]Feature{
+            .sve2,
             .v8_5a,
         }),
     };
@@ -1607,7 +1622,6 @@ pub const cpu = struct {
             .aggressive_fma,
             .alu_lsl_fast,
             .arith_bcc_fusion,
-            .ccidx,
             .cmp_bcc_fusion,
             .fullfp16,
             .fuse_address,
@@ -1618,7 +1632,6 @@ pub const cpu = struct {
             .perfmon,
             .rand,
             .sha3,
-            .ssbs,
             .store_pair_suppress,
             .stp_aligned_only,
             .use_postra_scheduler,
@@ -1633,7 +1646,6 @@ pub const cpu = struct {
             .aggressive_fma,
             .alu_lsl_fast,
             .arith_bcc_fusion,
-            .ccidx,
             .cmp_bcc_fusion,
             .fullfp16,
             .fuse_address,
@@ -1647,7 +1659,6 @@ pub const cpu = struct {
             .rand,
             .sha3,
             .sm4,
-            .ssbs,
             .store_pair_suppress,
             .stp_aligned_only,
             .use_postra_scheduler,
@@ -1662,7 +1673,6 @@ pub const cpu = struct {
             .aggressive_fma,
             .alu_lsl_fast,
             .arith_bcc_fusion,
-            .ccidx,
             .cmp_bcc_fusion,
             .cssc,
             .enable_select_opt,
@@ -1678,7 +1688,6 @@ pub const cpu = struct {
             .rand,
             .sha3,
             .sm4,
-            .ssbs,
             .store_pair_suppress,
             .stp_aligned_only,
             .use_postra_scheduler,
@@ -1819,7 +1828,6 @@ pub const cpu = struct {
             .fuse_literals,
             .perfmon,
             .sha3,
-            .ssbs,
             .store_pair_suppress,
             .v8_6a,
             .zcm,
@@ -1846,7 +1854,6 @@ pub const cpu = struct {
             .hcx,
             .perfmon,
             .sha3,
-            .ssbs,
             .store_pair_suppress,
             .v8_6a,
             .zcm,
@@ -1873,7 +1880,6 @@ pub const cpu = struct {
             .hcx,
             .perfmon,
             .sha3,
-            .ssbs,
             .store_pair_suppress,
             .v8_6a,
             .zcm,
@@ -1990,7 +1996,6 @@ pub const cpu = struct {
             .fuse_literals,
             .perfmon,
             .sha3,
-            .ssbs,
             .store_pair_suppress,
             .v8_6a,
             .zcm,
@@ -2017,7 +2022,6 @@ pub const cpu = struct {
             .hcx,
             .perfmon,
             .sha3,
-            .ssbs,
             .store_pair_suppress,
             .v8_6a,
             .zcm,
@@ -2106,7 +2110,6 @@ pub const cpu = struct {
         .features = featureSet(&[_]Feature{
             .alu_lsl_fast,
             .bf16,
-            .ccidx,
             .enable_select_opt,
             .ete,
             .fp16fml,
@@ -2116,7 +2119,6 @@ pub const cpu = struct {
             .mte,
             .perfmon,
             .predictable_select_expensive,
-            .ssbs,
             .sve2_bitperm,
             .use_postra_scheduler,
             .v9a,
@@ -2149,7 +2151,6 @@ pub const cpu = struct {
         .llvm_name = "cortex-a510",
         .features = featureSet(&[_]Feature{
             .bf16,
-            .ccidx,
             .ete,
             .fp16fml,
             .fuse_adrp_add,
@@ -2157,7 +2158,6 @@ pub const cpu = struct {
             .i8mm,
             .mte,
             .perfmon,
-            .ssbs,
             .sve2_bitperm,
             .use_postra_scheduler,
             .v9a,
@@ -2167,14 +2167,12 @@ pub const cpu = struct {
         .name = "cortex_a520",
         .llvm_name = "cortex-a520",
         .features = featureSet(&[_]Feature{
-            .ccidx,
             .ete,
             .fp16fml,
             .fuse_adrp_add,
             .fuse_aes,
             .mte,
             .perfmon,
-            .ssbs,
             .sve2_bitperm,
             .use_postra_scheduler,
             .v9_2a,
@@ -2184,14 +2182,12 @@ pub const cpu = struct {
         .name = "cortex_a520ae",
         .llvm_name = "cortex-a520ae",
         .features = featureSet(&[_]Feature{
-            .ccidx,
             .ete,
             .fp16fml,
             .fuse_adrp_add,
             .fuse_aes,
             .mte,
             .perfmon,
-            .ssbs,
             .sve2_bitperm,
             .use_postra_scheduler,
             .v9_2a,
@@ -2294,7 +2290,6 @@ pub const cpu = struct {
         .features = featureSet(&[_]Feature{
             .alu_lsl_fast,
             .bf16,
-            .ccidx,
             .cmp_bcc_fusion,
             .enable_select_opt,
             .ete,
@@ -2305,7 +2300,6 @@ pub const cpu = struct {
             .mte,
             .perfmon,
             .predictable_select_expensive,
-            .ssbs,
             .sve2_bitperm,
             .use_postra_scheduler,
             .v9a,
@@ -2317,7 +2311,6 @@ pub const cpu = struct {
         .features = featureSet(&[_]Feature{
             .alu_lsl_fast,
             .bf16,
-            .ccidx,
             .cmp_bcc_fusion,
             .enable_select_opt,
             .ete,
@@ -2329,7 +2322,6 @@ pub const cpu = struct {
             .perfmon,
             .predictable_select_expensive,
             .spe,
-            .ssbs,
             .sve2_bitperm,
             .use_postra_scheduler,
             .v9a,
@@ -2357,7 +2349,6 @@ pub const cpu = struct {
         .llvm_name = "cortex-a720",
         .features = featureSet(&[_]Feature{
             .alu_lsl_fast,
-            .ccidx,
             .cmp_bcc_fusion,
             .enable_select_opt,
             .ete,
@@ -2369,7 +2360,6 @@ pub const cpu = struct {
             .predictable_select_expensive,
             .spe,
             .spe_eef,
-            .ssbs,
             .sve2_bitperm,
             .use_postra_scheduler,
             .v9_2a,
@@ -2380,7 +2370,6 @@ pub const cpu = struct {
         .llvm_name = "cortex-a720ae",
         .features = featureSet(&[_]Feature{
             .alu_lsl_fast,
-            .ccidx,
             .cmp_bcc_fusion,
             .enable_select_opt,
             .ete,
@@ -2392,7 +2381,6 @@ pub const cpu = struct {
             .predictable_select_expensive,
             .spe,
             .spe_eef,
-            .ssbs,
             .sve2_bitperm,
             .use_postra_scheduler,
             .v9_2a,
@@ -2403,7 +2391,6 @@ pub const cpu = struct {
         .llvm_name = "cortex-a725",
         .features = featureSet(&[_]Feature{
             .alu_lsl_fast,
-            .ccidx,
             .cmp_bcc_fusion,
             .enable_select_opt,
             .ete,
@@ -2415,7 +2402,6 @@ pub const cpu = struct {
             .predictable_select_expensive,
             .spe,
             .spe_eef,
-            .ssbs,
             .sve2_bitperm,
             .use_postra_scheduler,
             .v9_2a,
@@ -2592,15 +2578,8 @@ pub const cpu = struct {
         .llvm_name = "cortex-r82",
         .features = featureSet(&[_]Feature{
             .ccdp,
-            .complxnum,
-            .dotprod,
-            .fp16fml,
-            .jsconv,
             .perfmon,
             .predres,
-            .rdm,
-            .sb,
-            .ssbs,
             .use_postra_scheduler,
             .v8r,
         }),
@@ -2610,15 +2589,8 @@ pub const cpu = struct {
         .llvm_name = "cortex-r82ae",
         .features = featureSet(&[_]Feature{
             .ccdp,
-            .complxnum,
-            .dotprod,
-            .fp16fml,
-            .jsconv,
             .perfmon,
             .predres,
-            .rdm,
-            .sb,
-            .ssbs,
             .use_postra_scheduler,
             .v8r,
         }),
@@ -2678,7 +2650,6 @@ pub const cpu = struct {
         .features = featureSet(&[_]Feature{
             .alu_lsl_fast,
             .bf16,
-            .ccidx,
             .cmp_bcc_fusion,
             .enable_select_opt,
             .ete,
@@ -2689,7 +2660,6 @@ pub const cpu = struct {
             .mte,
             .perfmon,
             .predictable_select_expensive,
-            .ssbs,
             .sve2_bitperm,
             .use_postra_scheduler,
             .v9a,
@@ -2701,7 +2671,6 @@ pub const cpu = struct {
         .features = featureSet(&[_]Feature{
             .alu_lsl_fast,
             .bf16,
-            .ccidx,
             .enable_select_opt,
             .ete,
             .fp16fml,
@@ -2712,7 +2681,6 @@ pub const cpu = struct {
             .perfmon,
             .predictable_select_expensive,
             .spe,
-            .ssbs,
             .sve2_bitperm,
             .use_postra_scheduler,
             .v9a,
@@ -2723,7 +2691,6 @@ pub const cpu = struct {
         .llvm_name = "cortex-x4",
         .features = featureSet(&[_]Feature{
             .alu_lsl_fast,
-            .ccidx,
             .enable_select_opt,
             .ete,
             .fp16fml,
@@ -2734,7 +2701,6 @@ pub const cpu = struct {
             .predictable_select_expensive,
             .spe,
             .spe_eef,
-            .ssbs,
             .sve2_bitperm,
             .use_postra_scheduler,
             .v9_2a,
@@ -2745,7 +2711,6 @@ pub const cpu = struct {
         .llvm_name = "cortex-x925",
         .features = featureSet(&[_]Feature{
             .alu_lsl_fast,
-            .ccidx,
             .enable_select_opt,
             .ete,
             .fp16fml,
@@ -2756,7 +2721,6 @@ pub const cpu = struct {
             .predictable_select_expensive,
             .spe,
             .spe_eef,
-            .ssbs,
             .sve2_bitperm,
             .use_postra_scheduler,
             .v9_2a,
@@ -2935,7 +2899,6 @@ pub const cpu = struct {
         .features = featureSet(&[_]Feature{
             .alu_lsl_fast,
             .bf16,
-            .ccidx,
             .cmp_bcc_fusion,
             .enable_select_opt,
             .ete,
@@ -2948,7 +2911,6 @@ pub const cpu = struct {
             .predictable_select_expensive,
             .rand,
             .spe,
-            .ssbs,
             .sve2_bitperm,
             .use_fixed_over_scalable_if_equal_cost,
             .use_postra_scheduler,
@@ -2979,7 +2941,6 @@ pub const cpu = struct {
             .alu_lsl_fast,
             .bf16,
             .ccdp,
-            .ccidx,
             .enable_select_opt,
             .fp16fml,
             .fuse_adrp_add,
@@ -3042,7 +3003,6 @@ pub const cpu = struct {
         .features = featureSet(&[_]Feature{
             .alu_lsl_fast,
             .bf16,
-            .ccidx,
             .enable_select_opt,
             .ete,
             .fp16fml,
@@ -3052,7 +3012,6 @@ pub const cpu = struct {
             .mte,
             .perfmon,
             .predictable_select_expensive,
-            .ssbs,
             .sve2_bitperm,
             .use_postra_scheduler,
             .v9a,
@@ -3063,7 +3022,6 @@ pub const cpu = struct {
         .llvm_name = "neoverse-n3",
         .features = featureSet(&[_]Feature{
             .alu_lsl_fast,
-            .ccidx,
             .enable_select_opt,
             .ete,
             .fp16fml,
@@ -3075,7 +3033,6 @@ pub const cpu = struct {
             .rand,
             .spe,
             .spe_eef,
-            .ssbs,
             .sve2_bitperm,
             .use_postra_scheduler,
             .v9_2a,
@@ -3090,7 +3047,6 @@ pub const cpu = struct {
             .alu_lsl_fast,
             .bf16,
             .ccdp,
-            .ccidx,
             .enable_select_opt,
             .fp16fml,
             .fuse_adrp_add,
@@ -3115,7 +3071,6 @@ pub const cpu = struct {
         .features = featureSet(&[_]Feature{
             .alu_lsl_fast,
             .bf16,
-            .ccidx,
             .cmp_bcc_fusion,
             .enable_select_opt,
             .ete,
@@ -3128,7 +3083,6 @@ pub const cpu = struct {
             .predictable_select_expensive,
             .rand,
             .spe,
-            .ssbs,
             .sve2_bitperm,
             .use_fixed_over_scalable_if_equal_cost,
             .use_postra_scheduler,
@@ -3141,7 +3095,6 @@ pub const cpu = struct {
         .features = featureSet(&[_]Feature{
             .alu_lsl_fast,
             .brbe,
-            .ccidx,
             .enable_select_opt,
             .ete,
             .fp16fml,
@@ -3152,10 +3105,8 @@ pub const cpu = struct {
             .perfmon,
             .predictable_select_expensive,
             .rand,
-            .rme,
             .spe,
             .spe_eef,
-            .ssbs,
             .sve2_bitperm,
             .use_postra_scheduler,
             .v9_2a,
@@ -3167,7 +3118,6 @@ pub const cpu = struct {
         .features = featureSet(&[_]Feature{
             .alu_lsl_fast,
             .brbe,
-            .ccidx,
             .enable_select_opt,
             .ete,
             .fp16fml,
@@ -3178,10 +3128,8 @@ pub const cpu = struct {
             .perfmon,
             .predictable_select_expensive,
             .rand,
-            .rme,
             .spe,
             .spe_eef,
-            .ssbs,
             .sve2_bitperm,
             .use_postra_scheduler,
             .v9_2a,
@@ -3192,7 +3140,6 @@ pub const cpu = struct {
         .llvm_name = "oryon-1",
         .features = featureSet(&[_]Feature{
             .aes,
-            .ccidx,
             .enable_select_opt,
             .fp16fml,
             .fuse_address,
@@ -3204,7 +3151,6 @@ pub const cpu = struct {
             .sha3,
             .sm4,
             .spe,
-            .ssbs,
             .use_postra_scheduler,
             .v8_6a,
         }),
@@ -3215,7 +3161,6 @@ pub const cpu = struct {
         .features = featureSet(&[_]Feature{
             .aes,
             .alu_lsl_fast,
-            .ccidx,
             .perfmon,
             .predictable_select_expensive,
             .sha2,
@@ -3262,7 +3207,6 @@ pub const cpu = struct {
             .aggressive_fma,
             .arith_bcc_fusion,
             .balance_fp_ops,
-            .ccidx,
             .perfmon,
             .predictable_select_expensive,
             .sha2,
diff --git a/zig/lib/std/Target/arm.zig b/zig/lib/std/Target/arm.zig
index aa0e1e4603..9e4e72a05a 100644
--- a/zig/lib/std/Target/arm.zig
+++ b/zig/lib/std/Target/arm.zig
@@ -2254,7 +2254,6 @@ pub const cpu = struct {
         .llvm_name = "cortex-m85",
         .features = featureSet(&[_]Feature{
             .dsp,
-            .trustzone,
             .use_misched,
             .v8_1m_main,
         }),
diff --git a/zig/lib/std/Target/lanai.zig b/zig/lib/std/Target/lanai.zig
new file mode 100644
index 0000000000..041934b6d4
--- /dev/null
+++ b/zig/lib/std/Target/lanai.zig
@@ -0,0 +1,37 @@
+//! This file is auto-generated by tools/update_cpu_features.zig.
+
+const std = @import("../std.zig");
+const CpuFeature = std.Target.Cpu.Feature;
+const CpuModel = std.Target.Cpu.Model;
+
+pub const Feature = enum {};
+
+pub const featureSet = CpuFeature.FeatureSetFns(Feature).featureSet;
+pub const featureSetHas = CpuFeature.FeatureSetFns(Feature).featureSetHas;
+pub const featureSetHasAny = CpuFeature.FeatureSetFns(Feature).featureSetHasAny;
+pub const featureSetHasAll = CpuFeature.FeatureSetFns(Feature).featureSetHasAll;
+
+pub const all_features = blk: {
+    const len = @typeInfo(Feature).@"enum".fields.len;
+    std.debug.assert(len <= CpuFeature.Set.needed_bit_count);
+    var result: [len]CpuFeature = undefined;
+    const ti = @typeInfo(Feature);
+    for (&result, 0..) |*elem, i| {
+        elem.index = i;
+        elem.name = ti.@"enum".fields[i].name;
+    }
+    break :blk result;
+};
+
+pub const cpu = struct {
+    pub const generic = CpuModel{
+        .name = "generic",
+        .llvm_name = "generic",
+        .features = featureSet(&[_]Feature{}),
+    };
+    pub const v11 = CpuModel{
+        .name = "v11",
+        .llvm_name = "v11",
+        .features = featureSet(&[_]Feature{}),
+    };
+};
diff --git a/zig/lib/std/Target/propeller.zig b/zig/lib/std/Target/propeller.zig
new file mode 100644
index 0000000000..929e3ff74c
--- /dev/null
+++ b/zig/lib/std/Target/propeller.zig
@@ -0,0 +1,20 @@
+const std = @import("../std.zig");
+const CpuFeature = std.Target.Cpu.Feature;
+const CpuModel = std.Target.Cpu.Model;
+
+pub const Feature = enum {};
+
+pub const featureSet = CpuFeature.FeatureSetFns(Feature).featureSet;
+pub const featureSetHas = CpuFeature.FeatureSetFns(Feature).featureSetHas;
+pub const featureSetHasAny = CpuFeature.FeatureSetFns(Feature).featureSetHasAny;
+pub const featureSetHasAll = CpuFeature.FeatureSetFns(Feature).featureSetHasAll;
+
+pub const all_features: [0]CpuFeature = .{};
+
+pub const cpu = struct {
+    pub const generic = CpuModel{
+        .name = "generic",
+        .llvm_name = null,
+        .features = featureSet(&[_]Feature{}),
+    };
+};
diff --git a/zig/lib/std/Target/xcore.zig b/zig/lib/std/Target/xcore.zig
new file mode 100644
index 0000000000..4069620849
--- /dev/null
+++ b/zig/lib/std/Target/xcore.zig
@@ -0,0 +1,37 @@
+//! This file is auto-generated by tools/update_cpu_features.zig.
+
+const std = @import("../std.zig");
+const CpuFeature = std.Target.Cpu.Feature;
+const CpuModel = std.Target.Cpu.Model;
+
+pub const Feature = enum {};
+
+pub const featureSet = CpuFeature.FeatureSetFns(Feature).featureSet;
+pub const featureSetHas = CpuFeature.FeatureSetFns(Feature).featureSetHas;
+pub const featureSetHasAny = CpuFeature.FeatureSetFns(Feature).featureSetHasAny;
+pub const featureSetHasAll = CpuFeature.FeatureSetFns(Feature).featureSetHasAll;
+
+pub const all_features = blk: {
+    const len = @typeInfo(Feature).@"enum".fields.len;
+    std.debug.assert(len <= CpuFeature.Set.needed_bit_count);
+    var result: [len]CpuFeature = undefined;
+    const ti = @typeInfo(Feature);
+    for (&result, 0..) |*elem, i| {
+        elem.index = i;
+        elem.name = ti.@"enum".fields[i].name;
+    }
+    break :blk result;
+};
+
+pub const cpu = struct {
+    pub const generic = CpuModel{
+        .name = "generic",
+        .llvm_name = "generic",
+        .features = featureSet(&[_]Feature{}),
+    };
+    pub const xs1b_generic = CpuModel{
+        .name = "xs1b_generic",
+        .llvm_name = "xs1b-generic",
+        .features = featureSet(&[_]Feature{}),
+    };
+};
diff --git a/zig/lib/std/Thread.zig b/zig/lib/std/Thread.zig
index 446b629cc6..a5c03138f7 100644
--- a/zig/lib/std/Thread.zig
+++ b/zig/lib/std/Thread.zig
@@ -22,6 +22,83 @@ pub const WaitGroup = @import("Thread/WaitGroup.zig");
 
 pub const use_pthreads = native_os != .windows and native_os != .wasi and builtin.link_libc;
 
+/// Spurious wakeups are possible and no precision of timing is guaranteed.
+pub fn sleep(nanoseconds: u64) void {
+    if (builtin.os.tag == .windows) {
+        const big_ms_from_ns = nanoseconds / std.time.ns_per_ms;
+        const ms = math.cast(windows.DWORD, big_ms_from_ns) orelse math.maxInt(windows.DWORD);
+        windows.kernel32.Sleep(ms);
+        return;
+    }
+
+    if (builtin.os.tag == .wasi) {
+        const w = std.os.wasi;
+        const userdata: w.userdata_t = 0x0123_45678;
+        const clock: w.subscription_clock_t = .{
+            .id = .MONOTONIC,
+            .timeout = nanoseconds,
+            .precision = 0,
+            .flags = 0,
+        };
+        const in: w.subscription_t = .{
+            .userdata = userdata,
+            .u = .{
+                .tag = .CLOCK,
+                .u = .{ .clock = clock },
+            },
+        };
+
+        var event: w.event_t = undefined;
+        var nevents: usize = undefined;
+        _ = w.poll_oneoff(&in, &event, 1, &nevents);
+        return;
+    }
+
+    if (builtin.os.tag == .uefi) {
+        const boot_services = std.os.uefi.system_table.boot_services.?;
+        const us_from_ns = nanoseconds / std.time.ns_per_us;
+        const us = math.cast(usize, us_from_ns) orelse math.maxInt(usize);
+        _ = boot_services.stall(us);
+        return;
+    }
+
+    const s = nanoseconds / std.time.ns_per_s;
+    const ns = nanoseconds % std.time.ns_per_s;
+
+    // Newer kernel ports don't have old `nanosleep()` and `clock_nanosleep()` has been around
+    // since Linux 2.6 and glibc 2.1 anyway.
+    if (builtin.os.tag == .linux) {
+        const linux = std.os.linux;
+
+        var req: linux.timespec = .{
+            .sec = std.math.cast(linux.time_t, s) orelse std.math.maxInt(linux.time_t),
+            .nsec = std.math.cast(linux.time_t, ns) orelse std.math.maxInt(linux.time_t),
+        };
+        var rem: linux.timespec = undefined;
+
+        while (true) {
+            switch (linux.E.init(linux.clock_nanosleep(.MONOTONIC, .{ .ABSTIME = false }, &req, &rem))) {
+                .SUCCESS => return,
+                .INTR => {
+                    req = rem;
+                    continue;
+                },
+                .FAULT,
+                .INVAL,
+                .OPNOTSUPP,
+                => unreachable,
+                else => return,
+            }
+        }
+    }
+
+    posix.nanosleep(s, ns);
+}
+
+test sleep {
+    sleep(1);
+}
+
 const Thread = @This();
 const Impl = if (native_os == .windows)
     WindowsThreadImpl
diff --git a/zig/lib/std/Thread/Futex.zig b/zig/lib/std/Thread/Futex.zig
index fe22fa2011..da3fb916c6 100644
--- a/zig/lib/std/Thread/Futex.zig
+++ b/zig/lib/std/Thread/Futex.zig
@@ -794,9 +794,8 @@ const PosixImpl = struct {
         // - T1: bumps pending waiters (was reordered after the ptr == expect check)
         // - T1: goes to sleep and misses both the ptr change and T2's wake up
         //
-        // seq_cst as Acquire barrier to ensure the announcement happens before the ptr check below.
-        // seq_cst as shared modification order to form a happens-before edge with the fence(.seq_cst)+load() in wake().
-        var pending = bucket.pending.fetchAdd(1, .seq_cst);
+        // acquire barrier to ensure the announcement happens before the ptr check below.
+        var pending = bucket.pending.fetchAdd(1, .acquire);
         assert(pending < std.math.maxInt(usize));
 
         // If the wait gets cancelled, remove the pending count we previously added.
@@ -858,15 +857,8 @@ const PosixImpl = struct {
         //
         // What we really want here is a Release load, but that doesn't exist under the C11 memory model.
         // We could instead do `bucket.pending.fetchAdd(0, Release) == 0` which achieves effectively the same thing,
-        // but the RMW operation unconditionally marks the cache-line as modified for others causing unnecessary fetching/contention.
-        //
-        // Instead we opt to do a full-fence + load instead which avoids taking ownership of the cache-line.
-        // fence(seq_cst) effectively converts the ptr update to seq_cst and the pending load to seq_cst: creating a Store-Load barrier.
-        //
-        // The pending count increment in wait() must also now use seq_cst for the update + this pending load
-        // to be in the same modification order as our load isn't using release/acquire to guarantee it.
-        bucket.pending.fence(.seq_cst);
-        if (bucket.pending.load(.monotonic) == 0) {
+        // LLVM lowers the fetchAdd(0, .release) into an mfence+load which avoids gaining ownership of the cache-line.
+        if (bucket.pending.fetchAdd(0, .release) == 0) {
             return;
         }
 
@@ -979,15 +971,14 @@ test "broadcasting" {
         fn wait(self: *@This()) !void {
             // Decrement the counter.
             // Release ensures stuff before this barrier.wait() happens before the last one.
-            const count = self.count.fetchSub(1, .release);
+            // Acquire for the last counter ensures stuff before previous barrier.wait()s happened before it.
+            const count = self.count.fetchSub(1, .acq_rel);
             try testing.expect(count <= num_threads);
             try testing.expect(count > 0);
 
             // First counter to reach zero wakes all other threads.
-            // Acquire for the last counter ensures stuff before previous barrier.wait()s happened before it.
             // Release on futex update ensures stuff before all barrier.wait()'s happens before they all return.
             if (count - 1 == 0) {
-                _ = self.count.load(.acquire); // TODO: could be fence(acquire) if not for TSAN
                 self.futex.store(1, .release);
                 Futex.wake(&self.futex, num_threads - 1);
                 return;
diff --git a/zig/lib/std/Thread/ResetEvent.zig b/zig/lib/std/Thread/ResetEvent.zig
index cbc5a2a31c..47a9b0c038 100644
--- a/zig/lib/std/Thread/ResetEvent.zig
+++ b/zig/lib/std/Thread/ResetEvent.zig
@@ -112,9 +112,9 @@ const FutexImpl = struct {
         // Try to set the state from `unset` to `waiting` to indicate
         // to the set() thread that others are blocked on the ResetEvent.
         // We avoid using any strict barriers until the end when we know the ResetEvent is set.
-        var state = self.state.load(.monotonic);
+        var state = self.state.load(.acquire);
         if (state == unset) {
-            state = self.state.cmpxchgStrong(state, waiting, .monotonic, .monotonic) orelse waiting;
+            state = self.state.cmpxchgStrong(state, waiting, .acquire, .acquire) orelse waiting;
         }
 
         // Wait until the ResetEvent is set since the state is waiting.
@@ -124,7 +124,7 @@ const FutexImpl = struct {
                 const wait_result = futex_deadline.wait(&self.state, waiting);
 
                 // Check if the ResetEvent was set before possibly reporting error.Timeout below.
-                state = self.state.load(.monotonic);
+                state = self.state.load(.acquire);
                 if (state != waiting) {
                     break;
                 }
@@ -133,9 +133,7 @@ const FutexImpl = struct {
             }
         }
 
-        // Acquire barrier ensures memory accesses before set() happen before we return.
         assert(state == is_set);
-        self.state.fence(.acquire);
     }
 
     fn set(self: *Impl) void {
diff --git a/zig/lib/std/Thread/WaitGroup.zig b/zig/lib/std/Thread/WaitGroup.zig
index cff474c863..bdc49587bf 100644
--- a/zig/lib/std/Thread/WaitGroup.zig
+++ b/zig/lib/std/Thread/WaitGroup.zig
@@ -15,11 +15,10 @@ pub fn start(self: *WaitGroup) void {
 }
 
 pub fn finish(self: *WaitGroup) void {
-    const state = self.state.fetchSub(one_pending, .release);
+    const state = self.state.fetchSub(one_pending, .acq_rel);
     assert((state / one_pending) > 0);
 
     if (state == (one_pending | is_waiting)) {
-        self.state.fence(.acquire);
         self.event.set();
     }
 }
diff --git a/zig/lib/std/atomic.zig b/zig/lib/std/atomic.zig
index 0f25bd448a..e1a6767590 100644
--- a/zig/lib/std/atomic.zig
+++ b/zig/lib/std/atomic.zig
@@ -10,31 +10,7 @@ pub fn Value(comptime T: type) type {
             return .{ .raw = value };
         }
 
-        /// Perform an atomic fence which uses the atomic value as a hint for
-        /// the modification order. Use this when you want to imply a fence on
-        /// an atomic variable without necessarily performing a memory access.
-        pub inline fn fence(self: *Self, comptime order: AtomicOrder) void {
-            // LLVM's ThreadSanitizer doesn't support the normal fences so we specialize for it.
-            if (builtin.sanitize_thread) {
-                const tsan = struct {
-                    extern "c" fn __tsan_acquire(addr: *anyopaque) void;
-                    extern "c" fn __tsan_release(addr: *anyopaque) void;
-                };
-
-                const addr: *anyopaque = self;
-                return switch (order) {
-                    .unordered, .monotonic => @compileError(@tagName(order) ++ " only applies to atomic loads and stores"),
-                    .acquire => tsan.__tsan_acquire(addr),
-                    .release => tsan.__tsan_release(addr),
-                    .acq_rel, .seq_cst => {
-                        tsan.__tsan_acquire(addr);
-                        tsan.__tsan_release(addr);
-                    },
-                };
-            }
-
-            return @fence(order);
-        }
+        pub const fence = @compileError("@fence is deprecated, use other atomics to establish ordering");
 
         pub inline fn load(self: *const Self, comptime order: AtomicOrder) T {
             return @atomicLoad(T, &self.raw, order);
@@ -148,21 +124,19 @@ test Value {
         const RefCount = @This();
 
         fn ref(rc: *RefCount) void {
-            // No ordering necessary; just updating a counter.
+            // no synchronization necessary; just updating a counter.
             _ = rc.count.fetchAdd(1, .monotonic);
         }
 
         fn unref(rc: *RefCount) void {
-            // Release ensures code before unref() happens-before the
+            // release ensures code before unref() happens-before the
             // count is decremented as dropFn could be called by then.
             if (rc.count.fetchSub(1, .release) == 1) {
-                // acquire ensures count decrement and code before
-                // previous unrefs()s happens-before we call dropFn
-                // below.
-                // Another alternative is to use .acq_rel on the
-                // fetchSub count decrement but it's extra barrier in
-                // possibly hot path.
-                rc.count.fence(.acquire);
+                // seeing 1 in the counter means that other unref()s have happened,
+                // but it doesn't mean that uses before each unref() are visible.
+                // The load acquires the release-sequence created by previous unref()s
+                // in order to ensure visibility of uses before dropping.
+                _ = rc.count.load(.acquire);
                 (rc.dropFn)(rc);
             }
         }
@@ -459,18 +433,20 @@ pub const cache_line = switch (builtin.cpu.arch) {
     .powerpc64le,
     => 128,
 
+    // https://github.com/llvm/llvm-project/blob/e379094328e49731a606304f7e3559d4f1fa96f9/clang/lib/Basic/Targets/Hexagon.h#L145-L151
+    .hexagon,
+    => if (std.Target.hexagon.featureSetHas(builtin.target.cpu.features, .v73)) 64 else 32,
+
     // - https://github.com/golang/go/blob/3dd58676054223962cd915bb0934d1f9f489d4d2/src/internal/cpu/cpu_arm.go#L7
     // - https://github.com/golang/go/blob/3dd58676054223962cd915bb0934d1f9f489d4d2/src/internal/cpu/cpu_mips.go#L7
     // - https://github.com/golang/go/blob/3dd58676054223962cd915bb0934d1f9f489d4d2/src/internal/cpu/cpu_mipsle.go#L7
     // - https://github.com/golang/go/blob/3dd58676054223962cd915bb0934d1f9f489d4d2/src/internal/cpu/cpu_mips64x.go#L9
     // - https://github.com/golang/go/blob/3dd58676054223962cd915bb0934d1f9f489d4d2/src/internal/cpu/cpu_riscv64.go#L7
-    // - https://github.com/torvalds/linux/blob/3a7e02c040b130b5545e4b115aada7bacd80a2b6/arch/hexagon/include/asm/cache.h#L13
     // - https://github.com/torvalds/linux/blob/3a7e02c040b130b5545e4b115aada7bacd80a2b6/arch/sparc/include/asm/cache.h#L14
     .arm,
     .armeb,
     .thumb,
     .thumbeb,
-    .hexagon,
     .mips,
     .mipsel,
     .mips64,
diff --git a/zig/lib/std/bit_set.zig b/zig/lib/std/bit_set.zig
index 1e2a0179ef..7ff97cfa9d 100644
--- a/zig/lib/std/bit_set.zig
+++ b/zig/lib/std/bit_set.zig
@@ -1043,10 +1043,7 @@ pub const DynamicBitSet = struct {
     /// The integer type used to shift a mask in this bit set
     pub const ShiftInt = std.math.Log2Int(MaskInt);
 
-    /// The allocator used by this bit set
     allocator: Allocator,
-
-    /// The number of valid items in this bit set
     unmanaged: DynamicBitSetUnmanaged = .{},
 
     /// Creates a bit set with no elements present.
diff --git a/zig/lib/std/builtin.zig b/zig/lib/std/builtin.zig
index ccd46d874d..628b736d82 100644
--- a/zig/lib/std/builtin.zig
+++ b/zig/lib/std/builtin.zig
@@ -236,6 +236,17 @@ pub const AddressSpace = enum(u5) {
     flash3,
     flash4,
     flash5,
+
+    // Propeller address spaces.
+
+    /// This address space only addresses the cog-local ram.
+    cog,
+
+    /// This address space only addresses shared hub ram.
+    hub,
+
+    /// This address space only addresses the "lookup" ram
+    lut,
 };
 
 /// This data structure is used by the Zig language code generation and
@@ -609,6 +620,7 @@ pub const VaList = switch (builtin.cpu.arch) {
     .avr => *anyopaque,
     .bpfel, .bpfeb => *anyopaque,
     .hexagon => if (builtin.target.isMusl()) VaListHexagon else *u8,
+    .loongarch32, .loongarch64 => *anyopaque,
     .mips, .mipsel, .mips64, .mips64el => *anyopaque,
     .riscv32, .riscv64 => *anyopaque,
     .powerpc, .powerpcle => switch (builtin.os.tag) {
@@ -761,201 +773,54 @@ pub const TestFn = struct {
     func: *const fn () anyerror!void,
 };
 
-/// This function type is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
+/// Deprecated, use the `Panic` namespace instead.
+/// To be deleted after 0.14.0 is released.
 pub const PanicFn = fn ([]const u8, ?*StackTrace, ?usize) noreturn;
-
-/// This function is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub const panic: PanicFn = if (@hasDecl(root, "panic"))
-    root.panic
-else if (@hasDecl(root, "os") and @hasDecl(root.os, "panic"))
-    root.os.panic
+/// Deprecated, use the `Panic` namespace instead.
+/// To be deleted after 0.14.0 is released.
+pub const panic: PanicFn = Panic.call;
+
+/// This namespace is used by the Zig compiler to emit various kinds of safety
+/// panics. These can be overridden by making a public `Panic` namespace in the
+/// root source file.
+pub const Panic: type = if (@hasDecl(root, "Panic"))
+    root.Panic
+else if (@hasDecl(root, "panic")) // Deprecated, use `Panic` instead.
+    DeprecatedPanic
+else if (builtin.zig_backend == .stage2_riscv64)
+    std.debug.SimplePanic // https://github.com/ziglang/zig/issues/21519
 else
-    default_panic;
-
-/// This function is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub fn default_panic(msg: []const u8, error_return_trace: ?*StackTrace, ret_addr: ?usize) noreturn {
-    @branchHint(.cold);
-
-    // For backends that cannot handle the language features depended on by the
-    // default panic handler, we have a simpler panic handler:
-    if (builtin.zig_backend == .stage2_wasm or
-        builtin.zig_backend == .stage2_arm or
-        builtin.zig_backend == .stage2_aarch64 or
-        builtin.zig_backend == .stage2_x86 or
-        (builtin.zig_backend == .stage2_x86_64 and (builtin.target.ofmt != .elf and builtin.target.ofmt != .macho)) or
-        builtin.zig_backend == .stage2_sparc64 or
-        builtin.zig_backend == .stage2_spirv64)
-    {
-        while (true) {
-            @breakpoint();
-        }
-    }
-
-    if (builtin.zig_backend == .stage2_riscv64) {
-        std.debug.print("panic: {s}\n", .{msg});
-        @breakpoint();
-        std.posix.exit(127);
-    }
-
-    switch (builtin.os.tag) {
-        .freestanding => {
-            while (true) {
-                @breakpoint();
-            }
-        },
-        .wasi => {
-            std.debug.print("{s}", .{msg});
-            std.posix.abort();
-        },
-        .uefi => {
-            const uefi = std.os.uefi;
-
-            const Formatter = struct {
-                pub fn fmt(exit_msg: []const u8, out: []u16) ![:0]u16 {
-                    var u8_buf: [256]u8 = undefined;
-                    const slice = try std.fmt.bufPrint(&u8_buf, "err: {s}\r\n", .{exit_msg});
-                    // We pass len - 1 because we need to add a null terminator after
-                    const len = try std.unicode.utf8ToUtf16Le(out[0 .. out.len - 1], slice);
-
-                    out[len] = 0;
-
-                    return out[0..len :0];
-                }
-            };
-
-            const ExitData = struct {
-                pub fn create_exit_data(exit_msg: [:0]u16, exit_size: *usize) ![*:0]u16 {
-                    // Need boot services for pool allocation
-                    if (uefi.system_table.boot_services == null) {
-                        return error.BootServicesUnavailable;
-                    }
-
-                    // ExitData buffer must be allocated using boot_services.allocatePool (spec: page 220)
-                    const exit_data: []u16 = try uefi.raw_pool_allocator.alloc(u16, exit_msg.len + 1);
-
-                    @memcpy(exit_data[0 .. exit_msg.len + 1], exit_msg[0 .. exit_msg.len + 1]);
-                    exit_size.* = exit_msg.len + 1;
-
-                    return @as([*:0]u16, @ptrCast(exit_data.ptr));
-                }
-            };
-
-            var buf: [256]u16 = undefined;
-            const utf16 = Formatter.fmt(msg, &buf) catch null;
-
-            var exit_size: usize = 0;
-            const exit_data = if (utf16) |u|
-                ExitData.create_exit_data(u, &exit_size) catch null
-            else
-                null;
-
-            if (utf16) |str| {
-                // Output to both std_err and con_out, as std_err is easier
-                // to read in stuff like QEMU at times, but, unlike con_out,
-                // isn't visible on actual hardware if directly booted into
-                inline for ([_]?*uefi.protocol.SimpleTextOutput{ uefi.system_table.std_err, uefi.system_table.con_out }) |o| {
-                    if (o) |out| {
-                        _ = out.setAttribute(uefi.protocol.SimpleTextOutput.red);
-                        _ = out.outputString(str);
-                        _ = out.setAttribute(uefi.protocol.SimpleTextOutput.white);
-                    }
-                }
-            }
-
-            if (uefi.system_table.boot_services) |bs| {
-                _ = bs.exit(uefi.handle, .Aborted, exit_size, exit_data);
-            }
-
-            // Didn't have boot_services, just fallback to whatever.
-            std.posix.abort();
-        },
-        .cuda, .amdhsa => std.posix.abort(),
-        .plan9 => {
-            var status: [std.os.plan9.ERRMAX]u8 = undefined;
-            const len = @min(msg.len, status.len - 1);
-            @memcpy(status[0..len], msg[0..len]);
-            status[len] = 0;
-            std.os.plan9.exits(status[0..len :0]);
-        },
-        else => {
-            const first_trace_addr = ret_addr orelse @returnAddress();
-            std.debug.panicImpl(error_return_trace, first_trace_addr, msg);
-        },
-    }
-}
-
-pub fn checkNonScalarSentinel(expected: anytype, actual: @TypeOf(expected)) void {
-    if (!std.meta.eql(expected, actual)) {
-        panicSentinelMismatch(expected, actual);
-    }
-}
-
-pub fn panicSentinelMismatch(expected: anytype, actual: @TypeOf(expected)) noreturn {
-    @branchHint(.cold);
-    std.debug.panicExtra(null, @returnAddress(), "sentinel mismatch: expected {any}, found {any}", .{ expected, actual });
-}
-
-pub fn panicUnwrapError(st: ?*StackTrace, err: anyerror) noreturn {
-    @branchHint(.cold);
-    std.debug.panicExtra(st, @returnAddress(), "attempt to unwrap error: {s}", .{@errorName(err)});
-}
-
-pub fn panicOutOfBounds(index: usize, len: usize) noreturn {
-    @branchHint(.cold);
-    std.debug.panicExtra(null, @returnAddress(), "index out of bounds: index {d}, len {d}", .{ index, len });
-}
-
-pub fn panicStartGreaterThanEnd(start: usize, end: usize) noreturn {
-    @branchHint(.cold);
-    std.debug.panicExtra(null, @returnAddress(), "start index {d} is larger than end index {d}", .{ start, end });
-}
-
-pub fn panicInactiveUnionField(active: anytype, wanted: @TypeOf(active)) noreturn {
-    @branchHint(.cold);
-    std.debug.panicExtra(null, @returnAddress(), "access of union field '{s}' while field '{s}' is active", .{ @tagName(wanted), @tagName(active) });
-}
-
-pub const panic_messages = struct {
-    pub const unreach = "reached unreachable code";
-    pub const unwrap_null = "attempt to use null value";
-    pub const cast_to_null = "cast causes pointer to be null";
-    pub const incorrect_alignment = "incorrect alignment";
-    pub const invalid_error_code = "invalid error code";
-    pub const cast_truncated_data = "integer cast truncated bits";
-    pub const negative_to_unsigned = "attempt to cast negative value to unsigned integer";
-    pub const integer_overflow = "integer overflow";
-    pub const shl_overflow = "left shift overflowed bits";
-    pub const shr_overflow = "right shift overflowed bits";
-    pub const divide_by_zero = "division by zero";
-    pub const exact_division_remainder = "exact division produced remainder";
-    pub const inactive_union_field = "access of inactive union field";
-    pub const integer_part_out_of_bounds = "integer part of floating point value out of bounds";
-    pub const corrupt_switch = "switch on corrupt value";
-    pub const shift_rhs_too_big = "shift amount is greater than the type size";
-    pub const invalid_enum_value = "invalid enum value";
-    pub const sentinel_mismatch = "sentinel mismatch";
-    pub const unwrap_error = "attempt to unwrap error";
-    pub const index_out_of_bounds = "index out of bounds";
-    pub const start_index_greater_than_end = "start index is larger than end index";
-    pub const for_len_mismatch = "for loop over objects with non-equal lengths";
-    pub const memcpy_len_mismatch = "@memcpy arguments have non-equal lengths";
-    pub const memcpy_alias = "@memcpy arguments alias";
-    pub const noreturn_returned = "'noreturn' function returned";
-};
+    std.debug.FormattedPanic;
+
+/// To be deleted after 0.14.0 is released.
+const DeprecatedPanic = struct {
+    pub const call = root.panic;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+/// To be deleted after zig1.wasm is updated.
+pub const panicSentinelMismatch = Panic.sentinelMismatch;
+/// To be deleted after zig1.wasm is updated.
+pub const panicUnwrapError = Panic.unwrapError;
+/// To be deleted after zig1.wasm is updated.
+pub const panicOutOfBounds = Panic.outOfBounds;
+/// To be deleted after zig1.wasm is updated.
+pub const panicStartGreaterThanEnd = Panic.startGreaterThanEnd;
+/// To be deleted after zig1.wasm is updated.
+pub const panicInactiveUnionField = Panic.inactiveUnionField;
+/// To be deleted after zig1.wasm is updated.
+pub const panic_messages = Panic.messages;
 
 pub noinline fn returnError(st: *StackTrace) void {
-    @branchHint(.cold);
+    @branchHint(.unlikely);
     @setRuntimeSafety(false);
-    addErrRetTraceAddr(st, @returnAddress());
-}
-
-pub inline fn addErrRetTraceAddr(st: *StackTrace, addr: usize) void {
     if (st.index < st.instruction_addresses.len)
-        st.instruction_addresses[st.index] = addr;
-
+        st.instruction_addresses[st.index] = @returnAddress();
     st.index += 1;
 }
 
diff --git a/zig/lib/std/c.zig b/zig/lib/std/c.zig
index 12524667d2..d28f5b0ac4 100644
--- a/zig/lib/std/c.zig
+++ b/zig/lib/std/c.zig
@@ -134,7 +134,7 @@ pub const mode_t = switch (native_os) {
     .linux => linux.mode_t,
     .emscripten => emscripten.mode_t,
     .openbsd, .haiku, .netbsd, .solaris, .illumos, .wasi => u32,
-    .freebsd, .macos, .ios, .tvos, .watchos, .visionos => u16,
+    .freebsd, .macos, .ios, .tvos, .watchos, .visionos, .dragonfly => u16,
     else => u0,
 };
 
@@ -2753,6 +2753,19 @@ pub const Sigaction = switch (native_os) {
             restorer: ?*const fn () callconv(.C) void = null,
             __resv: [1]c_int = .{0},
         },
+        .s390x => if (builtin.abi == .gnu) extern struct {
+            pub const handler_fn = *align(1) const fn (i32) callconv(.C) void;
+            pub const sigaction_fn = *const fn (i32, *const siginfo_t, ?*anyopaque) callconv(.C) void;
+
+            handler: extern union {
+                handler: ?handler_fn,
+                sigaction: ?sigaction_fn,
+            },
+            __glibc_reserved0: c_int = 0,
+            flags: c_uint,
+            restorer: ?*const fn () callconv(.C) void = null,
+            mask: sigset_t,
+        } else linux.Sigaction,
         else => linux.Sigaction,
     },
     .emscripten => emscripten.Sigaction,
@@ -3137,6 +3150,72 @@ pub const T = switch (native_os) {
         pub const IOCUCNTL = 0x80047466;
         pub const IOCXMTFRAME = 0x80087444;
     },
+    .dragonfly => struct {
+        pub const IOCMODG = 0x40047403;
+        pub const IOCMODS = 0x80047404;
+        pub const IOCM_LE = 0x00000001;
+        pub const IOCM_DTR = 0x00000002;
+        pub const IOCM_RTS = 0x00000004;
+        pub const IOCM_ST = 0x00000008;
+        pub const IOCM_SR = 0x00000010;
+        pub const IOCM_CTS = 0x00000020;
+        pub const IOCM_CAR = 0x00000040;
+        pub const IOCM_CD = 0x00000040;
+        pub const IOCM_RNG = 0x00000080;
+        pub const IOCM_RI = 0x00000080;
+        pub const IOCM_DSR = 0x00000100;
+        pub const IOCEXCL = 0x2000740d;
+        pub const IOCNXCL = 0x2000740e;
+        pub const IOCFLUSH = 0x80047410;
+        pub const IOCGETA = 0x402c7413;
+        pub const IOCSETA = 0x802c7414;
+        pub const IOCSETAW = 0x802c7415;
+        pub const IOCSETAF = 0x802c7416;
+        pub const IOCGETD = 0x4004741a;
+        pub const IOCSETD = 0x8004741b;
+        pub const IOCSBRK = 0x2000747b;
+        pub const IOCCBRK = 0x2000747a;
+        pub const IOCSDTR = 0x20007479;
+        pub const IOCCDTR = 0x20007478;
+        pub const IOCGPGRP = 0x40047477;
+        pub const IOCSPGRP = 0x80047476;
+        pub const IOCOUTQ = 0x40047473;
+        pub const IOCSTI = 0x80017472;
+        pub const IOCNOTTY = 0x20007471;
+        pub const IOCPKT = 0x80047470;
+        pub const IOCPKT_DATA = 0x00000000;
+        pub const IOCPKT_FLUSHREAD = 0x00000001;
+        pub const IOCPKT_FLUSHWRITE = 0x00000002;
+        pub const IOCPKT_STOP = 0x00000004;
+        pub const IOCPKT_START = 0x00000008;
+        pub const IOCPKT_NOSTOP = 0x00000010;
+        pub const IOCPKT_DOSTOP = 0x00000020;
+        pub const IOCPKT_IOCTL = 0x00000040;
+        pub const IOCSTOP = 0x2000746f;
+        pub const IOCSTART = 0x2000746e;
+        pub const IOCMSET = 0x8004746d;
+        pub const IOCMBIS = 0x8004746c;
+        pub const IOCMBIC = 0x8004746b;
+        pub const IOCMGET = 0x4004746a;
+        pub const IOCREMOTE = 0x80047469;
+        pub const IOCGWINSZ = 0x40087468;
+        pub const IOCSWINSZ = 0x80087467;
+        pub const IOCUCNTL = 0x80047466;
+        pub const IOCSTAT = 0x20007465;
+        pub const IOCGSID = 0x40047463;
+        pub const IOCCONS = 0x80047462;
+        pub const IOCSCTTY = 0x20007461;
+        pub const IOCEXT = 0x80047460;
+        pub const IOCSIG = 0x2000745f;
+        pub const IOCDRAIN = 0x2000745e;
+        pub const IOCMSDTRWAIT = 0x8004745b;
+        pub const IOCMGDTRWAIT = 0x4004745a;
+        pub const IOCTIMESTAMP = 0x40107459;
+        pub const IOCDCDTIMESTAMP = 0x40107458;
+        pub const IOCSDRAINWAIT = 0x80047457;
+        pub const IOCGDRAINWAIT = 0x40047456;
+        pub const IOCISPTMASTER = 0x20007455;
+    },
     else => void,
 };
 pub const IOCPARM_MASK = switch (native_os) {
@@ -5946,7 +6025,7 @@ pub const PR = switch (native_os) {
 };
 pub const _errno = switch (native_os) {
     .linux => switch (native_abi) {
-        .android => private.__errno,
+        .android, .androideabi => private.__errno,
         else => private.__errno_location,
     },
     .emscripten => private.__errno_location,
@@ -6389,14 +6468,14 @@ pub const Stat = switch (native_os) {
                 return self.ctim;
             }
         } else extern struct {
-            dev: dev_t,
+            dev: u32,
             __pad0: [3]u32,
             ino: ino_t,
             mode: mode_t,
             nlink: nlink_t,
             uid: uid_t,
             gid: gid_t,
-            rdev: dev_t,
+            rdev: u32,
             __pad1: [3]u32,
             size: off_t,
             atim: timespec,
@@ -6754,7 +6833,7 @@ pub const pthread_mutex_t = switch (native_os) {
                 .mips64, .powerpc64, .powerpc64le, .sparc64 => 40,
                 else => if (@sizeOf(usize) == 8) 40 else 24,
             },
-            .android => if (@sizeOf(usize) == 8) 40 else 4,
+            .android, .androideabi => if (@sizeOf(usize) == 8) 40 else 4,
             else => @compileError("unsupported ABI"),
         };
     },
@@ -6848,7 +6927,7 @@ pub const pthread_cond_t = switch (native_os) {
 
 pub const pthread_rwlock_t = switch (native_os) {
     .linux => switch (native_abi) {
-        .android => switch (@sizeOf(usize)) {
+        .android, .androideabi => switch (@sizeOf(usize)) {
             4 => extern struct {
                 data: [40]u8 align(@alignOf(usize)) = [_]u8{0} ** 40,
             },
@@ -9450,7 +9529,7 @@ pub extern "c" fn pthread_rwlock_unlock(rwl: *pthread_rwlock_t) callconv(.C) E;
 pub const pthread_t = *opaque {};
 pub const FILE = opaque {};
 
-pub extern "c" fn dlopen(path: [*:0]const u8, mode: RTLD) ?*anyopaque;
+pub extern "c" fn dlopen(path: ?[*:0]const u8, mode: RTLD) ?*anyopaque;
 pub extern "c" fn dlclose(handle: *anyopaque) c_int;
 pub extern "c" fn dlsym(handle: ?*anyopaque, symbol: [*:0]const u8) ?*anyopaque;
 pub extern "c" fn dlerror() ?[*:0]u8;
@@ -9506,7 +9585,7 @@ else if (native_os == .linux and builtin.target.isMusl())
 else
     private.getcontext;
 
-pub const max_align_t = if (native_abi == .msvc)
+pub const max_align_t = if (native_abi == .msvc or native_abi == .itanium)
     f64
 else if (builtin.target.isDarwin())
     c_longdouble
@@ -9796,6 +9875,10 @@ pub const _ksiginfo = netbsd._ksiginfo;
 pub const _lwp_self = netbsd._lwp_self;
 pub const lwpid_t = netbsd.lwpid_t;
 
+pub const lwp_gettid = dragonfly.lwp_gettid;
+pub const umtx_sleep = dragonfly.umtx_sleep;
+pub const umtx_wakeup = dragonfly.umtx_wakeup;
+
 /// External definitions shared by two or more operating systems.
 const private = struct {
     extern "c" fn close(fd: fd_t) c_int;
diff --git a/zig/lib/std/c/darwin.zig b/zig/lib/std/c/darwin.zig
index 60a349868e..573f29150d 100644
--- a/zig/lib/std/c/darwin.zig
+++ b/zig/lib/std/c/darwin.zig
@@ -10,7 +10,7 @@ const mode_t = std.c.mode_t;
 const off_t = std.c.off_t;
 const pid_t = std.c.pid_t;
 const pthread_attr_t = std.c.pthread_attr_t;
-const sigset_t = std.c.segset_t;
+const sigset_t = std.c.sigset_t;
 const timespec = std.c.timespec;
 const sf_hdtr = std.c.sf_hdtr;
 
@@ -23,6 +23,7 @@ pub const mach_port_t = c_uint;
 pub const THREAD_STATE_NONE = switch (native_arch) {
     .aarch64 => 5,
     .x86_64 => 13,
+    else => @compileError("unsupported arch"),
 };
 
 pub const EXC = enum(exception_type_t) {
diff --git a/zig/lib/std/crypto/tls.zig b/zig/lib/std/crypto/tls.zig
index b3d0dcb59f..fb1b550e42 100644
--- a/zig/lib/std/crypto/tls.zig
+++ b/zig/lib/std/crypto/tls.zig
@@ -279,8 +279,8 @@ pub const NamedGroup = enum(u16) {
     ffdhe8192 = 0x0104,
 
     // Hybrid post-quantum key agreements
-    x25519_kyber512d00 = 0xFE30,
-    x25519_kyber768d00 = 0x6399,
+    secp256r1_ml_kem256 = 0x11EB,
+    x25519_ml_kem768 = 0x11EC,
 
     _,
 };
diff --git a/zig/lib/std/crypto/tls/Client.zig b/zig/lib/std/crypto/tls/Client.zig
index 452ef5d0c5..84dbb2167a 100644
--- a/zig/lib/std/crypto/tls/Client.zig
+++ b/zig/lib/std/crypto/tls/Client.zig
@@ -158,7 +158,7 @@ pub fn init(stream: anytype, ca_bundle: Certificate.Bundle, host: []const u8) In
         // Only possible to happen if the private key is all zeroes.
         error.IdentityElement => return error.InsufficientEntropy,
     };
-    const kyber768_kp = crypto.kem.kyber_d00.Kyber768.KeyPair.create(null) catch {};
+    const ml_kem768_kp = crypto.kem.ml_kem.MLKem768.KeyPair.create(null) catch {};
 
     const extensions_payload =
         tls.extension(.supported_versions, [_]u8{
@@ -172,7 +172,7 @@ pub fn init(stream: anytype, ca_bundle: Certificate.Bundle, host: []const u8) In
         .rsa_pss_rsae_sha512,
         .ed25519,
     })) ++ tls.extension(.supported_groups, enum_array(tls.NamedGroup, &.{
-        .x25519_kyber768d00,
+        .x25519_ml_kem768,
         .secp256r1,
         .x25519,
     })) ++ tls.extension(
@@ -181,8 +181,8 @@ pub fn init(stream: anytype, ca_bundle: Certificate.Bundle, host: []const u8) In
             array(1, x25519_kp.public_key) ++
             int2(@intFromEnum(tls.NamedGroup.secp256r1)) ++
             array(1, secp256r1_kp.public_key.toUncompressedSec1()) ++
-            int2(@intFromEnum(tls.NamedGroup.x25519_kyber768d00)) ++
-            array(1, x25519_kp.public_key ++ kyber768_kp.public_key.toBytes())),
+            int2(@intFromEnum(tls.NamedGroup.x25519_ml_kem768)) ++
+            array(1, x25519_kp.public_key ++ ml_kem768_kp.public_key.toBytes())),
     ) ++
         int2(@intFromEnum(tls.ExtensionType.server_name)) ++
         int2(host_len + 5) ++ // byte length of this extension payload
@@ -298,9 +298,9 @@ pub fn init(stream: anytype, ca_bundle: Certificate.Bundle, host: []const u8) In
                             const key_size = extd.decode(u16);
                             try extd.ensure(key_size);
                             switch (named_group) {
-                                .x25519_kyber768d00 => {
+                                .x25519_ml_kem768 => {
                                     const xksl = crypto.dh.X25519.public_length;
-                                    const hksl = xksl + crypto.kem.kyber_d00.Kyber768.ciphertext_length;
+                                    const hksl = xksl + crypto.kem.ml_kem.MLKem768.ciphertext_length;
                                     if (key_size != hksl)
                                         return error.TlsIllegalParameter;
                                     const server_ks = extd.array(hksl);
@@ -308,7 +308,7 @@ pub fn init(stream: anytype, ca_bundle: Certificate.Bundle, host: []const u8) In
                                     shared_key = &((crypto.dh.X25519.scalarmult(
                                         x25519_kp.secret_key,
                                         server_ks[0..xksl].*,
-                                    ) catch return error.TlsDecryptFailure) ++ (kyber768_kp.secret_key.decaps(
+                                    ) catch return error.TlsDecryptFailure) ++ (ml_kem768_kp.secret_key.decaps(
                                         server_ks[xksl..hksl],
                                     ) catch return error.TlsDecryptFailure));
                                 },
diff --git a/zig/lib/std/debug.zig b/zig/lib/std/debug.zig
index fd6676504f..23b005ad49 100644
--- a/zig/lib/std/debug.zig
+++ b/zig/lib/std/debug.zig
@@ -21,6 +21,9 @@ pub const SelfInfo = @import("debug/SelfInfo.zig");
 pub const Info = @import("debug/Info.zig");
 pub const Coverage = @import("debug/Coverage.zig");
 
+pub const FormattedPanic = @import("debug/FormattedPanic.zig");
+pub const SimplePanic = @import("debug/SimplePanic.zig");
+
 /// Unresolved source locations can be represented with a single `usize` that
 /// corresponds to a virtual memory address of the program counter. Combined
 /// with debug information, those values can be converted into a resolved
@@ -58,6 +61,7 @@ pub const sys_can_stack_trace = switch (builtin.cpu.arch) {
     .mipsel,
     .mips64,
     .mips64el,
+    .s390x,
     => false,
 
     // `@returnAddress()` in LLVM 10 gives
@@ -408,14 +412,21 @@ pub fn assertReadable(slice: []const volatile u8) void {
     for (slice) |*byte| _ = byte.*;
 }
 
+/// By including a call to this function, the caller gains an error return trace
+/// secret parameter, making `@errorReturnTrace()` more useful. This is not
+/// necessary if the function already contains a call to an errorable function
+/// elsewhere.
+pub fn errorReturnTraceHelper() anyerror!void {}
+
+/// Equivalent to `@panic` but with a formatted message.
 pub fn panic(comptime format: []const u8, args: anytype) noreturn {
     @branchHint(.cold);
-
+    errorReturnTraceHelper() catch unreachable;
     panicExtra(@errorReturnTrace(), @returnAddress(), format, args);
 }
 
-/// `panicExtra` is useful when you want to print out an `@errorReturnTrace`
-/// and also print out some values.
+/// Equivalent to `@panic` but with a formatted message, and with an explicitly
+/// provided `@errorReturnTrace` and return address.
 pub fn panicExtra(
     trace: ?*std.builtin.StackTrace,
     ret_addr: ?usize,
@@ -436,7 +447,7 @@ pub fn panicExtra(
             break :blk &buf;
         },
     };
-    std.builtin.panic(msg, trace, ret_addr);
+    std.builtin.Panic.call(msg, trace, ret_addr);
 }
 
 /// Non-zero whenever the program triggered a panic.
@@ -447,11 +458,70 @@ var panicking = std.atomic.Value(u8).init(0);
 /// This is used to catch and handle panics triggered by the panic handler.
 threadlocal var panic_stage: usize = 0;
 
-// `panicImpl` could be useful in implementing a custom panic handler which
-// calls the default handler (on supported platforms)
-pub fn panicImpl(trace: ?*const std.builtin.StackTrace, first_trace_addr: ?usize, msg: []const u8) noreturn {
+/// Dumps a stack trace to standard error, then aborts.
+pub fn defaultPanic(
+    msg: []const u8,
+    error_return_trace: ?*const std.builtin.StackTrace,
+    first_trace_addr: ?usize,
+) noreturn {
     @branchHint(.cold);
 
+    // For backends that cannot handle the language features depended on by the
+    // default panic handler, we have a simpler panic handler:
+    if (builtin.zig_backend == .stage2_wasm or
+        builtin.zig_backend == .stage2_arm or
+        builtin.zig_backend == .stage2_aarch64 or
+        builtin.zig_backend == .stage2_x86 or
+        (builtin.zig_backend == .stage2_x86_64 and (builtin.target.ofmt != .elf and builtin.target.ofmt != .macho)) or
+        builtin.zig_backend == .stage2_sparc64 or
+        builtin.zig_backend == .stage2_spirv64)
+    {
+        @trap();
+    }
+
+    switch (builtin.os.tag) {
+        .freestanding => {
+            @trap();
+        },
+        .uefi => {
+            const uefi = std.os.uefi;
+
+            var utf16_buffer: [1000]u16 = undefined;
+            const len_minus_3 = std.unicode.utf8ToUtf16Le(&utf16_buffer, msg) catch 0;
+            utf16_buffer[len_minus_3..][0..3].* = .{ '\r', '\n', 0 };
+            const len = len_minus_3 + 3;
+            const exit_msg = utf16_buffer[0 .. len - 1 :0];
+
+            // Output to both std_err and con_out, as std_err is easier
+            // to read in stuff like QEMU at times, but, unlike con_out,
+            // isn't visible on actual hardware if directly booted into
+            inline for ([_]?*uefi.protocol.SimpleTextOutput{ uefi.system_table.std_err, uefi.system_table.con_out }) |o| {
+                if (o) |out| {
+                    _ = out.setAttribute(uefi.protocol.SimpleTextOutput.red);
+                    _ = out.outputString(exit_msg);
+                    _ = out.setAttribute(uefi.protocol.SimpleTextOutput.white);
+                }
+            }
+
+            if (uefi.system_table.boot_services) |bs| {
+                // ExitData buffer must be allocated using boot_services.allocatePool (spec: page 220)
+                const exit_data: []u16 = uefi.raw_pool_allocator.alloc(u16, exit_msg.len + 1) catch @trap();
+                @memcpy(exit_data, exit_msg[0..exit_data.len]); // Includes null terminator.
+                _ = bs.exit(uefi.handle, .Aborted, exit_data.len, exit_data.ptr);
+            }
+            @trap();
+        },
+        .cuda, .amdhsa => std.posix.abort(),
+        .plan9 => {
+            var status: [std.os.plan9.ERRMAX]u8 = undefined;
+            const len = @min(msg.len, status.len - 1);
+            @memcpy(status[0..len], msg[0..len]);
+            status[len] = 0;
+            std.os.plan9.exits(status[0..len :0]);
+        },
+        else => {},
+    }
+
     if (enable_segfault_handler) {
         // If a segfault happens while panicking, we want it to actually segfault, not trigger
         // the handler.
@@ -465,7 +535,6 @@ pub fn panicImpl(trace: ?*const std.builtin.StackTrace, first_trace_addr: ?usize
 
             _ = panicking.fetchAdd(1, .seq_cst);
 
-            // Make sure to release the mutex when done
             {
                 lockStdErr();
                 defer unlockStdErr();
@@ -478,10 +547,9 @@ pub fn panicImpl(trace: ?*const std.builtin.StackTrace, first_trace_addr: ?usize
                     stderr.print("thread {} panic: ", .{current_thread_id}) catch posix.abort();
                 }
                 stderr.print("{s}\n", .{msg}) catch posix.abort();
-                if (trace) |t| {
-                    dumpStackTrace(t.*);
-                }
-                dumpCurrentStackTrace(first_trace_addr);
+
+                if (error_return_trace) |t| dumpStackTrace(t.*);
+                dumpCurrentStackTrace(first_trace_addr orelse @returnAddress());
             }
 
             waitForOtherThreadToFinishPanicking();
@@ -489,15 +557,12 @@ pub fn panicImpl(trace: ?*const std.builtin.StackTrace, first_trace_addr: ?usize
         1 => {
             panic_stage = 2;
 
-            // A panic happened while trying to print a previous panic message,
-            // we're still holding the mutex but that's fine as we're going to
-            // call abort()
-            const stderr = io.getStdErr().writer();
-            stderr.print("Panicked during a panic. Aborting.\n", .{}) catch posix.abort();
-        },
-        else => {
-            // Panicked while printing "Panicked during a panic."
+            // A panic happened while trying to print a previous panic message.
+            // We're still holding the mutex but that's fine as we're going to
+            // call abort().
+            io.getStdErr().writeAll("aborting due to recursive panic\n") catch {};
         },
+        else => {}, // Panicked while printing the recursive panic message.
     };
 
     posix.abort();
@@ -1157,7 +1222,7 @@ pub const default_enable_segfault_handler = runtime_safety and have_segfault_han
 
 pub fn maybeEnableSegfaultHandler() void {
     if (enable_segfault_handler) {
-        std.debug.attachSegfaultHandler();
+        attachSegfaultHandler();
     }
 }
 
@@ -1289,46 +1354,29 @@ fn handleSegfaultWindows(info: *windows.EXCEPTION_POINTERS) callconv(windows.WIN
     }
 }
 
-fn handleSegfaultWindowsExtra(
-    info: *windows.EXCEPTION_POINTERS,
-    msg: u8,
-    label: ?[]const u8,
-) noreturn {
-    const exception_address = @intFromPtr(info.ExceptionRecord.ExceptionAddress);
-    if (windows.CONTEXT != void) {
-        nosuspend switch (panic_stage) {
-            0 => {
-                panic_stage = 1;
-                _ = panicking.fetchAdd(1, .seq_cst);
-
-                {
-                    lockStdErr();
-                    defer unlockStdErr();
-
-                    dumpSegfaultInfoWindows(info, msg, label);
-                }
+fn handleSegfaultWindowsExtra(info: *windows.EXCEPTION_POINTERS, msg: u8, label: ?[]const u8) noreturn {
+    comptime assert(windows.CONTEXT != void);
+    nosuspend switch (panic_stage) {
+        0 => {
+            panic_stage = 1;
+            _ = panicking.fetchAdd(1, .seq_cst);
+
+            {
+                lockStdErr();
+                defer unlockStdErr();
 
-                waitForOtherThreadToFinishPanicking();
-            },
-            else => {
-                // panic mutex already locked
                 dumpSegfaultInfoWindows(info, msg, label);
-            },
-        };
-        posix.abort();
-    } else {
-        switch (msg) {
-            0 => panicImpl(null, exception_address, "{s}", label.?),
-            1 => {
-                const format_item = "Segmentation fault at address 0x{x}";
-                var buf: [format_item.len + 64]u8 = undefined; // 64 is arbitrary, but sufficiently large
-                const to_print = std.fmt.bufPrint(buf[0..buf.len], format_item, .{info.ExceptionRecord.ExceptionInformation[1]}) catch unreachable;
-                panicImpl(null, exception_address, to_print);
-            },
-            2 => panicImpl(null, exception_address, "Illegal Instruction"),
-            else => unreachable,
-        }
-    }
+            }
+
+            waitForOtherThreadToFinishPanicking();
+        },
+        1 => {
+            panic_stage = 2;
+            io.getStdErr().writeAll("aborting due to recursive panic\n") catch {};
+        },
+        else => {},
+    };
+    posix.abort();
 }
 
 fn dumpSegfaultInfoWindows(info: *windows.EXCEPTION_POINTERS, msg: u8, label: ?[]const u8) void {
@@ -1347,7 +1395,7 @@ pub fn dumpStackPointerAddr(prefix: []const u8) void {
     const sp = asm (""
         : [argc] "={rsp}" (-> usize),
     );
-    std.debug.print("{s} sp = 0x{x}\n", .{ prefix, sp });
+    print("{s} sp = 0x{x}\n", .{ prefix, sp });
 }
 
 test "manage resources correctly" {
diff --git a/zig/lib/std/debug/FormattedPanic.zig b/zig/lib/std/debug/FormattedPanic.zig
new file mode 100644
index 0000000000..0ad6ea696c
--- /dev/null
+++ b/zig/lib/std/debug/FormattedPanic.zig
@@ -0,0 +1,45 @@
+//! This namespace is the default one used by the Zig compiler to emit various
+//! kinds of safety panics, due to the logic in `std.builtin.Panic`.
+//!
+//! Since Zig does not have interfaces, this file serves as an example template
+//! for users to provide their own alternative panic handling.
+//!
+//! As an alternative, see `std.debug.SimplePanic`.
+
+const std = @import("../std.zig");
+
+/// Dumps a stack trace to standard error, then aborts.
+///
+/// Explicit calls to `@panic` lower to calling this function.
+pub const call: fn ([]const u8, ?*std.builtin.StackTrace, ?usize) noreturn = std.debug.defaultPanic;
+
+pub fn sentinelMismatch(expected: anytype, found: @TypeOf(expected)) noreturn {
+    @branchHint(.cold);
+    std.debug.panicExtra(null, @returnAddress(), "sentinel mismatch: expected {any}, found {any}", .{
+        expected, found,
+    });
+}
+
+pub fn unwrapError(ert: ?*std.builtin.StackTrace, err: anyerror) noreturn {
+    @branchHint(.cold);
+    std.debug.panicExtra(ert, @returnAddress(), "attempt to unwrap error: {s}", .{@errorName(err)});
+}
+
+pub fn outOfBounds(index: usize, len: usize) noreturn {
+    @branchHint(.cold);
+    std.debug.panicExtra(null, @returnAddress(), "index out of bounds: index {d}, len {d}", .{ index, len });
+}
+
+pub fn startGreaterThanEnd(start: usize, end: usize) noreturn {
+    @branchHint(.cold);
+    std.debug.panicExtra(null, @returnAddress(), "start index {d} is larger than end index {d}", .{ start, end });
+}
+
+pub fn inactiveUnionField(active: anytype, accessed: @TypeOf(active)) noreturn {
+    @branchHint(.cold);
+    std.debug.panicExtra(null, @returnAddress(), "access of union field '{s}' while field '{s}' is active", .{
+        @tagName(accessed), @tagName(active),
+    });
+}
+
+pub const messages = std.debug.SimplePanic.messages;
diff --git a/zig/lib/std/debug/SimplePanic.zig b/zig/lib/std/debug/SimplePanic.zig
new file mode 100644
index 0000000000..9685642a5c
--- /dev/null
+++ b/zig/lib/std/debug/SimplePanic.zig
@@ -0,0 +1,86 @@
+//! This namespace is the default one used by the Zig compiler to emit various
+//! kinds of safety panics, due to the logic in `std.builtin.Panic`.
+//!
+//! Since Zig does not have interfaces, this file serves as an example template
+//! for users to provide their own alternative panic handling.
+//!
+//! As an alternative, see `std.debug.FormattedPanic`.
+
+const std = @import("../std.zig");
+
+/// Prints the message to stderr without a newline and then traps.
+///
+/// Explicit calls to `@panic` lower to calling this function.
+pub fn call(msg: []const u8, ert: ?*std.builtin.StackTrace, ra: ?usize) noreturn {
+    @branchHint(.cold);
+    _ = ert;
+    _ = ra;
+    std.debug.lockStdErr();
+    const stderr = std.io.getStdErr();
+    stderr.writeAll(msg) catch {};
+    @trap();
+}
+
+pub fn sentinelMismatch(expected: anytype, found: @TypeOf(expected)) noreturn {
+    _ = found;
+    call("sentinel mismatch", null, null);
+}
+
+pub fn unwrapError(ert: ?*std.builtin.StackTrace, err: anyerror) noreturn {
+    _ = ert;
+    _ = &err;
+    call("attempt to unwrap error", null, null);
+}
+
+pub fn outOfBounds(index: usize, len: usize) noreturn {
+    _ = index;
+    _ = len;
+    call("index out of bounds", null, null);
+}
+
+pub fn startGreaterThanEnd(start: usize, end: usize) noreturn {
+    _ = start;
+    _ = end;
+    call("start index is larger than end index", null, null);
+}
+
+pub fn inactiveUnionField(active: anytype, accessed: @TypeOf(active)) noreturn {
+    _ = accessed;
+    call("access of inactive union field", null, null);
+}
+
+pub const messages = struct {
+    pub const reached_unreachable = "reached unreachable code";
+    pub const unwrap_null = "attempt to use null value";
+    pub const cast_to_null = "cast causes pointer to be null";
+    pub const incorrect_alignment = "incorrect alignment";
+    pub const invalid_error_code = "invalid error code";
+    pub const cast_truncated_data = "integer cast truncated bits";
+    pub const negative_to_unsigned = "attempt to cast negative value to unsigned integer";
+    pub const integer_overflow = "integer overflow";
+    pub const shl_overflow = "left shift overflowed bits";
+    pub const shr_overflow = "right shift overflowed bits";
+    pub const divide_by_zero = "division by zero";
+    pub const exact_division_remainder = "exact division produced remainder";
+    pub const integer_part_out_of_bounds = "integer part of floating point value out of bounds";
+    pub const corrupt_switch = "switch on corrupt value";
+    pub const shift_rhs_too_big = "shift amount is greater than the type size";
+    pub const invalid_enum_value = "invalid enum value";
+    pub const for_len_mismatch = "for loop over objects with non-equal lengths";
+    pub const memcpy_len_mismatch = "@memcpy arguments have non-equal lengths";
+    pub const memcpy_alias = "@memcpy arguments alias";
+    pub const noreturn_returned = "'noreturn' function returned";
+
+    /// To be deleted after zig1.wasm is updated.
+    pub const inactive_union_field = "access of inactive union field";
+    /// To be deleted after zig1.wasm is updated.
+    pub const sentinel_mismatch = "sentinel mismatch";
+    /// To be deleted after zig1.wasm is updated.
+    pub const unwrap_error = "attempt to unwrap error";
+    /// To be deleted after zig1.wasm is updated.
+    pub const index_out_of_bounds = "index out of bounds";
+    /// To be deleted after zig1.wasm is updated.
+    pub const start_index_greater_than_end = "start index is larger than end index";
+    /// To be deleted after zig1.wasm is updated.
+    pub const unreach = reached_unreachable;
+};
diff --git a/zig/lib/std/elf.zig b/zig/lib/std/elf.zig
index d92973c314..792694dffb 100644
--- a/zig/lib/std/elf.zig
+++ b/zig/lib/std/elf.zig
@@ -453,18 +453,27 @@ pub const ET = enum(u16) {
     /// Core file
     CORE = 4,
 
+    /// Beginning of OS-specific codes
+    pub const LOOS = 0xfe00;
+
+    /// End of OS-specific codes
+    pub const HIOS = 0xfeff;
+
     /// Beginning of processor-specific codes
     pub const LOPROC = 0xff00;
 
-    /// Processor-specific
+    /// End of processor-specific codes
     pub const HIPROC = 0xffff;
 };
 
 /// All integers are native endian.
 pub const Header = struct {
+    is_64: bool,
     endian: std.builtin.Endian,
+    os_abi: OSABI,
+    abi_version: u8,
+    type: ET,
     machine: EM,
-    is_64: bool,
     entry: u64,
     phoff: u64,
     shoff: u64,
@@ -501,6 +510,12 @@ pub const Header = struct {
         if (!mem.eql(u8, hdr32.e_ident[0..4], MAGIC)) return error.InvalidElfMagic;
         if (hdr32.e_ident[EI_VERSION] != 1) return error.InvalidElfVersion;
 
+        const is_64 = switch (hdr32.e_ident[EI_CLASS]) {
+            ELFCLASS32 => false,
+            ELFCLASS64 => true,
+            else => return error.InvalidElfClass,
+        };
+
         const endian: std.builtin.Endian = switch (hdr32.e_ident[EI_DATA]) {
             ELFDATA2LSB => .little,
             ELFDATA2MSB => .big,
@@ -508,11 +523,15 @@ pub const Header = struct {
         };
         const need_bswap = endian != native_endian;
 
-        const is_64 = switch (hdr32.e_ident[EI_CLASS]) {
-            ELFCLASS32 => false,
-            ELFCLASS64 => true,
-            else => return error.InvalidElfClass,
-        };
+        const os_abi: OSABI = @enumFromInt(hdr32.e_ident[EI_OSABI]);
+
+        // The meaning of this value depends on `os_abi` so just make it available as `u8`.
+        const abi_version = hdr32.e_ident[EI_ABIVERSION];
+
+        const @"type" = if (need_bswap) blk: {
+            const value = @intFromEnum(hdr32.e_type);
+            break :blk @as(ET, @enumFromInt(@byteSwap(value)));
+        } else hdr32.e_type;
 
         const machine = if (need_bswap) blk: {
             const value = @intFromEnum(hdr32.e_machine);
@@ -520,9 +539,12 @@ pub const Header = struct {
         } else hdr32.e_machine;
 
         return @as(Header, .{
+            .is_64 = is_64,
             .endian = endian,
+            .os_abi = os_abi,
+            .abi_version = abi_version,
+            .type = @"type",
             .machine = machine,
-            .is_64 = is_64,
             .entry = int(is_64, need_bswap, hdr32.e_entry, hdr64.e_entry),
             .phoff = int(is_64, need_bswap, hdr32.e_phoff, hdr64.e_phoff),
             .shoff = int(is_64, need_bswap, hdr32.e_shoff, hdr64.e_shoff),
@@ -637,7 +659,7 @@ pub fn SectionHeaderIterator(comptime ParseSource: anytype) type {
     };
 }
 
-pub fn int(is_64: bool, need_bswap: bool, int_32: anytype, int_64: anytype) @TypeOf(int_64) {
+fn int(is_64: bool, need_bswap: bool, int_32: anytype, int_64: anytype) @TypeOf(int_64) {
     if (is_64) {
         if (need_bswap) {
             return @byteSwap(int_64);
@@ -649,7 +671,7 @@ pub fn int(is_64: bool, need_bswap: bool, int_32: anytype, int_64: anytype) @Typ
     }
 }
 
-pub fn int32(need_bswap: bool, int_32: anytype, comptime Int64: anytype) Int64 {
+fn int32(need_bswap: bool, int_32: anytype, comptime Int64: anytype) Int64 {
     if (need_bswap) {
         return @byteSwap(int_32);
     } else {
@@ -657,21 +679,24 @@ pub fn int32(need_bswap: bool, int_32: anytype, comptime Int64: anytype) Int64 {
     }
 }
 
-pub const EI_NIDENT = 16;
-
-pub const EI_CLASS = 4;
 pub const ELFCLASSNONE = 0;
 pub const ELFCLASS32 = 1;
 pub const ELFCLASS64 = 2;
 pub const ELFCLASSNUM = 3;
 
-pub const EI_DATA = 5;
 pub const ELFDATANONE = 0;
 pub const ELFDATA2LSB = 1;
 pub const ELFDATA2MSB = 2;
 pub const ELFDATANUM = 3;
 
+pub const EI_CLASS = 4;
+pub const EI_DATA = 5;
 pub const EI_VERSION = 6;
+pub const EI_OSABI = 7;
+pub const EI_ABIVERSION = 8;
+pub const EI_PAD = 9;
+
+pub const EI_NIDENT = 16;
 
 pub const Elf32_Half = u16;
 pub const Elf64_Half = u16;
@@ -1094,6 +1119,57 @@ pub const Addr = switch (@sizeOf(usize)) {
 };
 pub const Half = u16;
 
+pub const OSABI = enum(u8) {
+    /// UNIX System V ABI
+    NONE = 0,
+    /// HP-UX operating system
+    HPUX = 1,
+    /// NetBSD
+    NETBSD = 2,
+    /// GNU (Hurd/Linux)
+    GNU = 3,
+    /// Solaris
+    SOLARIS = 6,
+    /// AIX
+    AIX = 7,
+    /// IRIX
+    IRIX = 8,
+    /// FreeBSD
+    FREEBSD = 9,
+    /// TRU64 UNIX
+    TRU64 = 10,
+    /// Novell Modesto
+    MODESTO = 11,
+    /// OpenBSD
+    OPENBSD = 12,
+    /// OpenVMS
+    OPENVMS = 13,
+    /// Hewlett-Packard Non-Stop Kernel
+    NSK = 14,
+    /// AROS
+    AROS = 15,
+    /// FenixOS
+    FENIXOS = 16,
+    /// Nuxi CloudABI
+    CLOUDABI = 17,
+    /// Stratus Technologies OpenVOS
+    OPENVOS = 18,
+    /// NVIDIA CUDA architecture
+    CUDA = 51,
+    /// AMD HSA Runtime
+    AMDGPU_HSA = 64,
+    /// AMD PAL Runtime
+    AMDGPU_PAL = 65,
+    /// AMD Mesa3D Runtime
+    AMDGPU_MESA3D = 66,
+    /// ARM
+    ARM = 97,
+    /// Standalone (embedded) application
+    STANDALONE = 255,
+
+    _,
+};
+
 /// Machine architectures.
 ///
 /// See current registered ELF machine architectures at:
@@ -1552,6 +1628,14 @@ pub const EM = enum(u16) {
     /// Adapteva's Epiphany architecture
     ADAPTEVA_EPIPHANY = 0x1223,
 
+    /// Parallax Propeller (P1)
+    /// This value is an unofficial ELF value used in: https://github.com/parallaxinc/propgcc
+    PROPELLER = 0x5072,
+
+    /// Parallax Propeller 2 (P2)
+    /// This value is an unofficial ELF value used in: https://github.com/ne75/llvm-project
+    PROPELLER2 = 300,
+
     _,
 };
 
diff --git a/zig/lib/std/fmt.zig b/zig/lib/std/fmt.zig
index 12504b6872..123122fd56 100644
--- a/zig/lib/std/fmt.zig
+++ b/zig/lib/std/fmt.zig
@@ -1197,7 +1197,7 @@ pub fn formatInt(
     if (base == 10) {
         while (a >= 100) : (a = @divTrunc(a, 100)) {
             index -= 2;
-            buf[index..][0..2].* = digits2(@as(usize, @intCast(a % 100)));
+            buf[index..][0..2].* = digits2(@intCast(a % 100));
         }
 
         if (a < 10) {
@@ -1205,13 +1205,13 @@ pub fn formatInt(
             buf[index] = '0' + @as(u8, @intCast(a));
         } else {
             index -= 2;
-            buf[index..][0..2].* = digits2(@as(usize, @intCast(a)));
+            buf[index..][0..2].* = digits2(@intCast(a));
         }
     } else {
         while (true) {
             const digit = a % base;
             index -= 1;
-            buf[index] = digitToChar(@as(u8, @intCast(digit)), case);
+            buf[index] = digitToChar(@intCast(digit), case);
             a /= base;
             if (a == 0) break;
         }
@@ -1242,11 +1242,7 @@ pub fn formatIntBuf(out_buf: []u8, value: anytype, base: u8, case: Case, options
 
 // Converts values in the range [0, 100) to a string.
 pub fn digits2(value: usize) [2]u8 {
-    return ("0001020304050607080910111213141516171819" ++
-        "2021222324252627282930313233343536373839" ++
-        "4041424344454647484950515253545556575859" ++
-        "6061626364656667686970717273747576777879" ++
-        "8081828384858687888990919293949596979899")[value * 2 ..][0..2].*;
+    return "00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899"[value * 2 ..][0..2].*;
 }
 
 const FormatDurationData = struct {
diff --git a/zig/lib/std/fs/Dir.zig b/zig/lib/std/fs/Dir.zig
index 2e84d1097f..d504ecb0c4 100644
--- a/zig/lib/std/fs/Dir.zig
+++ b/zig/lib/std/fs/Dir.zig
@@ -804,11 +804,14 @@ pub fn openFile(self: Dir, sub_path: []const u8, flags: File.OpenFlags) File.Ope
     }
     if (native_os == .wasi and !builtin.link_libc) {
         var base: std.os.wasi.rights_t = .{};
+        // POLL_FD_READWRITE only grants extra rights if the corresponding FD_READ and/or FD_WRITE
+        // is also set.
         if (flags.isRead()) {
             base.FD_READ = true;
             base.FD_TELL = true;
             base.FD_SEEK = true;
             base.FD_FILESTAT_GET = true;
+            base.POLL_FD_READWRITE = true;
         }
         if (flags.isWrite()) {
             base.FD_WRITE = true;
@@ -821,6 +824,7 @@ pub fn openFile(self: Dir, sub_path: []const u8, flags: File.OpenFlags) File.Ope
             base.FD_ADVISE = true;
             base.FD_FILESTAT_SET_TIMES = true;
             base.FD_FILESTAT_SET_SIZE = true;
+            base.POLL_FD_READWRITE = true;
         }
         const fd = try posix.openatWasi(self.fd, sub_path, .{}, .{}, .{}, base, .{});
         return .{ .handle = fd };
@@ -982,6 +986,9 @@ pub fn createFile(self: Dir, sub_path: []const u8, flags: File.CreateFlags) File
                 .FD_FILESTAT_SET_TIMES = true,
                 .FD_FILESTAT_SET_SIZE = true,
                 .FD_FILESTAT_GET = true,
+                // POLL_FD_READWRITE only grants extra rights if the corresponding FD_READ and/or
+                // FD_WRITE is also set.
+                .POLL_FD_READWRITE = true,
             }, .{}),
         };
     }
diff --git a/zig/lib/std/fs/test.zig b/zig/lib/std/fs/test.zig
index b0810f81a5..618323dce3 100644
--- a/zig/lib/std/fs/test.zig
+++ b/zig/lib/std/fs/test.zig
@@ -1647,6 +1647,36 @@ test "open file with exclusive nonblocking lock twice (absolute paths)" {
     try testing.expectError(error.WouldBlock, file2);
 }
 
+test "read from locked file" {
+    try testWithAllSupportedPathTypes(struct {
+        fn impl(ctx: *TestContext) !void {
+            const filename = try ctx.transformPath("read_lock_file_test.txt");
+
+            {
+                const f = try ctx.dir.createFile(filename, .{ .read = true });
+                defer f.close();
+                var buffer: [1]u8 = undefined;
+                _ = try f.readAll(&buffer);
+            }
+            {
+                const f = try ctx.dir.createFile(filename, .{
+                    .read = true,
+                    .lock = .exclusive,
+                });
+                defer f.close();
+                const f2 = try ctx.dir.openFile(filename, .{});
+                defer f2.close();
+                var buffer: [1]u8 = undefined;
+                if (builtin.os.tag == .windows) {
+                    try std.testing.expectError(error.LockViolation, f2.readAll(&buffer));
+                } else {
+                    try std.testing.expectEqual(0, f2.readAll(&buffer));
+                }
+            }
+        }
+    }.impl);
+}
+
 test "walker" {
     if (native_os == .wasi and builtin.link_libc) return error.SkipZigTest;
 
diff --git a/zig/lib/std/heap.zig b/zig/lib/std/heap.zig
index 18332c79a8..3d19d8daa6 100644
--- a/zig/lib/std/heap.zig
+++ b/zig/lib/std/heap.zig
@@ -501,8 +501,6 @@ pub const FixedBufferAllocator = struct {
     }
 };
 
-pub const ThreadSafeFixedBufferAllocator = @compileError("ThreadSafeFixedBufferAllocator has been replaced with `threadSafeAllocator` on FixedBufferAllocator");
-
 /// Returns a `StackFallbackAllocator` allocating using either a
 /// `FixedBufferAllocator` on an array of size `size` and falling back to
 /// `fallback_allocator` if that fails.
diff --git a/zig/lib/std/http/test.zig b/zig/lib/std/http/test.zig
index caeed0e1ea..dc944fbabb 100644
--- a/zig/lib/std/http/test.zig
+++ b/zig/lib/std/http/test.zig
@@ -230,6 +230,11 @@ test "echo content server" {
 }
 
 test "Server.Request.respondStreaming non-chunked, unknown content-length" {
+    if (builtin.os.tag == .windows) {
+        // https://github.com/ziglang/zig/issues/21457
+        return error.SkipZigTest;
+    }
+
     // In this case, the response is expected to stream until the connection is
     // closed, indicating the end of the body.
     const test_server = try createTestServer(struct {
diff --git a/zig/lib/std/io.zig b/zig/lib/std/io.zig
index 6455693d67..0a9b2bf867 100644
--- a/zig/lib/std/io.zig
+++ b/zig/lib/std/io.zig
@@ -442,6 +442,7 @@ pub fn poll(
         .overlapped = [1]windows.OVERLAPPED{
             mem.zeroes(windows.OVERLAPPED),
         } ** enum_fields.len,
+        .small_bufs = undefined,
         .active = .{
             .count = 0,
             .handles_buf = undefined,
@@ -481,6 +482,7 @@ pub fn Poller(comptime StreamEnum: type) type {
         windows: if (is_windows) struct {
             first_read_done: bool,
             overlapped: [enum_fields.len]windows.OVERLAPPED,
+            small_bufs: [enum_fields.len][128]u8,
             active: struct {
                 count: math.IntFittingRange(0, enum_fields.len),
                 handles_buf: [enum_fields.len]windows.HANDLE,
@@ -534,24 +536,31 @@ pub fn Poller(comptime StreamEnum: type) type {
             const bump_amt = 512;
 
             if (!self.windows.first_read_done) {
-                // Windows Async IO requires an initial call to ReadFile before waiting on the handle
+                var already_read_data = false;
                 for (0..enum_fields.len) |i| {
                     const handle = self.windows.active.handles_buf[i];
-                    switch (try windowsAsyncRead(
+                    switch (try windowsAsyncReadToFifoAndQueueSmallRead(
                         handle,
                         &self.windows.overlapped[i],
                         &self.fifos[i],
+                        &self.windows.small_bufs[i],
                         bump_amt,
                     )) {
-                        .pending => {
+                        .populated, .empty => |state| {
+                            if (state == .populated) already_read_data = true;
                             self.windows.active.handles_buf[self.windows.active.count] = handle;
                             self.windows.active.stream_map[self.windows.active.count] = @as(StreamEnum, @enumFromInt(i));
                             self.windows.active.count += 1;
                         },
                         .closed => {}, // don't add to the wait_objects list
+                        .closed_populated => {
+                            // don't add to the wait_objects list, but we did already get data
+                            already_read_data = true;
+                        },
                     }
                 }
                 self.windows.first_read_done = true;
+                if (already_read_data) return true;
             }
 
             while (true) {
@@ -576,32 +585,35 @@ pub fn Poller(comptime StreamEnum: type) type {
 
                 const active_idx = status - windows.WAIT_OBJECT_0;
 
-                const handle = self.windows.active.handles_buf[active_idx];
                 const stream_idx = @intFromEnum(self.windows.active.stream_map[active_idx]);
-                var read_bytes: u32 = undefined;
-                if (0 == windows.kernel32.GetOverlappedResult(
-                    handle,
-                    &self.windows.overlapped[stream_idx],
-                    &read_bytes,
-                    0,
-                )) switch (windows.GetLastError()) {
-                    .BROKEN_PIPE => {
+                const handle = self.windows.active.handles_buf[active_idx];
+
+                const overlapped = &self.windows.overlapped[stream_idx];
+                const stream_fifo = &self.fifos[stream_idx];
+                const small_buf = &self.windows.small_bufs[stream_idx];
+
+                const num_bytes_read = switch (try windowsGetReadResult(handle, overlapped, false)) {
+                    .success => |n| n,
+                    .closed => {
                         self.windows.active.removeAt(active_idx);
                         continue;
                     },
-                    else => |err| return windows.unexpectedError(err),
+                    .aborted => unreachable,
                 };
+                try stream_fifo.write(small_buf[0..num_bytes_read]);
 
-                self.fifos[stream_idx].update(read_bytes);
-
-                switch (try windowsAsyncRead(
+                switch (try windowsAsyncReadToFifoAndQueueSmallRead(
                     handle,
-                    &self.windows.overlapped[stream_idx],
-                    &self.fifos[stream_idx],
+                    overlapped,
+                    stream_fifo,
+                    small_buf,
                     bump_amt,
                 )) {
-                    .pending => {},
-                    .closed => self.windows.active.removeAt(active_idx),
+                    .empty => {}, // irrelevant, we already got data from the small buffer
+                    .populated => {},
+                    .closed,
+                    .closed_populated, // identical, since we already got data from the small buffer
+                    => self.windows.active.removeAt(active_idx),
                 }
                 return true;
             }
@@ -654,25 +666,145 @@ pub fn Poller(comptime StreamEnum: type) type {
     };
 }
 
-fn windowsAsyncRead(
+/// The `ReadFile` docuementation states that `lpNumberOfBytesRead` does not have a meaningful
+/// result when using overlapped I/O, but also that it cannot be `null` on Windows 7. For
+/// compatibility, we point it to this dummy variables, which we never otherwise access.
+/// See: https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-readfile
+var win_dummy_bytes_read: u32 = undefined;
+
+/// Read as much data as possible from `handle` with `overlapped`, and write it to the FIFO. Before
+/// returning, queue a read into `small_buf` so that `WaitForMultipleObjects` returns when more data
+/// is available. `handle` must have no pending asynchronous operation.
+fn windowsAsyncReadToFifoAndQueueSmallRead(
     handle: windows.HANDLE,
     overlapped: *windows.OVERLAPPED,
     fifo: *PollFifo,
+    small_buf: *[128]u8,
     bump_amt: usize,
-) !enum { pending, closed } {
+) !enum { empty, populated, closed_populated, closed } {
+    var read_any_data = false;
     while (true) {
-        const buf = try fifo.writableWithSize(bump_amt);
-        var read_bytes: u32 = undefined;
-        const read_result = windows.kernel32.ReadFile(handle, buf.ptr, math.cast(u32, buf.len) orelse math.maxInt(u32), &read_bytes, overlapped);
-        if (read_result == 0) return switch (windows.GetLastError()) {
-            .IO_PENDING => .pending,
-            .BROKEN_PIPE => .closed,
-            else => |err| windows.unexpectedError(err),
+        const fifo_read_pending = while (true) {
+            const buf = try fifo.writableWithSize(bump_amt);
+            const buf_len = math.cast(u32, buf.len) orelse math.maxInt(u32);
+
+            if (0 == windows.kernel32.ReadFile(
+                handle,
+                buf.ptr,
+                buf_len,
+                &win_dummy_bytes_read,
+                overlapped,
+            )) switch (windows.GetLastError()) {
+                .IO_PENDING => break true,
+                .BROKEN_PIPE => return if (read_any_data) .closed_populated else .closed,
+                else => |err| return windows.unexpectedError(err),
+            };
+
+            const num_bytes_read = switch (try windowsGetReadResult(handle, overlapped, false)) {
+                .success => |n| n,
+                .closed => return if (read_any_data) .closed_populated else .closed,
+                .aborted => unreachable,
+            };
+
+            read_any_data = true;
+            fifo.update(num_bytes_read);
+
+            if (num_bytes_read == buf_len) {
+                // We filled the buffer, so there's probably more data available.
+                continue;
+            } else {
+                // We didn't fill the buffer, so assume we're out of data.
+                // There is no pending read.
+                break false;
+            }
         };
-        fifo.update(read_bytes);
+
+        if (fifo_read_pending) cancel_read: {
+            // Cancel the pending read into the FIFO.
+            _ = windows.kernel32.CancelIo(handle);
+
+            // We have to wait for the handle to be signalled, i.e. for the cancellation to complete.
+            switch (windows.kernel32.WaitForSingleObject(handle, windows.INFINITE)) {
+                windows.WAIT_OBJECT_0 => {},
+                windows.WAIT_FAILED => return windows.unexpectedError(windows.GetLastError()),
+                else => unreachable,
+            }
+
+            // If it completed before we canceled, make sure to tell the FIFO!
+            const num_bytes_read = switch (try windowsGetReadResult(handle, overlapped, true)) {
+                .success => |n| n,
+                .closed => return if (read_any_data) .closed_populated else .closed,
+                .aborted => break :cancel_read,
+            };
+            read_any_data = true;
+            fifo.update(num_bytes_read);
+        }
+
+        // Try to queue the 1-byte read.
+        if (0 == windows.kernel32.ReadFile(
+            handle,
+            small_buf,
+            small_buf.len,
+            &win_dummy_bytes_read,
+            overlapped,
+        )) switch (windows.GetLastError()) {
+            .IO_PENDING => {
+                // 1-byte read pending as intended
+                return if (read_any_data) .populated else .empty;
+            },
+            .BROKEN_PIPE => return if (read_any_data) .closed_populated else .closed,
+            else => |err| return windows.unexpectedError(err),
+        };
+
+        // We got data back this time. Write it to the FIFO and run the main loop again.
+        const num_bytes_read = switch (try windowsGetReadResult(handle, overlapped, false)) {
+            .success => |n| n,
+            .closed => return if (read_any_data) .closed_populated else .closed,
+            .aborted => unreachable,
+        };
+        try fifo.write(small_buf[0..num_bytes_read]);
+        read_any_data = true;
     }
 }
 
+/// Simple wrapper around `GetOverlappedResult` to determine the result of a `ReadFile` operation.
+/// If `!allow_aborted`, then `aborted` is never returned (`OPERATION_ABORTED` is considered unexpected).
+///
+/// The `ReadFile` documentation states that the number of bytes read by an overlapped `ReadFile` must be determined using `GetOverlappedResult`, even if the
+/// operation immediately returns data:
+/// "Use NULL for [lpNumberOfBytesRead] if this is an asynchronous operation to avoid potentially
+/// erroneous results."
+/// "If `hFile` was opened with `FILE_FLAG_OVERLAPPED`, the following conditions are in effect: [...]
+/// The lpNumberOfBytesRead parameter should be set to NULL. Use the GetOverlappedResult function to
+/// get the actual number of bytes read."
+/// See: https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-readfile
+fn windowsGetReadResult(
+    handle: windows.HANDLE,
+    overlapped: *windows.OVERLAPPED,
+    allow_aborted: bool,
+) !union(enum) {
+    success: u32,
+    closed,
+    aborted,
+} {
+    var num_bytes_read: u32 = undefined;
+    if (0 == windows.kernel32.GetOverlappedResult(
+        handle,
+        overlapped,
+        &num_bytes_read,
+        0,
+    )) switch (windows.GetLastError()) {
+        .BROKEN_PIPE => return .closed,
+        .OPERATION_ABORTED => |err| if (allow_aborted) {
+            return .aborted;
+        } else {
+            return windows.unexpectedError(err);
+        },
+        else => |err| return windows.unexpectedError(err),
+    };
+    return .{ .success = num_bytes_read };
+}
+
 /// Given an enum, returns a struct with fields of that enum, each field
 /// representing an I/O stream for polling.
 pub fn PollFiles(comptime StreamEnum: type) type {
diff --git a/zig/lib/std/io/Reader/test.zig b/zig/lib/std/io/Reader/test.zig
index e92d1ec4db..30f0e1269c 100644
--- a/zig/lib/std/io/Reader/test.zig
+++ b/zig/lib/std/io/Reader/test.zig
@@ -1,3 +1,4 @@
+const builtin = @import("builtin");
 const std = @import("../../std.zig");
 const testing = std.testing;
 
@@ -11,7 +12,7 @@ test "Reader" {
         b = 99,
         c = 2,
         d = 3,
-    }, undefined)) == .c);
+    }, builtin.cpu.arch.endian())) == .c);
     try testing.expectError(error.EndOfStream, reader.readByte());
 }
 
diff --git a/zig/lib/std/io/buffered_reader.zig b/zig/lib/std/io/buffered_reader.zig
index ca132202a7..bcf54fb882 100644
--- a/zig/lib/std/io/buffered_reader.zig
+++ b/zig/lib/std/io/buffered_reader.zig
@@ -17,26 +17,27 @@ pub fn BufferedReader(comptime buffer_size: usize, comptime ReaderType: type) ty
         const Self = @This();
 
         pub fn read(self: *Self, dest: []u8) Error!usize {
-            var dest_index: usize = 0;
-
-            while (dest_index < dest.len) {
-                const written = @min(dest.len - dest_index, self.end - self.start);
-                @memcpy(dest[dest_index..][0..written], self.buf[self.start..][0..written]);
-                if (written == 0) {
-                    // buf empty, fill it
-                    const n = try self.unbuffered_reader.read(self.buf[0..]);
-                    if (n == 0) {
-                        // reading from the unbuffered stream returned nothing
-                        // so we have nothing left to read.
-                        return dest_index;
-                    }
-                    self.start = 0;
-                    self.end = n;
-                }
-                self.start += written;
-                dest_index += written;
+            // First try reading from the already buffered data onto the destination.
+            const current = self.buf[self.start..self.end];
+            if (current.len != 0) {
+                const to_transfer = @min(current.len, dest.len);
+                @memcpy(dest[0..to_transfer], current[0..to_transfer]);
+                self.start += to_transfer;
+                return to_transfer;
             }
-            return dest.len;
+
+            // If dest is large, read from the unbuffered reader directly into the destination.
+            if (dest.len >= buffer_size) {
+                return self.unbuffered_reader.read(dest);
+            }
+
+            // If dest is small, read from the unbuffered reader into our own internal buffer,
+            // and then transfer to destination.
+            self.end = try self.unbuffered_reader.read(&self.buf);
+            const to_transfer = @min(self.end, dest.len);
+            @memcpy(dest[0..to_transfer], self.buf[0..to_transfer]);
+            self.start = to_transfer;
+            return to_transfer;
         }
 
         pub fn reader(self: *Self) Reader {
@@ -134,12 +135,13 @@ test "Block" {
         var test_buf_reader: BufferedReader(4, BlockReader) = .{
             .unbuffered_reader = BlockReader.init(block, 2),
         };
+        const reader = test_buf_reader.reader();
         var out_buf: [4]u8 = undefined;
-        _ = try test_buf_reader.read(&out_buf);
+        _ = try reader.readAll(&out_buf);
         try testing.expectEqualSlices(u8, &out_buf, block);
-        _ = try test_buf_reader.read(&out_buf);
+        _ = try reader.readAll(&out_buf);
         try testing.expectEqualSlices(u8, &out_buf, block);
-        try testing.expectEqual(try test_buf_reader.read(&out_buf), 0);
+        try testing.expectEqual(try reader.readAll(&out_buf), 0);
     }
 
     // len out < block
@@ -147,14 +149,15 @@ test "Block" {
         var test_buf_reader: BufferedReader(4, BlockReader) = .{
             .unbuffered_reader = BlockReader.init(block, 2),
         };
+        const reader = test_buf_reader.reader();
         var out_buf: [3]u8 = undefined;
-        _ = try test_buf_reader.read(&out_buf);
+        _ = try reader.readAll(&out_buf);
         try testing.expectEqualSlices(u8, &out_buf, "012");
-        _ = try test_buf_reader.read(&out_buf);
+        _ = try reader.readAll(&out_buf);
         try testing.expectEqualSlices(u8, &out_buf, "301");
-        const n = try test_buf_reader.read(&out_buf);
+        const n = try reader.readAll(&out_buf);
         try testing.expectEqualSlices(u8, out_buf[0..n], "23");
-        try testing.expectEqual(try test_buf_reader.read(&out_buf), 0);
+        try testing.expectEqual(try reader.readAll(&out_buf), 0);
     }
 
     // len out > block
@@ -162,12 +165,13 @@ test "Block" {
         var test_buf_reader: BufferedReader(4, BlockReader) = .{
             .unbuffered_reader = BlockReader.init(block, 2),
         };
+        const reader = test_buf_reader.reader();
         var out_buf: [5]u8 = undefined;
-        _ = try test_buf_reader.read(&out_buf);
+        _ = try reader.readAll(&out_buf);
         try testing.expectEqualSlices(u8, &out_buf, "01230");
-        const n = try test_buf_reader.read(&out_buf);
+        const n = try reader.readAll(&out_buf);
         try testing.expectEqualSlices(u8, out_buf[0..n], "123");
-        try testing.expectEqual(try test_buf_reader.read(&out_buf), 0);
+        try testing.expectEqual(try reader.readAll(&out_buf), 0);
     }
 
     // len out == 0
@@ -175,8 +179,9 @@ test "Block" {
         var test_buf_reader: BufferedReader(4, BlockReader) = .{
             .unbuffered_reader = BlockReader.init(block, 2),
         };
+        const reader = test_buf_reader.reader();
         var out_buf: [0]u8 = undefined;
-        _ = try test_buf_reader.read(&out_buf);
+        _ = try reader.readAll(&out_buf);
         try testing.expectEqualSlices(u8, &out_buf, "");
     }
 
@@ -185,11 +190,12 @@ test "Block" {
         var test_buf_reader: BufferedReader(5, BlockReader) = .{
             .unbuffered_reader = BlockReader.init(block, 2),
         };
+        const reader = test_buf_reader.reader();
         var out_buf: [4]u8 = undefined;
-        _ = try test_buf_reader.read(&out_buf);
+        _ = try reader.readAll(&out_buf);
         try testing.expectEqualSlices(u8, &out_buf, block);
-        _ = try test_buf_reader.read(&out_buf);
+        _ = try reader.readAll(&out_buf);
         try testing.expectEqualSlices(u8, &out_buf, block);
-        try testing.expectEqual(try test_buf_reader.read(&out_buf), 0);
+        try testing.expectEqual(try reader.readAll(&out_buf), 0);
     }
 }
diff --git a/zig/lib/std/math/float.zig b/zig/lib/std/math/float.zig
index a10332f863..b7269b3ba9 100644
--- a/zig/lib/std/math/float.zig
+++ b/zig/lib/std/math/float.zig
@@ -172,9 +172,6 @@ test nan {
 }
 
 test snan {
-    // TODO: https://github.com/ziglang/zig/issues/14366
-    if (builtin.zig_backend == .stage2_llvm and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
-
     const snan_u16: u16 = 0x7D00;
     const snan_u32: u32 = 0x7FA00000;
     const snan_u64: u64 = 0x7FF4000000000000;
diff --git a/zig/lib/std/math/gcd.zig b/zig/lib/std/math/gcd.zig
index 36ba8e3614..16ca7846f1 100644
--- a/zig/lib/std/math/gcd.zig
+++ b/zig/lib/std/math/gcd.zig
@@ -1,41 +1,50 @@
 //! Greatest common divisor (https://mathworld.wolfram.com/GreatestCommonDivisor.html)
 const std = @import("std");
-const expectEqual = std.testing.expectEqual;
 
-/// Returns the greatest common divisor (GCD) of two unsigned integers (a and b) which are not both zero.
-/// For example, the GCD of 8 and 12 is 4, that is, gcd(8, 12) == 4.
+/// Returns the greatest common divisor (GCD) of two unsigned integers (`a` and `b`) which are not both zero.
+/// For example, the GCD of `8` and `12` is `4`, that is, `gcd(8, 12) == 4`.
 pub fn gcd(a: anytype, b: anytype) @TypeOf(a, b) {
-
-    // only unsigned integers are allowed and not both must be zero
-    comptime switch (@typeInfo(@TypeOf(a, b))) {
-        .int => |int| std.debug.assert(int.signedness == .unsigned),
-        .comptime_int => {
-            std.debug.assert(a >= 0);
-            std.debug.assert(b >= 0);
-        },
-        else => unreachable,
+    const N = switch (@TypeOf(a, b)) {
+        // convert comptime_int to some sized int type for @ctz
+        comptime_int => std.math.IntFittingRange(@min(a, b), @max(a, b)),
+        else => |T| T,
     };
+    if (@typeInfo(N) != .int or @typeInfo(N).int.signedness != .unsigned) {
+        @compileError("`a` and `b` must be usigned integers");
+    }
+
+    // using an optimised form of Stein's algorithm:
+    // https://en.wikipedia.org/wiki/Binary_GCD_algorithm
     std.debug.assert(a != 0 or b != 0);
 
-    // if one of them is zero, the other is returned
     if (a == 0) return b;
     if (b == 0) return a;
 
-    // init vars
-    var x: @TypeOf(a, b) = a;
-    var y: @TypeOf(a, b) = b;
-    var m: @TypeOf(a, b) = a;
+    var x: N = a;
+    var y: N = b;
 
-    // using the Euclidean algorithm (https://mathworld.wolfram.com/EuclideanAlgorithm.html)
-    while (y != 0) {
-        m = x % y;
-        x = y;
-        y = m;
+    const xz = @ctz(x);
+    const yz = @ctz(y);
+    const shift = @min(xz, yz);
+    x >>= @intCast(xz);
+    y >>= @intCast(yz);
+
+    var diff = y -% x;
+    while (diff != 0) : (diff = y -% x) {
+        // ctz is invariant under negation, we
+        // put it here to ease data dependencies,
+        // makes the CPU happy.
+        const zeros = @ctz(diff);
+        if (x > y) diff = -%diff;
+        y = @min(x, y);
+        x = diff >> @intCast(zeros);
     }
-    return x;
+    return y << @intCast(shift);
 }
 
-test "gcd" {
+test gcd {
+    const expectEqual = std.testing.expectEqual;
+
     try expectEqual(gcd(0, 5), 5);
     try expectEqual(gcd(5, 0), 5);
     try expectEqual(gcd(8, 12), 4);
@@ -45,4 +54,6 @@ test "gcd" {
     try expectEqual(gcd(49865, 69811), 9973);
     try expectEqual(gcd(300_000, 2_300_000), 100_000);
     try expectEqual(gcd(90000000_000_000_000_000_000, 2), 2);
+    try expectEqual(gcd(@as(u80, 90000000_000_000_000_000_000), 2), 2);
+    try expectEqual(gcd(300_000, @as(u32, 2_300_000)), 100_000);
 }
diff --git a/zig/lib/std/math/isnan.zig b/zig/lib/std/math/isnan.zig
index cb929e5890..a85100ba90 100644
--- a/zig/lib/std/math/isnan.zig
+++ b/zig/lib/std/math/isnan.zig
@@ -32,7 +32,13 @@ test isSignalNan {
         // TODO: Signalling NaN values get converted to quiet NaN values in
         //       some cases where they shouldn't such that this can fail.
         //       See https://github.com/ziglang/zig/issues/14366
-        // try expect(isSignalNan(math.snan(T)));
+        if (!builtin.cpu.arch.isArmOrThumb() and
+            !builtin.cpu.arch.isAARCH64() and
+            !builtin.cpu.arch.isPowerPC() and
+            builtin.zig_backend != .stage2_c)
+        {
+            try expect(isSignalNan(math.snan(T)));
+        }
         try expect(!isSignalNan(math.nan(T)));
         try expect(!isSignalNan(@as(T, 1.0)));
         try expect(!isSignalNan(math.inf(T)));
diff --git a/zig/lib/std/mem.zig b/zig/lib/std/mem.zig
index b4580b1aa4..d458e26989 100644
--- a/zig/lib/std/mem.zig
+++ b/zig/lib/std/mem.zig
@@ -4334,8 +4334,6 @@ pub fn alignForwardLog2(addr: usize, log2_alignment: u8) usize {
     return alignForward(usize, addr, alignment);
 }
 
-pub const alignForwardGeneric = @compileError("renamed to alignForward");
-
 /// Force an evaluation of the expression; this tries to prevent
 /// the compiler from optimizing the computation away even if the
 /// result eventually gets discarded.
@@ -4459,8 +4457,6 @@ pub fn alignBackward(comptime T: type, addr: T, alignment: T) T {
     return addr & ~(alignment - 1);
 }
 
-pub const alignBackwardGeneric = @compileError("renamed to alignBackward");
-
 /// Returns whether `alignment` is a valid alignment, meaning it is
 /// a positive power of 2.
 pub fn isValidAlign(alignment: usize) bool {
diff --git a/zig/lib/std/meta.zig b/zig/lib/std/meta.zig
index e7ea5b5f0e..ea81c87648 100644
--- a/zig/lib/std/meta.zig
+++ b/zig/lib/std/meta.zig
@@ -240,8 +240,6 @@ pub fn Sentinel(comptime T: type, comptime sentinel_val: Elem(T)) type {
     @compileError("Unable to derive a sentinel pointer type from " ++ @typeName(T));
 }
 
-pub const assumeSentinel = @compileError("This function has been removed, consider using std.mem.sliceTo() or if needed a @ptrCast()");
-
 pub fn containerLayout(comptime T: type) Type.ContainerLayout {
     return switch (@typeInfo(T)) {
         .@"struct" => |info| info.layout,
@@ -628,7 +626,7 @@ pub fn DeclEnum(comptime T: type) type {
     }
     return @Type(.{
         .@"enum" = .{
-            .tag_type = std.math.IntFittingRange(0, fieldInfos.len - 1),
+            .tag_type = std.math.IntFittingRange(0, if (fieldInfos.len == 0) 0 else fieldInfos.len - 1),
             .fields = &enumDecls,
             .decls = &decls,
             .is_exhaustive = true,
@@ -654,9 +652,12 @@ test DeclEnum {
         pub const b: void = {};
         pub const c: f32 = 0;
     };
+    const D = struct {};
+
     try expectEqualEnum(enum { a }, DeclEnum(A));
     try expectEqualEnum(enum { a, b, c }, DeclEnum(B));
     try expectEqualEnum(enum { a, b, c }, DeclEnum(C));
+    try expectEqualEnum(enum {}, DeclEnum(D));
 }
 
 pub fn Tag(comptime T: type) type {
@@ -930,8 +931,6 @@ pub fn fieldIndex(comptime T: type, comptime name: []const u8) ?comptime_int {
     return null;
 }
 
-pub const refAllDecls = @compileError("refAllDecls has been moved from std.meta to std.testing");
-
 /// Returns a slice of pointers to public declarations of a namespace.
 pub fn declList(comptime Namespace: type, comptime Decl: type) []const *const Decl {
     const S = struct {
@@ -951,8 +950,6 @@ pub fn declList(comptime Namespace: type, comptime Decl: type) []const *const De
     }
 }
 
-pub const IntType = @compileError("replaced by std.meta.Int");
-
 pub fn Int(comptime signedness: std.builtin.Signedness, comptime bit_count: u16) type {
     return @Type(.{
         .int = .{
diff --git a/zig/lib/std/os/linux.zig b/zig/lib/std/os/linux.zig
index 9039acedee..03eef2bb8e 100644
--- a/zig/lib/std/os/linux.zig
+++ b/zig/lib/std/os/linux.zig
@@ -29,16 +29,12 @@ test {
     }
 }
 
-const syscall_bits = switch (native_arch) {
-    .thumb => @import("linux/thumb.zig"),
-    else => arch_bits,
-};
-
 const arch_bits = switch (native_arch) {
     .x86 => @import("linux/x86.zig"),
     .x86_64 => @import("linux/x86_64.zig"),
-    .aarch64, .aarch64_be => @import("linux/arm64.zig"),
-    .arm, .armeb, .thumb, .thumbeb => @import("linux/arm-eabi.zig"),
+    .aarch64, .aarch64_be => @import("linux/aarch64.zig"),
+    .arm, .armeb, .thumb, .thumbeb => @import("linux/arm.zig"),
+    .hexagon => @import("linux/hexagon.zig"),
     .riscv32 => @import("linux/riscv32.zig"),
     .riscv64 => @import("linux/riscv64.zig"),
     .sparc64 => @import("linux/sparc64.zig"),
@@ -47,11 +43,15 @@ const arch_bits = switch (native_arch) {
     .mips64, .mips64el => @import("linux/mips64.zig"),
     .powerpc, .powerpcle => @import("linux/powerpc.zig"),
     .powerpc64, .powerpc64le => @import("linux/powerpc64.zig"),
+    .s390x => @import("linux/s390x.zig"),
     else => struct {
         pub const ucontext_t = void;
         pub const getcontext = {};
     },
 };
+
+const syscall_bits = if (native_arch.isThumb()) @import("linux/thumb.zig") else arch_bits;
+
 pub const syscall0 = syscall_bits.syscall0;
 pub const syscall1 = syscall_bits.syscall1;
 pub const syscall2 = syscall_bits.syscall2;
@@ -115,7 +115,7 @@ pub const user_desc = arch_bits.user_desc;
 pub const getcontext = arch_bits.getcontext;
 
 pub const tls = @import("linux/tls.zig");
-pub const pie = @import("linux/start_pie.zig");
+pub const pie = @import("linux/pie.zig");
 pub const BPF = @import("linux/bpf.zig");
 pub const IOCTL = @import("linux/ioctl.zig");
 pub const SECCOMP = @import("linux/seccomp.zig");
@@ -276,6 +276,29 @@ pub const MAP = switch (native_arch) {
         UNINITIALIZED: bool = false,
         _: u5 = 0,
     },
+    .hexagon, .s390x => packed struct(u32) {
+        TYPE: MAP_TYPE,
+        FIXED: bool = false,
+        ANONYMOUS: bool = false,
+        _4: u1 = 0,
+        _5: u1 = 0,
+        GROWSDOWN: bool = false,
+        _7: u1 = 0,
+        _8: u1 = 0,
+        DENYWRITE: bool = false,
+        EXECUTABLE: bool = false,
+        LOCKED: bool = false,
+        NORESERVE: bool = false,
+        POPULATE: bool = false,
+        NONBLOCK: bool = false,
+        STACK: bool = false,
+        HUGETLB: bool = false,
+        SYNC: bool = false,
+        FIXED_NOREPLACE: bool = false,
+        _19: u5 = 0,
+        UNINITIALIZED: bool = false,
+        _: u5 = 0,
+    },
     else => @compileError("missing std.os.linux.MAP constants for this architecture"),
 };
 
@@ -417,6 +440,32 @@ pub const O = switch (native_arch) {
         TMPFILE: bool = false,
         _: u9 = 0,
     },
+    .hexagon, .s390x => packed struct(u32) {
+        ACCMODE: ACCMODE = .RDONLY,
+        _2: u4 = 0,
+        CREAT: bool = false,
+        EXCL: bool = false,
+        NOCTTY: bool = false,
+        TRUNC: bool = false,
+        APPEND: bool = false,
+        NONBLOCK: bool = false,
+        DSYNC: bool = false,
+        ASYNC: bool = false,
+        DIRECT: bool = false,
+        LARGEFILE: bool = false,
+        DIRECTORY: bool = false,
+        NOFOLLOW: bool = false,
+        NOATIME: bool = false,
+        CLOEXEC: bool = false,
+        _17: u1 = 0,
+        PATH: bool = false,
+        _: u10 = 0,
+
+        // #define O_RSYNC    04010000
+        // #define O_SYNC     04010000
+        // #define O_TMPFILE 020200000
+        // #define O_NDELAY O_NONBLOCK
+    },
     else => @compileError("missing std.os.linux.O constants for this architecture"),
 };
 
@@ -854,7 +903,19 @@ pub fn mmap(address: ?[*]u8, length: usize, prot: usize, flags: MAP, fd: i32, of
             @truncate(@as(u64, @bitCast(offset)) / MMAP2_UNIT),
         );
     } else {
-        return syscall6(
+        // The s390x mmap() syscall existed before Linux supported syscalls with 5+ parameters, so
+        // it takes a single pointer to an array of arguments instead.
+        return if (native_arch == .s390x) syscall1(
+            .mmap,
+            @intFromPtr(&[_]usize{
+                @intFromPtr(address),
+                length,
+                prot,
+                @as(u32, @bitCast(flags)),
+                @bitCast(@as(isize, fd)),
+                @as(u64, @bitCast(offset)),
+            }),
+        ) else syscall6(
             .mmap,
             @intFromPtr(address),
             length,
@@ -6501,12 +6562,12 @@ pub const tc_oflag_t = if (is_ppc) packed struct(tcflag_t) {
     ONLRET: bool = false,
     OFILL: bool = false,
     OFDEL: bool = false,
-    NLDLY: NLDLY = 0,
-    TABDLY: TABDLY = 0,
-    CRDLY: CRDLY = 0,
-    FFDLY: FFDLY = 0,
-    BSDLY: BSDLY = 0,
-    VTDLY: VTDLY = 0,
+    NLDLY: NLDLY = .NL0,
+    TABDLY: TABDLY = .TAB0,
+    CRDLY: CRDLY = .CR0,
+    FFDLY: FFDLY = .FF0,
+    BSDLY: BSDLY = .BS0,
+    VTDLY: VTDLY = .VT0,
     _17: u15 = 0,
 } else if (is_sparc) packed struct(tcflag_t) {
     OPOST: bool = false,
@@ -8014,11 +8075,33 @@ pub const rtattr = extern struct {
     len: c_ushort,
 
     /// Type of option
-    type: IFLA,
+    type: extern union {
+        /// IFLA_* from linux/if_link.h
+        link: IFLA,
+        /// IFA_* from linux/if_addr.h
+        addr: IFA,
+    },
 
     pub const ALIGNTO = 4;
 };
 
+pub const IFA = enum(c_ushort) {
+    UNSPEC,
+    ADDRESS,
+    LOCAL,
+    LABEL,
+    BROADCAST,
+    ANYCAST,
+    CACHEINFO,
+    MULTICAST,
+    FLAGS,
+    RT_PRIORITY,
+    TARGET_NETNSID,
+    PROTO,
+
+    _,
+};
+
 pub const IFLA = enum(c_ushort) {
     UNSPEC,
     ADDRESS,
diff --git a/zig/lib/std/os/linux/IoUring.zig b/zig/lib/std/os/linux/IoUring.zig
index c7717524a9..731877e5ae 100644
--- a/zig/lib/std/os/linux/IoUring.zig
+++ b/zig/lib/std/os/linux/IoUring.zig
@@ -3886,7 +3886,13 @@ inline fn skipKernelLessThan(required: std.SemanticVersion) !void {
     }
 
     const release = mem.sliceTo(&uts.release, 0);
-    var current = try std.SemanticVersion.parse(release);
+    // Strips potential extra, as kernel version might not be semver compliant, example "6.8.9-300.fc40.x86_64"
+    const extra_index = std.mem.indexOfAny(u8, release, "-+");
+    const stripped = release[0..(extra_index orelse release.len)];
+    // Make sure the input don't rely on the extra we just stripped
+    try testing.expect(required.pre == null and required.build == null);
+
+    var current = try std.SemanticVersion.parse(stripped);
     current.pre = null; // don't check pre field
     if (required.order(current) == .gt) return error.SkipZigTest;
 }
diff --git a/zig/lib/std/os/linux/arm64.zig b/zig/lib/std/os/linux/aarch64.zig
similarity index 100%
rename from zig/lib/std/os/linux/arm64.zig
rename to zig/lib/std/os/linux/aarch64.zig
diff --git a/zig/lib/std/os/linux/arm-eabi.zig b/zig/lib/std/os/linux/arm.zig
similarity index 100%
rename from zig/lib/std/os/linux/arm-eabi.zig
rename to zig/lib/std/os/linux/arm.zig
diff --git a/zig/lib/std/os/linux/hexagon.zig b/zig/lib/std/os/linux/hexagon.zig
new file mode 100644
index 0000000000..e9bf9ab57c
--- /dev/null
+++ b/zig/lib/std/os/linux/hexagon.zig
@@ -0,0 +1,254 @@
+const std = @import("../../std.zig");
+const iovec = std.posix.iovec;
+const iovec_const = std.posix.iovec_const;
+const linux = std.os.linux;
+const SYS = linux.SYS;
+const uid_t = std.os.linux.uid_t;
+const gid_t = std.os.linux.gid_t;
+const pid_t = std.os.linux.pid_t;
+const sockaddr = linux.sockaddr;
+const socklen_t = linux.socklen_t;
+const timespec = std.os.linux.timespec;
+
+pub fn syscall0(number: SYS) usize {
+    return asm volatile ("trap0(#1)"
+        : [ret] "={r0}" (-> usize),
+        : [number] "{r6}" (@intFromEnum(number)),
+        : "memory"
+    );
+}
+
+pub fn syscall1(number: SYS, arg1: usize) usize {
+    return asm volatile ("trap0(#1)"
+        : [ret] "={r0}" (-> usize),
+        : [number] "{r6}" (@intFromEnum(number)),
+          [arg1] "{r0}" (arg1),
+        : "memory"
+    );
+}
+
+pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
+    return asm volatile ("trap0(#1)"
+        : [ret] "={r0}" (-> usize),
+        : [number] "{r6}" (@intFromEnum(number)),
+          [arg1] "{r0}" (arg1),
+          [arg2] "{r1}" (arg2),
+        : "memory"
+    );
+}
+
+pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
+    return asm volatile ("trap0(#1)"
+        : [ret] "={r0}" (-> usize),
+        : [number] "{r6}" (@intFromEnum(number)),
+          [arg1] "{r0}" (arg1),
+          [arg2] "{r1}" (arg2),
+          [arg3] "{r2}" (arg3),
+        : "memory"
+    );
+}
+
+pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
+    return asm volatile ("trap0(#1)"
+        : [ret] "={r0}" (-> usize),
+        : [number] "{r6}" (@intFromEnum(number)),
+          [arg1] "{r0}" (arg1),
+          [arg2] "{r1}" (arg2),
+          [arg3] "{r2}" (arg3),
+          [arg4] "{r3}" (arg4),
+        : "memory"
+    );
+}
+
+pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
+    return asm volatile ("trap0(#1)"
+        : [ret] "={r0}" (-> usize),
+        : [number] "{r6}" (@intFromEnum(number)),
+          [arg1] "{r0}" (arg1),
+          [arg2] "{r1}" (arg2),
+          [arg3] "{r2}" (arg3),
+          [arg4] "{r3}" (arg4),
+          [arg5] "{r4}" (arg5),
+        : "memory"
+    );
+}
+
+pub fn syscall6(
+    number: SYS,
+    arg1: usize,
+    arg2: usize,
+    arg3: usize,
+    arg4: usize,
+    arg5: usize,
+    arg6: usize,
+) usize {
+    return asm volatile ("trap0(#1)"
+        : [ret] "={r0}" (-> usize),
+        : [number] "{r6}" (@intFromEnum(number)),
+          [arg1] "{r0}" (arg1),
+          [arg2] "{r1}" (arg2),
+          [arg3] "{r2}" (arg3),
+          [arg4] "{r3}" (arg4),
+          [arg5] "{r4}" (arg5),
+          [arg6] "{r5}" (arg6),
+        : "memory"
+    );
+}
+
+pub fn clone() callconv(.Naked) usize {
+    // __clone(func, stack, flags, arg, ptid, tls, ctid)
+    //         r0,   r1,    r2,    r3,  r4,   r5,  +0
+    //
+    // syscall(SYS_clone, flags, stack, ptid, ctid, tls)
+    //         r6         r0,    r1,    r2,   r3,   r4
+    asm volatile (
+        \\ allocframe(#8)
+        \\
+        \\ r11 = r0
+        \\ r10 = r3
+        \\
+        \\ r6 = #220 // SYS_clone
+        \\ r0 = r2
+        \\ r1 = and(r1, #-8)
+        \\ r2 = r4
+        \\ r3 = memw(r30 + #8)
+        \\ r4 = r5
+        \\ trap0(#1)
+        \\
+        \\ p0 = cmp.eq(r0, #0)
+        \\ if (!p0) dealloc_return
+        \\
+        \\ r0 = r10
+        \\ callr r11
+        \\
+        \\ r6 = #93 // SYS_exit
+        \\ r0 = #0
+        \\ trap0(#1)
+    );
+}
+
+pub const restore = restore_rt;
+
+pub fn restore_rt() callconv(.Naked) noreturn {
+    asm volatile (
+        \\ trap0(#0)
+        :
+        : [number] "{r6}" (@intFromEnum(SYS.rt_sigreturn)),
+        : "memory"
+    );
+}
+
+pub const F = struct {
+    pub const DUPFD = 0;
+    pub const GETFD = 1;
+    pub const SETFD = 2;
+    pub const GETFL = 3;
+    pub const SETFL = 4;
+    pub const GETLK = 5;
+    pub const SETLK = 6;
+    pub const SETLKW = 7;
+    pub const SETOWN = 8;
+    pub const GETOWN = 9;
+    pub const SETSIG = 10;
+    pub const GETSIG = 11;
+
+    pub const RDLCK = 0;
+    pub const WRLCK = 1;
+    pub const UNLCK = 2;
+
+    pub const SETOWN_EX = 15;
+    pub const GETOWN_EX = 16;
+
+    pub const GETOWNER_UIDS = 17;
+};
+
+pub const timeval = extern struct {
+    sec: time_t,
+    usec: i32,
+};
+
+pub const Flock = extern struct {
+    type: i16,
+    whence: i16,
+    start: off_t,
+    len: off_t,
+    pid: pid_t,
+    __unused: [4]u8,
+};
+
+pub const msghdr = extern struct {
+    name: ?*sockaddr,
+    namelen: socklen_t,
+    iov: [*]iovec,
+    iovlen: i32,
+    __pad1: i32 = 0,
+    control: ?*anyopaque,
+    controllen: socklen_t,
+    __pad2: socklen_t = 0,
+    flags: i32,
+};
+
+pub const msghdr_const = extern struct {
+    name: ?*const sockaddr,
+    namelen: socklen_t,
+    iov: [*]const iovec_const,
+    iovlen: i32,
+    __pad1: i32 = 0,
+    control: ?*const anyopaque,
+    controllen: socklen_t,
+    __pad2: socklen_t = 0,
+    flags: i32,
+};
+
+pub const blksize_t = i32;
+pub const nlink_t = u32;
+pub const time_t = i32;
+pub const mode_t = u32;
+pub const off_t = i64;
+pub const ino_t = u64;
+pub const dev_t = u64;
+pub const blkcnt_t = i64;
+
+// The `stat` definition used by the Linux kernel.
+pub const Stat = extern struct {
+    dev: dev_t,
+    ino: ino_t,
+    mode: mode_t,
+    nlink: nlink_t,
+    uid: uid_t,
+    gid: gid_t,
+    rdev: dev_t,
+    __pad: u32,
+    size: off_t,
+    blksize: blksize_t,
+    __pad2: i32,
+    blocks: blkcnt_t,
+    atim: timespec,
+    mtim: timespec,
+    ctim: timespec,
+    __unused: [2]u32,
+
+    pub fn atime(self: @This()) timespec {
+        return self.atim;
+    }
+
+    pub fn mtime(self: @This()) timespec {
+        return self.mtim;
+    }
+
+    pub fn ctime(self: @This()) timespec {
+        return self.ctim;
+    }
+};
+
+pub const Elf_Symndx = u32;
+
+pub const MMAP2_UNIT = 4096;
+
+pub const VDSO = void;
+
+/// TODO
+pub const ucontext_t = void;
+
+/// TODO
+pub const getcontext = {};
diff --git a/zig/lib/std/os/linux/start_pie.zig b/zig/lib/std/os/linux/pie.zig
similarity index 100%
rename from zig/lib/std/os/linux/start_pie.zig
rename to zig/lib/std/os/linux/pie.zig
diff --git a/zig/lib/std/os/linux/powerpc64.zig b/zig/lib/std/os/linux/powerpc64.zig
index 04936a113d..06b67c17f1 100644
--- a/zig/lib/std/os/linux/powerpc64.zig
+++ b/zig/lib/std/os/linux/powerpc64.zig
@@ -48,7 +48,7 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
         : [number] "{r0}" (@intFromEnum(number)),
           [arg1] "{r3}" (arg1),
           [arg2] "{r4}" (arg2),
-        : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
+        : "memory", "cr0", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
     );
 }
 
@@ -63,7 +63,7 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
           [arg1] "{r3}" (arg1),
           [arg2] "{r4}" (arg2),
           [arg3] "{r5}" (arg3),
-        : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
+        : "memory", "cr0", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
     );
 }
 
@@ -79,7 +79,7 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
           [arg2] "{r4}" (arg2),
           [arg3] "{r5}" (arg3),
           [arg4] "{r6}" (arg4),
-        : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
+        : "memory", "cr0", "r7", "r8", "r9", "r10", "r11", "r12"
     );
 }
 
@@ -96,7 +96,7 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
           [arg3] "{r5}" (arg3),
           [arg4] "{r6}" (arg4),
           [arg5] "{r7}" (arg5),
-        : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
+        : "memory", "cr0", "r8", "r9", "r10", "r11", "r12"
     );
 }
 
@@ -122,7 +122,7 @@ pub fn syscall6(
           [arg4] "{r6}" (arg4),
           [arg5] "{r7}" (arg5),
           [arg6] "{r8}" (arg6),
-        : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
+        : "memory", "cr0", "r9", "r10", "r11", "r12"
     );
 }
 
diff --git a/zig/lib/std/os/linux/s390x.zig b/zig/lib/std/os/linux/s390x.zig
new file mode 100644
index 0000000000..efc48af4ff
--- /dev/null
+++ b/zig/lib/std/os/linux/s390x.zig
@@ -0,0 +1,276 @@
+const std = @import("../../std.zig");
+const iovec = std.posix.iovec;
+const iovec_const = std.posix.iovec_const;
+const linux = std.os.linux;
+const SYS = linux.SYS;
+const uid_t = std.os.linux.uid_t;
+const gid_t = std.os.linux.gid_t;
+const pid_t = std.os.linux.pid_t;
+const sockaddr = linux.sockaddr;
+const socklen_t = linux.socklen_t;
+const timespec = std.os.linux.timespec;
+const stack_t = std.os.linux.stack_t;
+const sigset_t = std.os.linux.sigset_t;
+
+pub fn syscall0(number: SYS) usize {
+    return asm volatile ("svc 0"
+        : [ret] "={r2}" (-> usize),
+        : [number] "{r1}" (@intFromEnum(number)),
+        : "memory"
+    );
+}
+
+pub fn syscall1(number: SYS, arg1: usize) usize {
+    return asm volatile ("svc 0"
+        : [ret] "={r2}" (-> usize),
+        : [number] "{r1}" (@intFromEnum(number)),
+          [arg1] "{r2}" (arg1),
+        : "memory"
+    );
+}
+
+pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
+    return asm volatile ("svc 0"
+        : [ret] "={r2}" (-> usize),
+        : [number] "{r1}" (@intFromEnum(number)),
+          [arg1] "{r2}" (arg1),
+          [arg2] "{r3}" (arg2),
+        : "memory"
+    );
+}
+
+pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
+    return asm volatile ("svc 0"
+        : [ret] "={r2}" (-> usize),
+        : [number] "{r1}" (@intFromEnum(number)),
+          [arg1] "{r2}" (arg1),
+          [arg2] "{r3}" (arg2),
+          [arg3] "{r4}" (arg3),
+        : "memory"
+    );
+}
+
+pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
+    return asm volatile ("svc 0"
+        : [ret] "={r2}" (-> usize),
+        : [number] "{r1}" (@intFromEnum(number)),
+          [arg1] "{r2}" (arg1),
+          [arg2] "{r3}" (arg2),
+          [arg3] "{r4}" (arg3),
+          [arg4] "{r5}" (arg4),
+        : "memory"
+    );
+}
+
+pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
+    return asm volatile ("svc 0"
+        : [ret] "={r2}" (-> usize),
+        : [number] "{r1}" (@intFromEnum(number)),
+          [arg1] "{r2}" (arg1),
+          [arg2] "{r3}" (arg2),
+          [arg3] "{r4}" (arg3),
+          [arg4] "{r5}" (arg4),
+          [arg5] "{r6}" (arg5),
+        : "memory"
+    );
+}
+
+pub fn syscall6(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize, arg6: usize) usize {
+    return asm volatile ("svc 0"
+        : [ret] "={r2}" (-> usize),
+        : [number] "{r1}" (@intFromEnum(number)),
+          [arg1] "{r2}" (arg1),
+          [arg2] "{r3}" (arg2),
+          [arg3] "{r4}" (arg3),
+          [arg4] "{r5}" (arg4),
+          [arg5] "{r6}" (arg5),
+          [arg6] "{r7}" (arg6),
+        : "memory"
+    );
+}
+
+pub fn clone() callconv(.Naked) usize {
+    asm volatile (
+        \\# int clone(
+        \\#    fn,      a = r2
+        \\#    stack,   b = r3
+        \\#    flags,   c = r4
+        \\#    arg,     d = r5
+        \\#    ptid,    e = r6
+        \\#    tls,     f = *(r15+160)
+        \\#    ctid)    g = *(r15+168)
+        \\#
+        \\# pseudo C code:
+        \\# tid = syscall(SYS_clone,b,c,e,g,f);
+        \\# if (!tid) syscall(SYS_exit, a(d));
+        \\# return tid;
+        \\
+        \\# preserve call-saved register used as syscall arg
+        \\stg  %%r6, 48(%%r15)
+        \\
+        \\# create initial stack frame for new thread
+        \\nill %%r3, 0xfff8
+        \\aghi %%r3, -160
+        \\lghi %%r0, 0
+        \\stg  %%r0, 0(%%r3)
+        \\
+        \\# save fn and arg to child stack
+        \\stg  %%r2,  8(%%r3)
+        \\stg  %%r5, 16(%%r3)
+        \\
+        \\# shuffle args into correct registers and call SYS_clone
+        \\lgr  %%r2, %%r3
+        \\lgr  %%r3, %%r4
+        \\lgr  %%r4, %%r6
+        \\lg   %%r5, 168(%%r15)
+        \\lg   %%r6, 160(%%r15)
+        \\svc  120
+        \\
+        \\# restore call-saved register
+        \\lg   %%r6, 48(%%r15)
+        \\
+        \\# if error or if we're the parent, return
+        \\ltgr %%r2, %%r2
+        \\bnzr %%r14
+        \\
+        \\# we're the child. call fn(arg)
+        \\lg   %%r1,  8(%%r15)
+        \\lg   %%r2, 16(%%r15)
+        \\basr %%r14, %%r1
+        \\
+        \\# call SYS_exit. exit code is already in r2 from fn return value
+        \\svc  1
+        \\
+    );
+}
+
+pub const restore = restore_rt;
+
+pub fn restore_rt() callconv(.Naked) noreturn {
+    asm volatile (
+        \\svc 0
+        :
+        : [number] "{r1}" (@intFromEnum(SYS.rt_sigreturn)),
+        : "memory"
+    );
+}
+
+pub const F = struct {
+    pub const DUPFD = 0;
+    pub const GETFD = 1;
+    pub const SETFD = 2;
+    pub const GETFL = 3;
+    pub const SETFL = 4;
+    pub const GETLK = 5;
+    pub const SETLK = 6;
+    pub const SETLKW = 7;
+    pub const SETOWN = 8;
+    pub const GETOWN = 9;
+    pub const SETSIG = 10;
+    pub const GETSIG = 11;
+
+    pub const SETOWN_EX = 15;
+    pub const GETOWN_EX = 16;
+
+    pub const GETOWNER_UIDS = 17;
+};
+
+pub const blksize_t = i64;
+pub const nlink_t = u64;
+pub const time_t = i64;
+pub const mode_t = u32;
+pub const off_t = i64;
+pub const ino_t = u64;
+pub const dev_t = u64;
+pub const blkcnt_t = i64;
+
+pub const timeval = extern struct {
+    sec: time_t,
+    usec: i64,
+};
+
+pub const Flock = extern struct {
+    type: i16,
+    whence: i16,
+    start: off_t,
+    len: off_t,
+    pid: pid_t,
+};
+
+pub const msghdr = extern struct {
+    name: ?*sockaddr,
+    namelen: socklen_t,
+    iov: [*]iovec,
+    __pad1: i32 = 0,
+    iovlen: i32,
+    control: ?*anyopaque,
+    __pad2: i32 = 0,
+    controllen: socklen_t,
+    flags: i32,
+};
+
+pub const msghdr_const = extern struct {
+    name: ?*const sockaddr,
+    namelen: socklen_t,
+    iov: [*]const iovec_const,
+    __pad1: i32 = 0,
+    iovlen: i32,
+    control: ?*const anyopaque,
+    __pad2: i32 = 0,
+    controllen: socklen_t,
+    flags: i32,
+};
+
+// The `stat` definition used by the Linux kernel.
+pub const Stat = extern struct {
+    dev: dev_t,
+    ino: ino_t,
+    nlink: nlink_t,
+    mode: mode_t,
+    uid: uid_t,
+    gid: gid_t,
+    rdev: dev_t,
+    size: off_t,
+    atim: timespec,
+    mtim: timespec,
+    ctim: timespec,
+    blksize: blksize_t,
+    blocks: blkcnt_t,
+    __unused: [3]c_ulong,
+
+    pub fn atime(self: @This()) timespec {
+        return self.atim;
+    }
+
+    pub fn mtime(self: @This()) timespec {
+        return self.mtim;
+    }
+
+    pub fn ctime(self: @This()) timespec {
+        return self.ctim;
+    }
+};
+
+pub const Elf_Symndx = u64;
+
+pub const VDSO = struct {
+    pub const CGT_SYM = "__kernel_clock_gettime";
+    pub const CGT_VER = "LINUX_2.6.29";
+};
+
+pub const ucontext_t = extern struct {
+    flags: u64,
+    link: ?*ucontext_t,
+    stack: stack_t,
+    mcontext: mcontext_t,
+    sigmask: sigset_t,
+};
+
+pub const mcontext_t = extern struct {
+    __regs1: [18]u64,
+    __regs2: [18]u32,
+    __regs3: [16]f64,
+};
+
+/// TODO
+pub const getcontext = {};
diff --git a/zig/lib/std/os/linux/syscalls.zig b/zig/lib/std/os/linux/syscalls.zig
index d08a77b47c..ef04387ea6 100644
--- a/zig/lib/std/os/linux/syscalls.zig
+++ b/zig/lib/std/os/linux/syscalls.zig
@@ -6852,7 +6852,7 @@ pub const Arc = enum(usize) {
     keyctl = 219,
     clone = 220,
     execve = 221,
-    mmap_pgoff = 222,
+    mmap2 = 222,
     fadvise64_64 = 223,
     swapon = 224,
     swapoff = 225,
@@ -7538,7 +7538,7 @@ pub const Hexagon = enum(usize) {
     keyctl = 219,
     clone = 220,
     execve = 221,
-    mmap_pgoff = 222,
+    mmap2 = 222,
     fadvise64_64 = 223,
     swapon = 224,
     swapoff = 225,
diff --git a/zig/lib/std/os/linux/thumb.zig b/zig/lib/std/os/linux/thumb.zig
index baaf130578..a464030858 100644
--- a/zig/lib/std/os/linux/thumb.zig
+++ b/zig/lib/std/os/linux/thumb.zig
@@ -141,7 +141,7 @@ pub fn syscall6(
     );
 }
 
-pub const clone = @import("arm-eabi.zig").clone;
+pub const clone = @import("arm.zig").clone;
 
 pub fn restore() callconv(.Naked) noreturn {
     asm volatile (
diff --git a/zig/lib/std/os/linux/tls.zig b/zig/lib/std/os/linux/tls.zig
index 7dab38024c..d1292e86dd 100644
--- a/zig/lib/std/os/linux/tls.zig
+++ b/zig/lib/std/os/linux/tls.zig
@@ -541,7 +541,19 @@ inline fn mmap(address: ?[*]u8, length: usize, prot: usize, flags: linux.MAP, fd
             @as(usize, @truncate(@as(u64, @bitCast(offset)) / linux.MMAP2_UNIT)),
         });
     } else {
-        return @call(.always_inline, linux.syscall6, .{
+        // The s390x mmap() syscall existed before Linux supported syscalls with 5+ parameters, so
+        // it takes a single pointer to an array of arguments instead.
+        return if (native_arch == .s390x) @call(.always_inline, linux.syscall1, .{
+            .mmap,
+            @intFromPtr(&[_]usize{
+                @intFromPtr(address),
+                length,
+                prot,
+                @as(u32, @bitCast(flags)),
+                @as(usize, @bitCast(@as(isize, fd))),
+                @as(u64, @bitCast(offset)),
+            }),
+        }) else @call(.always_inline, linux.syscall6, .{
             .mmap,
             @intFromPtr(address),
             length,
diff --git a/zig/lib/std/os/uefi/pool_allocator.zig b/zig/lib/std/os/uefi/pool_allocator.zig
index aa9798c6e5..f7962f22aa 100644
--- a/zig/lib/std/os/uefi/pool_allocator.zig
+++ b/zig/lib/std/os/uefi/pool_allocator.zig
@@ -48,11 +48,9 @@ const UefiPoolAllocator = struct {
         ret_addr: usize,
     ) bool {
         _ = ret_addr;
+        _ = log2_old_ptr_align;
 
         if (new_len > buf.len) return false;
-
-        _ = mem.alignAllocLen(buf.len, new_len, log2_old_ptr_align);
-
         return true;
     }
 
@@ -121,9 +119,6 @@ fn uefi_resize(
     std.debug.assert(log2_old_ptr_align <= 3);
 
     if (new_len > buf.len) return false;
-
-    _ = mem.alignAllocLen(buf.len, new_len, 8);
-
     return true;
 }
 
diff --git a/zig/lib/std/os/wasi.zig b/zig/lib/std/os/wasi.zig
index 2c7d0d3272..5ffde3c1f6 100644
--- a/zig/lib/std/os/wasi.zig
+++ b/zig/lib/std/os/wasi.zig
@@ -315,35 +315,77 @@ pub const SOCK = struct {
 };
 
 pub const rights_t = packed struct(u64) {
+    /// The right to invoke fd_datasync. If PATH_OPEN is set, includes the right to invoke
+    /// path_open with fdflags_t.dsync.
     FD_DATASYNC: bool = false,
+    /// The right to invoke fd_read and sock_recv. If FD_SEEK is set, includes the right to invoke
+    /// fd_pread.
     FD_READ: bool = false,
+    /// The right to invoke fd_seek. This flag implies FD_TELL.
     FD_SEEK: bool = false,
+    /// The right to invoke fd_fdstat_set_flags.
     FD_FDSTAT_SET_FLAGS: bool = false,
+    /// The right to invoke fd_sync. If PATH_OPEN is set, includes the right to invoke path_open
+    /// with fdflags_t.RSYNC and fdflags_t.DSYNC.
     FD_SYNC: bool = false,
+    /// The right to invoke fd_seek in such a way that the file offset remains unaltered (i.e.
+    /// whence_t.CUR with offset zero), or to invoke fd_tell.
     FD_TELL: bool = false,
+    /// The right to invoke fd_write and sock_send. If FD_SEEK is set, includes the right to invoke
+    /// fd_pwrite.
     FD_WRITE: bool = false,
+    /// The right to invoke fd_advise.
     FD_ADVISE: bool = false,
+    /// The right to invoke fd_allocate.
     FD_ALLOCATE: bool = false,
+    /// The right to invoke path_create_directory.
     PATH_CREATE_DIRECTORY: bool = false,
+    /// If PATH_OPEN is set, the right to invoke path_open with oflags_t.CREAT.
     PATH_CREATE_FILE: bool = false,
+    /// The right to invoke path_link with the file descriptor as the source directory.
     PATH_LINK_SOURCE: bool = false,
+    /// The right to invoke path_link with the file descriptor as the target directory.
     PATH_LINK_TARGET: bool = false,
+    /// The right to invoke path_open.
     PATH_OPEN: bool = false,
+    /// The right to invoke fd_readdir.
     FD_READDIR: bool = false,
+    /// The right to invoke path_readlink.
     PATH_READLINK: bool = false,
+    /// The right to invoke path_rename with the file descriptor as the source directory.
     PATH_RENAME_SOURCE: bool = false,
+    /// The right to invoke path_rename with the file descriptor as the target directory.
     PATH_RENAME_TARGET: bool = false,
+    /// The right to invoke path_filestat_get.
     PATH_FILESTAT_GET: bool = false,
+    /// The right to change a file's size. If PATH_OPEN is set, includes the right to invoke
+    /// path_open with oflags_t.TRUNC. Note: there is no function named path_filestat_set_size.
+    /// This follows POSIX design, which only has ftruncate and does not provide ftruncateat. While
+    /// such function would be desirable from the API design perspective, there are virtually no
+    /// use cases for it since no code written for POSIX systems would use it. Moreover,
+    /// implementing it would require multiple syscalls, leading to inferior performance.
     PATH_FILESTAT_SET_SIZE: bool = false,
+    /// The right to invoke path_filestat_set_times.
     PATH_FILESTAT_SET_TIMES: bool = false,
+    /// The right to invoke fd_filestat_get.
     FD_FILESTAT_GET: bool = false,
+    /// The right to invoke fd_filestat_set_size.
     FD_FILESTAT_SET_SIZE: bool = false,
+    /// The right to invoke fd_filestat_set_times.
     FD_FILESTAT_SET_TIMES: bool = false,
+    /// The right to invoke path_symlink.
     PATH_SYMLINK: bool = false,
+    /// The right to invoke path_remove_directory.
     PATH_REMOVE_DIRECTORY: bool = false,
+    /// The right to invoke path_unlink_file.
     PATH_UNLINK_FILE: bool = false,
+    /// If FD_READ is set, includes the right to invoke poll_oneoff to subscribe to
+    /// eventtype_t.FD_READ. If FD_WRITE is set, includes the right to invoke poll_oneoff to
+    /// subscribe to eventtype_t.FD_WRITE.
     POLL_FD_READWRITE: bool = false,
+    /// The right to invoke sock_shutdown.
     SOCK_SHUTDOWN: bool = false,
+    /// The right to invoke sock_accept.
     SOCK_ACCEPT: bool = false,
     _: u34 = 0,
 };
diff --git a/zig/lib/std/os/windows.zig b/zig/lib/std/os/windows.zig
index d277361352..7f4d3290dc 100644
--- a/zig/lib/std/os/windows.zig
+++ b/zig/lib/std/os/windows.zig
@@ -599,6 +599,8 @@ pub const ReadFileError = error{
     /// The specified network name is no longer available.
     ConnectionResetByPeer,
     OperationAborted,
+    /// Unable to read file due to lock.
+    LockViolation,
     Unexpected,
 };
 
@@ -630,6 +632,7 @@ pub fn ReadFile(in_hFile: HANDLE, buffer: []u8, offset: ?u64) ReadFileError!usiz
                 .BROKEN_PIPE => return 0,
                 .HANDLE_EOF => return 0,
                 .NETNAME_DELETED => return error.ConnectionResetByPeer,
+                .LOCK_VIOLATION => return error.LockViolation,
                 else => |err| return unexpectedError(err),
             }
         }
diff --git a/zig/lib/std/os/windows/tls.zig b/zig/lib/std/os/windows/tls.zig
index f98e22b620..4723b31011 100644
--- a/zig/lib/std/os/windows/tls.zig
+++ b/zig/lib/std/os/windows/tls.zig
@@ -9,7 +9,7 @@ export var __xl_a: windows.PIMAGE_TLS_CALLBACK linksection(".CRT$XLA") = null;
 export var __xl_z: windows.PIMAGE_TLS_CALLBACK linksection(".CRT$XLZ") = null;
 
 comptime {
-    if (builtin.cpu.arch == .x86 and builtin.abi == .msvc and builtin.zig_backend != .stage2_c) {
+    if (builtin.cpu.arch == .x86 and !builtin.abi.isGnu() and builtin.zig_backend != .stage2_c) {
         // The __tls_array is the offset of the ThreadLocalStoragePointer field
         // in the TEB block whose base address held in the %fs segment.
         asm (
diff --git a/zig/lib/std/posix.zig b/zig/lib/std/posix.zig
index 94b37a0878..bb21a79690 100644
--- a/zig/lib/std/posix.zig
+++ b/zig/lib/std/posix.zig
@@ -798,6 +798,13 @@ pub const ReadError = error{
     /// In WASI, this error occurs when the file descriptor does
     /// not hold the required rights to read from it.
     AccessDenied,
+
+    /// This error occurs in Linux if the process to be read from
+    /// no longer exists.
+    ProcessNotFound,
+
+    /// Unable to read file due to lock.
+    LockViolation,
 } || UnexpectedError;
 
 /// Returns the number of bytes that were read, which can be less than
@@ -854,6 +861,7 @@ pub fn read(fd: fd_t, buf: []u8) ReadError!usize {
             .INTR => continue,
             .INVAL => unreachable,
             .FAULT => unreachable,
+            .NOENT => return error.ProcessNotFound,
             .AGAIN => return error.WouldBlock,
             .CANCELED => return error.Canceled,
             .BADF => return error.NotOpenForReading, // Can be a race condition.
@@ -917,6 +925,7 @@ pub fn readv(fd: fd_t, iov: []const iovec) ReadError!usize {
             .INTR => continue,
             .INVAL => unreachable,
             .FAULT => unreachable,
+            .NOENT => return error.ProcessNotFound,
             .AGAIN => return error.WouldBlock,
             .BADF => return error.NotOpenForReading, // can be a race condition
             .IO => return error.InputOutput,
@@ -996,6 +1005,7 @@ pub fn pread(fd: fd_t, buf: []u8, offset: u64) PReadError!usize {
             .INTR => continue,
             .INVAL => unreachable,
             .FAULT => unreachable,
+            .NOENT => return error.ProcessNotFound,
             .AGAIN => return error.WouldBlock,
             .BADF => return error.NotOpenForReading, // Can be a race condition.
             .IO => return error.InputOutput,
@@ -1133,6 +1143,7 @@ pub fn preadv(fd: fd_t, iov: []const iovec, offset: u64) PReadError!usize {
             .INTR => continue,
             .INVAL => unreachable,
             .FAULT => unreachable,
+            .NOENT => return error.ProcessNotFound,
             .AGAIN => return error.WouldBlock,
             .BADF => return error.NotOpenForReading, // can be a race condition
             .IO => return error.InputOutput,
@@ -1176,6 +1187,10 @@ pub const WriteError = error{
 
     /// Connection reset by peer.
     ConnectionResetByPeer,
+
+    /// This error occurs in Linux if the process being written to
+    /// no longer exists.
+    ProcessNotFound,
 } || UnexpectedError;
 
 /// Write to a file descriptor.
@@ -1243,6 +1258,7 @@ pub fn write(fd: fd_t, bytes: []const u8) WriteError!usize {
             .INTR => continue,
             .INVAL => return error.InvalidArgument,
             .FAULT => unreachable,
+            .NOENT => return error.ProcessNotFound,
             .AGAIN => return error.WouldBlock,
             .BADF => return error.NotOpenForWriting, // can be a race condition.
             .DESTADDRREQ => unreachable, // `connect` was never called.
@@ -1315,6 +1331,7 @@ pub fn writev(fd: fd_t, iov: []const iovec_const) WriteError!usize {
             .INTR => continue,
             .INVAL => return error.InvalidArgument,
             .FAULT => unreachable,
+            .NOENT => return error.ProcessNotFound,
             .AGAIN => return error.WouldBlock,
             .BADF => return error.NotOpenForWriting, // Can be a race condition.
             .DESTADDRREQ => unreachable, // `connect` was never called.
@@ -1404,6 +1421,7 @@ pub fn pwrite(fd: fd_t, bytes: []const u8, offset: u64) PWriteError!usize {
             .INTR => continue,
             .INVAL => return error.InvalidArgument,
             .FAULT => unreachable,
+            .NOENT => return error.ProcessNotFound,
             .AGAIN => return error.WouldBlock,
             .BADF => return error.NotOpenForWriting, // Can be a race condition.
             .DESTADDRREQ => unreachable, // `connect` was never called.
@@ -1488,6 +1506,7 @@ pub fn pwritev(fd: fd_t, iov: []const iovec_const, offset: u64) PWriteError!usiz
             .INTR => continue,
             .INVAL => return error.InvalidArgument,
             .FAULT => unreachable,
+            .NOENT => return error.ProcessNotFound,
             .AGAIN => return error.WouldBlock,
             .BADF => return error.NotOpenForWriting, // Can be a race condition.
             .DESTADDRREQ => unreachable, // `connect` was never called.
@@ -4544,13 +4563,16 @@ pub const FanotifyInitError = error{
     SystemFdQuotaExceeded,
     SystemResources,
     PermissionDenied,
+    /// The kernel does not recognize the flags passed, likely because it is an
+    /// older version.
+    UnsupportedFlags,
 } || UnexpectedError;
 
 pub fn fanotify_init(flags: std.os.linux.fanotify.InitFlags, event_f_flags: u32) FanotifyInitError!i32 {
     const rc = system.fanotify_init(flags, event_f_flags);
     switch (errno(rc)) {
         .SUCCESS => return @intCast(rc),
-        .INVAL => unreachable,
+        .INVAL => return error.UnsupportedFlags,
         .MFILE => return error.ProcessFdQuotaExceeded,
         .NFILE => return error.SystemFdQuotaExceeded,
         .NOMEM => return error.SystemResources,
@@ -6763,6 +6785,7 @@ pub const MemFdCreateError = error{
     OutOfMemory,
     /// Either the name provided exceeded `NAME_MAX`, or invalid flags were passed.
     NameTooLong,
+    SystemOutdated,
 } || UnexpectedError;
 
 pub fn memfd_createZ(name: [*:0]const u8, flags: u32) MemFdCreateError!fd_t {
diff --git a/zig/lib/std/posix/test.zig b/zig/lib/std/posix/test.zig
index e62ffa39ca..dba7dcde6d 100644
--- a/zig/lib/std/posix/test.zig
+++ b/zig/lib/std/posix/test.zig
@@ -368,6 +368,11 @@ test "fstatat" {
     // now repeat but using `fstatat` instead
     const flags = if (native_os == .wasi) 0x0 else posix.AT.SYMLINK_NOFOLLOW;
     const statat = try posix.fstatat(tmp.dir.fd, "file.txt", flags);
+
+    // s390x-linux does not have nanosecond precision for fstat(), but it does for fstatat(). As a
+    // result, comparing the two structures is doomed to fail.
+    if (builtin.cpu.arch == .s390x and builtin.os.tag == .linux) return error.SkipZigTest;
+
     try expectEqual(stat, statat);
 }
 
diff --git a/zig/lib/std/process/Child.zig b/zig/lib/std/process/Child.zig
index 3a54ede2ad..bd0a91ce77 100644
--- a/zig/lib/std/process/Child.zig
+++ b/zig/lib/std/process/Child.zig
@@ -316,9 +316,7 @@ pub const RunResult = struct {
 };
 
 fn fifoToOwnedArrayList(fifo: *std.io.PollFifo) std.ArrayList(u8) {
-    if (fifo.head > 0) {
-        @memcpy(fifo.buf[0..fifo.count], fifo.buf[fifo.head..][0..fifo.count]);
-    }
+    if (fifo.head != 0) fifo.realign();
     const result = std.ArrayList(u8){
         .items = fifo.buf[0..fifo.count],
         .capacity = fifo.buf.len,
diff --git a/zig/lib/std/sort.zig b/zig/lib/std/sort.zig
index 23707f1385..8705d24017 100644
--- a/zig/lib/std/sort.zig
+++ b/zig/lib/std/sort.zig
@@ -769,10 +769,38 @@ pub fn equalRange(
     context: anytype,
     comptime compareFn: fn (@TypeOf(context), T) std.math.Order,
 ) struct { usize, usize } {
-    return .{
-        lowerBound(T, items, context, compareFn),
-        upperBound(T, items, context, compareFn),
-    };
+    var low: usize = 0;
+    var high: usize = items.len;
+
+    while (low < high) {
+        const mid = low + (high - low) / 2;
+        switch (compareFn(context, items[mid])) {
+            .gt => {
+                low = mid + 1;
+            },
+            .lt => {
+                high = mid;
+            },
+            .eq => {
+                return .{
+                    low + std.sort.lowerBound(
+                        T,
+                        items[low..mid],
+                        context,
+                        compareFn,
+                    ),
+                    mid + std.sort.upperBound(
+                        T,
+                        items[mid..high],
+                        context,
+                        compareFn,
+                    ),
+                };
+            },
+        }
+    }
+
+    return .{ low, low };
 }
 
 test equalRange {
@@ -800,6 +828,7 @@ test equalRange {
     try std.testing.expectEqual(.{ 6, 6 }, equalRange(i32, &[_]i32{ 2, 4, 8, 16, 32, 64 }, @as(i32, 100), S.orderI32));
     try std.testing.expectEqual(.{ 2, 6 }, equalRange(i32, &[_]i32{ 2, 4, 8, 8, 8, 8, 15, 22 }, @as(i32, 8), S.orderI32));
     try std.testing.expectEqual(.{ 2, 2 }, equalRange(u32, &[_]u32{ 2, 4, 8, 16, 32, 64 }, @as(u32, 5), S.orderU32));
+    try std.testing.expectEqual(.{ 3, 5 }, equalRange(u32, &[_]u32{ 2, 3, 4, 5, 5 }, @as(u32, 5), S.orderU32));
     try std.testing.expectEqual(.{ 1, 1 }, equalRange(f32, &[_]f32{ -54.2, -26.7, 0.0, 56.55, 100.1, 322.0 }, @as(f32, -33.4), S.orderF32));
     try std.testing.expectEqual(.{ 3, 5 }, equalRange(
         []const u8,
diff --git a/zig/lib/std/start.zig b/zig/lib/std/start.zig
index a8109f7ed9..01a33522d0 100644
--- a/zig/lib/std/start.zig
+++ b/zig/lib/std/start.zig
@@ -271,8 +271,8 @@ fn _start() callconv(.Naked) noreturn {
             \\ b %[posixCallMainAndExit]
             ,
             .arc =>
-            // The `arc` tag currently means ARCv2, which has an unusually low stack alignment
-            // requirement. ARCv3 increases it from 4 to 16, but we don't support ARCv3 yet.
+            // The `arc` tag currently means ARC v1 and v2, which have an unusually low stack
+            // alignment requirement. ARC v3 increases it from 4 to 16, but we don't support v3 yet.
             \\ mov fp, 0
             \\ mov blink, 0
             \\ mov r0, sp
@@ -391,6 +391,7 @@ fn _start() callconv(.Naked) noreturn {
             \\ stdu 0, -32(1)
             \\ mtlr 0
             \\ b %[posixCallMainAndExit]
+            \\ nop
             ,
             .s390x =>
             // Set up the stack frame (register save area and cleared back-chain slot).
@@ -539,6 +540,7 @@ fn expandStackSize(phdrs: []elf.Phdr) void {
     for (phdrs) |*phdr| {
         switch (phdr.p_type) {
             elf.PT_GNU_STACK => {
+                if (phdr.p_memsz == 0) break;
                 assert(phdr.p_memsz % std.mem.page_size == 0);
 
                 // Silently fail if we are unable to get limits.
diff --git a/zig/lib/std/tar.zig b/zig/lib/std/tar.zig
index f15a5e8c8a..060b802f19 100644
--- a/zig/lib/std/tar.zig
+++ b/zig/lib/std/tar.zig
@@ -848,6 +848,7 @@ test PaxIterator {
 
 test {
     _ = @import("tar/test.zig");
+    _ = @import("tar/writer.zig");
     _ = Diagnostics;
 }
 
diff --git a/zig/lib/std/tar/writer.zig b/zig/lib/std/tar/writer.zig
index e75e6c42d6..4ced287eec 100644
--- a/zig/lib/std/tar/writer.zig
+++ b/zig/lib/std/tar/writer.zig
@@ -84,7 +84,7 @@ pub fn Writer(comptime WriterType: type) type {
 
         /// Writes fs.Dir.WalkerEntry. Uses `mtime` from file system entry and
         /// default for entry mode .
-        pub fn writeEntry(self: *Self, entry: std.fs.Dir.Walker.WalkerEntry) !void {
+        pub fn writeEntry(self: *Self, entry: std.fs.Dir.Walker.Entry) !void {
             switch (entry.kind) {
                 .directory => {
                     try self.writeDir(entry.path, .{ .mtime = try entryMtime(entry) });
@@ -95,7 +95,7 @@ pub fn Writer(comptime WriterType: type) type {
                     try self.writeFile(entry.path, file);
                 },
                 .sym_link => {
-                    var link_name_buffer: [std.fs.MAX_PATH_BYTES]u8 = undefined;
+                    var link_name_buffer: [std.fs.max_path_bytes]u8 = undefined;
                     const link_name = try entry.dir.readLink(entry.basename, &link_name_buffer);
                     try self.writeLink(entry.path, link_name, .{ .mtime = try entryMtime(entry) });
                 },
@@ -133,7 +133,7 @@ pub fn Writer(comptime WriterType: type) type {
             return self.mtime_now;
         }
 
-        fn entryMtime(entry: std.fs.Dir.Walker.WalkerEntry) !u64 {
+        fn entryMtime(entry: std.fs.Dir.Walker.Entry) !u64 {
             const stat = try entry.dir.statFile(entry.basename);
             return @intCast(@divFloor(stat.mtime, std.time.ns_per_s));
         }
@@ -424,8 +424,8 @@ test "write files" {
         .{ .path = "e123456789" ** 11, .content = "e" },
     };
 
-    var file_name_buffer: [std.fs.MAX_PATH_BYTES]u8 = undefined;
-    var link_name_buffer: [std.fs.MAX_PATH_BYTES]u8 = undefined;
+    var file_name_buffer: [std.fs.max_path_bytes]u8 = undefined;
+    var link_name_buffer: [std.fs.max_path_bytes]u8 = undefined;
 
     // with root
     {
diff --git a/zig/lib/std/time.zig b/zig/lib/std/time.zig
index a80a2477ac..d253b63512 100644
--- a/zig/lib/std/time.zig
+++ b/zig/lib/std/time.zig
@@ -8,82 +8,8 @@ const posix = std.posix;
 
 pub const epoch = @import("time/epoch.zig");
 
-/// Spurious wakeups are possible and no precision of timing is guaranteed.
-pub fn sleep(nanoseconds: u64) void {
-    if (builtin.os.tag == .windows) {
-        const big_ms_from_ns = nanoseconds / ns_per_ms;
-        const ms = math.cast(windows.DWORD, big_ms_from_ns) orelse math.maxInt(windows.DWORD);
-        windows.kernel32.Sleep(ms);
-        return;
-    }
-
-    if (builtin.os.tag == .wasi) {
-        const w = std.os.wasi;
-        const userdata: w.userdata_t = 0x0123_45678;
-        const clock: w.subscription_clock_t = .{
-            .id = .MONOTONIC,
-            .timeout = nanoseconds,
-            .precision = 0,
-            .flags = 0,
-        };
-        const in: w.subscription_t = .{
-            .userdata = userdata,
-            .u = .{
-                .tag = .CLOCK,
-                .u = .{ .clock = clock },
-            },
-        };
-
-        var event: w.event_t = undefined;
-        var nevents: usize = undefined;
-        _ = w.poll_oneoff(&in, &event, 1, &nevents);
-        return;
-    }
-
-    if (builtin.os.tag == .uefi) {
-        const boot_services = std.os.uefi.system_table.boot_services.?;
-        const us_from_ns = nanoseconds / ns_per_us;
-        const us = math.cast(usize, us_from_ns) orelse math.maxInt(usize);
-        _ = boot_services.stall(us);
-        return;
-    }
-
-    const s = nanoseconds / ns_per_s;
-    const ns = nanoseconds % ns_per_s;
-
-    // Newer kernel ports don't have old `nanosleep()` and `clock_nanosleep()` has been around
-    // since Linux 2.6 and glibc 2.1 anyway.
-    if (builtin.os.tag == .linux) {
-        const linux = std.os.linux;
-
-        var req: linux.timespec = .{
-            .sec = std.math.cast(linux.time_t, s) orelse std.math.maxInt(linux.time_t),
-            .nsec = std.math.cast(linux.time_t, ns) orelse std.math.maxInt(linux.time_t),
-        };
-        var rem: linux.timespec = undefined;
-
-        while (true) {
-            switch (linux.E.init(linux.clock_nanosleep(.MONOTONIC, .{ .ABSTIME = false }, &req, &rem))) {
-                .SUCCESS => return,
-                .INTR => {
-                    req = rem;
-                    continue;
-                },
-                .FAULT,
-                .INVAL,
-                .OPNOTSUPP,
-                => unreachable,
-                else => return,
-            }
-        }
-    }
-
-    posix.nanosleep(s, ns);
-}
-
-test sleep {
-    sleep(1);
-}
+/// Deprecated: moved to std.Thread.sleep
+pub const sleep = std.Thread.sleep;
 
 /// Get a calendar timestamp, in seconds, relative to UTC 1970-01-01.
 /// Precision of timing depends on the hardware and operating system.
@@ -155,7 +81,7 @@ test milliTimestamp {
     const margin = ns_per_ms * 50;
 
     const time_0 = milliTimestamp();
-    sleep(ns_per_ms);
+    std.Thread.sleep(ns_per_ms);
     const time_1 = milliTimestamp();
     const interval = time_1 - time_0;
     try testing.expect(interval > 0);
@@ -359,7 +285,7 @@ test Timer {
     const margin = ns_per_ms * 150;
 
     var timer = try Timer.start();
-    sleep(10 * ns_per_ms);
+    std.Thread.sleep(10 * ns_per_ms);
     const time_0 = timer.read();
     try testing.expect(time_0 > 0);
     // Tests should not depend on timings: skip test if outside margin.
diff --git a/zig/lib/std/zig.zig b/zig/lib/std/zig.zig
index 325b7bea90..c3ce106634 100644
--- a/zig/lib/std/zig.zig
+++ b/zig/lib/std/zig.zig
@@ -233,7 +233,6 @@ pub fn binNameAlloc(allocator: Allocator, options: BinNameOptions) error{OutOfMe
             }),
         },
         .nvptx => return std.fmt.allocPrint(allocator, "{s}.ptx", .{root_name}),
-        .dxcontainer => return std.fmt.allocPrint(allocator, "{s}.dxil", .{root_name}),
     }
 }
 
diff --git a/zig/lib/std/zig/AstGen.zig b/zig/lib/std/zig/AstGen.zig
index 14902a6726..7e11f8d44b 100644
--- a/zig/lib/std/zig/AstGen.zig
+++ b/zig/lib/std/zig/AstGen.zig
@@ -2716,7 +2716,7 @@ fn addEnsureResult(gz: *GenZir, maybe_unused_result: Zir.Inst.Ref, statement: As
             .array_type_sentinel,
             .elem_type,
             .indexable_ptr_elem_type,
-            .vector_elem_type,
+            .vec_arr_elem_type,
             .vector_type,
             .indexable_ptr_len,
             .anyframe_type,
@@ -2901,7 +2901,6 @@ fn addEnsureResult(gz: *GenZir, maybe_unused_result: Zir.Inst.Ref, statement: As
             .extended => switch (gz.astgen.instructions.items(.data)[@intFromEnum(inst)].extended.opcode) {
                 .breakpoint,
                 .disable_instrumentation,
-                .fence,
                 .set_float_mode,
                 .set_align_stack,
                 .branch_hint,
@@ -3156,6 +3155,9 @@ fn deferStmt(
     const have_err_code = scope_tag == .defer_error and payload_token != 0;
     const sub_scope = if (!have_err_code) &defer_gen.base else blk: {
         const ident_name = try gz.astgen.identAsString(payload_token);
+        if (std.mem.eql(u8, tree.tokenSlice(payload_token), "_")) {
+            return gz.astgen.failTok(payload_token, "discard of error capture; omit it instead", .{});
+        }
         const remapped_err_code: Zir.Inst.Index = @enumFromInt(gz.astgen.instructions.len);
         opt_remapped_err_code = remapped_err_code.toOptional();
         try gz.astgen.instructions.append(gz.astgen.gpa, .{
@@ -9139,7 +9141,7 @@ fn minMax(
 ) InnerError!Zir.Inst.Ref {
     const astgen = gz.astgen;
     if (args.len < 2) {
-        return astgen.failNode(node, "expected at least 2 arguments, found 0", .{});
+        return astgen.failNode(node, "expected at least 2 arguments, found {}", .{args.len});
     }
     if (args.len == 2) {
         const tag: Zir.Inst.Tag = switch (op) {
@@ -9304,15 +9306,6 @@ fn builtinCall(
             });
             return rvalue(gz, ri, result, node);
         },
-        .fence => {
-            const atomic_order_ty = try gz.addBuiltinValue(node, .atomic_order);
-            const order = try expr(gz, scope, .{ .rl = .{ .coerced_ty = atomic_order_ty } }, params[0]);
-            _ = try gz.addExtendedPayload(.fence, Zir.Inst.UnNode{
-                .node = gz.nodeIndexToRelative(node),
-                .operand = order,
-            });
-            return rvalue(gz, ri, .void_value, node);
-        },
         .set_float_mode => {
             const float_mode_ty = try gz.addBuiltinValue(node, .float_mode);
             const order = try expr(gz, scope, .{ .rl = .{ .coerced_ty = float_mode_ty } }, params[0]);
@@ -9536,7 +9529,7 @@ fn builtinCall(
 
         .splat => {
             const result_type = try ri.rl.resultTypeForCast(gz, node, builtin_name);
-            const elem_type = try gz.addUnNode(.vector_elem_type, result_type, node);
+            const elem_type = try gz.addUnNode(.vec_arr_elem_type, result_type, node);
             const scalar = try expr(gz, scope, .{ .rl = .{ .ty = elem_type } }, params[0]);
             const result = try gz.addPlNode(.splat, node, Zir.Inst.Bin{
                 .lhs = result_type,
diff --git a/zig/lib/std/zig/AstRlAnnotate.zig b/zig/lib/std/zig/AstRlAnnotate.zig
index 597baa2936..104cea1154 100644
--- a/zig/lib/std/zig/AstRlAnnotate.zig
+++ b/zig/lib/std/zig/AstRlAnnotate.zig
@@ -908,7 +908,6 @@ fn builtinCall(astrl: *AstRlAnnotate, block: ?*Block, ri: ResultInfo, node: Ast.
         .c_include,
         .wasm_memory_size,
         .splat,
-        .fence,
         .set_float_mode,
         .set_align_stack,
         .type_info,
diff --git a/zig/lib/std/zig/BuiltinFn.zig b/zig/lib/std/zig/BuiltinFn.zig
index 95c6c7be12..6b0d0cc0a2 100644
--- a/zig/lib/std/zig/BuiltinFn.zig
+++ b/zig/lib/std/zig/BuiltinFn.zig
@@ -48,7 +48,6 @@ pub const Tag = enum {
     error_cast,
     @"export",
     @"extern",
-    fence,
     field,
     field_parent_ptr,
     float_cast,
@@ -500,13 +499,6 @@ pub const list = list: {
                 .param_count = 2,
             },
         },
-        .{
-            "@fence",
-            .{
-                .tag = .fence,
-                .param_count = 1,
-            },
-        },
         .{
             "@field",
             .{
diff --git a/zig/lib/std/zig/LibCDirs.zig b/zig/lib/std/zig/LibCDirs.zig
index 8fb961c187..8b8a3a8d42 100644
--- a/zig/lib/std/zig/LibCDirs.zig
+++ b/zig/lib/std/zig/LibCDirs.zig
@@ -69,7 +69,7 @@ pub fn detect(
     // On windows, instead of the native (mingw) abi, we want to check
     // for the MSVC abi as a fallback.
     const use_system_abi = if (builtin.os.tag == .windows)
-        target.abi == .msvc
+        target.abi == .msvc or target.abi == .itanium
     else
         is_native_abi;
 
@@ -242,35 +242,20 @@ fn libCGenericName(target: std.Target) [:0]const u8 {
         .muslx32,
         .none,
         .ohos,
+        .ohoseabi,
         => return "musl",
         .code16,
         .eabi,
         .eabihf,
         .ilp32,
         .android,
+        .androideabi,
         .msvc,
         .itanium,
         .cygnus,
         .simulator,
         .macabi,
         => unreachable,
-
-        .pixel,
-        .vertex,
-        .geometry,
-        .hull,
-        .domain,
-        .compute,
-        .library,
-        .raygeneration,
-        .intersection,
-        .anyhit,
-        .closesthit,
-        .miss,
-        .callable,
-        .mesh,
-        .amplification,
-        => unreachable,
     }
 }
 
diff --git a/zig/lib/std/zig/LibCInstallation.zig b/zig/lib/std/zig/LibCInstallation.zig
index 686471bde5..3d163532d1 100644
--- a/zig/lib/std/zig/LibCInstallation.zig
+++ b/zig/lib/std/zig/LibCInstallation.zig
@@ -86,14 +86,14 @@ pub fn parse(
         return error.ParseError;
     }
 
-    if (self.msvc_lib_dir == null and os_tag == .windows and target.abi == .msvc) {
+    if (self.msvc_lib_dir == null and os_tag == .windows and (target.abi == .msvc or target.abi == .itanium)) {
         log.err("msvc_lib_dir may not be empty for {s}-{s}", .{
             @tagName(os_tag),
             @tagName(target.abi),
         });
         return error.ParseError;
     }
-    if (self.kernel32_lib_dir == null and os_tag == .windows and target.abi == .msvc) {
+    if (self.kernel32_lib_dir == null and os_tag == .windows and (target.abi == .msvc or target.abi == .itanium)) {
         log.err("kernel32_lib_dir may not be empty for {s}-{s}", .{
             @tagName(os_tag),
             @tagName(target.abi),
@@ -690,12 +690,340 @@ fn appendCcExe(args: *std.ArrayList([]const u8), skip_cc_env_var: bool) !void {
     }
 }
 
+/// These are basenames. This data is produced with a pure function. See also
+/// `CsuPaths`.
+pub const CrtBasenames = struct {
+    crt0: ?[]const u8 = null,
+    crti: ?[]const u8 = null,
+    crtbegin: ?[]const u8 = null,
+    crtend: ?[]const u8 = null,
+    crtn: ?[]const u8 = null,
+
+    pub const GetArgs = struct {
+        target: std.Target,
+        link_libc: bool,
+        output_mode: std.builtin.OutputMode,
+        link_mode: std.builtin.LinkMode,
+        pie: bool,
+    };
+
+    /// Determine file system path names of C runtime startup objects for supported
+    /// link modes.
+    pub fn get(args: GetArgs) CrtBasenames {
+        // crt objects are only required for libc.
+        if (!args.link_libc) return .{};
+
+        // Flatten crt cases.
+        const mode: enum {
+            dynamic_lib,
+            dynamic_exe,
+            dynamic_pie,
+            static_exe,
+            static_pie,
+        } = switch (args.output_mode) {
+            .Obj => return .{},
+            .Lib => switch (args.link_mode) {
+                .dynamic => .dynamic_lib,
+                .static => return .{},
+            },
+            .Exe => switch (args.link_mode) {
+                .dynamic => if (args.pie) .dynamic_pie else .dynamic_exe,
+                .static => if (args.pie) .static_pie else .static_exe,
+            },
+        };
+
+        const target = args.target;
+
+        if (target.isAndroid()) return switch (mode) {
+            .dynamic_lib => .{
+                .crtbegin = "crtbegin_so.o",
+                .crtend = "crtend_so.o",
+            },
+            .dynamic_exe, .dynamic_pie => .{
+                .crtbegin = "crtbegin_dynamic.o",
+                .crtend = "crtend_android.o",
+            },
+            .static_exe, .static_pie => .{
+                .crtbegin = "crtbegin_static.o",
+                .crtend = "crtend_android.o",
+            },
+        };
+
+        return switch (target.os.tag) {
+            .linux => switch (mode) {
+                .dynamic_lib => .{
+                    .crti = "crti.o",
+                    .crtn = "crtn.o",
+                },
+                .dynamic_exe => .{
+                    .crt0 = "crt1.o",
+                    .crti = "crti.o",
+                    .crtn = "crtn.o",
+                },
+                .dynamic_pie => .{
+                    .crt0 = "Scrt1.o",
+                    .crti = "crti.o",
+                    .crtn = "crtn.o",
+                },
+                .static_exe => .{
+                    .crt0 = "crt1.o",
+                    .crti = "crti.o",
+                    .crtn = "crtn.o",
+                },
+                .static_pie => .{
+                    .crt0 = "rcrt1.o",
+                    .crti = "crti.o",
+                    .crtn = "crtn.o",
+                },
+            },
+            .dragonfly => switch (mode) {
+                .dynamic_lib => .{
+                    .crti = "crti.o",
+                    .crtbegin = "crtbeginS.o",
+                    .crtend = "crtendS.o",
+                    .crtn = "crtn.o",
+                },
+                .dynamic_exe => .{
+                    .crt0 = "crt1.o",
+                    .crti = "crti.o",
+                    .crtbegin = "crtbegin.o",
+                    .crtend = "crtend.o",
+                    .crtn = "crtn.o",
+                },
+                .dynamic_pie => .{
+                    .crt0 = "Scrt1.o",
+                    .crti = "crti.o",
+                    .crtbegin = "crtbeginS.o",
+                    .crtend = "crtendS.o",
+                    .crtn = "crtn.o",
+                },
+                .static_exe => .{
+                    .crt0 = "crt1.o",
+                    .crti = "crti.o",
+                    .crtbegin = "crtbegin.o",
+                    .crtend = "crtend.o",
+                    .crtn = "crtn.o",
+                },
+                .static_pie => .{
+                    .crt0 = "Scrt1.o",
+                    .crti = "crti.o",
+                    .crtbegin = "crtbeginS.o",
+                    .crtend = "crtendS.o",
+                    .crtn = "crtn.o",
+                },
+            },
+            .freebsd => switch (mode) {
+                .dynamic_lib => .{
+                    .crti = "crti.o",
+                    .crtbegin = "crtbeginS.o",
+                    .crtend = "crtendS.o",
+                    .crtn = "crtn.o",
+                },
+                .dynamic_exe => .{
+                    .crt0 = "crt1.o",
+                    .crti = "crti.o",
+                    .crtbegin = "crtbegin.o",
+                    .crtend = "crtend.o",
+                    .crtn = "crtn.o",
+                },
+                .dynamic_pie => .{
+                    .crt0 = "Scrt1.o",
+                    .crti = "crti.o",
+                    .crtbegin = "crtbeginS.o",
+                    .crtend = "crtendS.o",
+                    .crtn = "crtn.o",
+                },
+                .static_exe => .{
+                    .crt0 = "crt1.o",
+                    .crti = "crti.o",
+                    .crtbegin = "crtbeginT.o",
+                    .crtend = "crtend.o",
+                    .crtn = "crtn.o",
+                },
+                .static_pie => .{
+                    .crt0 = "Scrt1.o",
+                    .crti = "crti.o",
+                    .crtbegin = "crtbeginS.o",
+                    .crtend = "crtendS.o",
+                    .crtn = "crtn.o",
+                },
+            },
+            .netbsd => switch (mode) {
+                .dynamic_lib => .{
+                    .crti = "crti.o",
+                    .crtbegin = "crtbeginS.o",
+                    .crtend = "crtendS.o",
+                    .crtn = "crtn.o",
+                },
+                .dynamic_exe => .{
+                    .crt0 = "crt0.o",
+                    .crti = "crti.o",
+                    .crtbegin = "crtbegin.o",
+                    .crtend = "crtend.o",
+                    .crtn = "crtn.o",
+                },
+                .dynamic_pie => .{
+                    .crt0 = "crt0.o",
+                    .crti = "crti.o",
+                    .crtbegin = "crtbeginS.o",
+                    .crtend = "crtendS.o",
+                    .crtn = "crtn.o",
+                },
+                .static_exe => .{
+                    .crt0 = "crt0.o",
+                    .crti = "crti.o",
+                    .crtbegin = "crtbeginT.o",
+                    .crtend = "crtend.o",
+                    .crtn = "crtn.o",
+                },
+                .static_pie => .{
+                    .crt0 = "crt0.o",
+                    .crti = "crti.o",
+                    .crtbegin = "crtbeginT.o",
+                    .crtend = "crtendS.o",
+                    .crtn = "crtn.o",
+                },
+            },
+            .openbsd => switch (mode) {
+                .dynamic_lib => .{
+                    .crtbegin = "crtbeginS.o",
+                    .crtend = "crtendS.o",
+                },
+                .dynamic_exe, .dynamic_pie => .{
+                    .crt0 = "crt0.o",
+                    .crtbegin = "crtbegin.o",
+                    .crtend = "crtend.o",
+                },
+                .static_exe, .static_pie => .{
+                    .crt0 = "rcrt0.o",
+                    .crtbegin = "crtbegin.o",
+                    .crtend = "crtend.o",
+                },
+            },
+            .haiku => switch (mode) {
+                .dynamic_lib => .{
+                    .crti = "crti.o",
+                    .crtbegin = "crtbeginS.o",
+                    .crtend = "crtendS.o",
+                    .crtn = "crtn.o",
+                },
+                .dynamic_exe => .{
+                    .crt0 = "start_dyn.o",
+                    .crti = "crti.o",
+                    .crtbegin = "crtbegin.o",
+                    .crtend = "crtend.o",
+                    .crtn = "crtn.o",
+                },
+                .dynamic_pie => .{
+                    .crt0 = "start_dyn.o",
+                    .crti = "crti.o",
+                    .crtbegin = "crtbeginS.o",
+                    .crtend = "crtendS.o",
+                    .crtn = "crtn.o",
+                },
+                .static_exe => .{
+                    .crt0 = "start_dyn.o",
+                    .crti = "crti.o",
+                    .crtbegin = "crtbegin.o",
+                    .crtend = "crtend.o",
+                    .crtn = "crtn.o",
+                },
+                .static_pie => .{
+                    .crt0 = "start_dyn.o",
+                    .crti = "crti.o",
+                    .crtbegin = "crtbeginS.o",
+                    .crtend = "crtendS.o",
+                    .crtn = "crtn.o",
+                },
+            },
+            .solaris, .illumos => switch (mode) {
+                .dynamic_lib => .{
+                    .crti = "crti.o",
+                    .crtn = "crtn.o",
+                },
+                .dynamic_exe, .dynamic_pie => .{
+                    .crt0 = "crt1.o",
+                    .crti = "crti.o",
+                    .crtn = "crtn.o",
+                },
+                .static_exe, .static_pie => .{},
+            },
+            else => .{},
+        };
+    }
+};
+
+pub const CrtPaths = struct {
+    crt0: ?Path = null,
+    crti: ?Path = null,
+    crtbegin: ?Path = null,
+    crtend: ?Path = null,
+    crtn: ?Path = null,
+};
+
+pub fn resolveCrtPaths(
+    lci: LibCInstallation,
+    arena: Allocator,
+    crt_basenames: CrtBasenames,
+    target: std.Target,
+) error{ OutOfMemory, LibCInstallationMissingCrtDir }!CrtPaths {
+    const crt_dir_path: Path = .{
+        .root_dir = std.Build.Cache.Directory.cwd(),
+        .sub_path = lci.crt_dir orelse return error.LibCInstallationMissingCrtDir,
+    };
+    switch (target.os.tag) {
+        .dragonfly => {
+            const gccv: []const u8 = if (target.os.version_range.semver.isAtLeast(.{
+                .major = 5,
+                .minor = 4,
+                .patch = 0,
+            }) orelse true) "gcc80" else "gcc54";
+            return .{
+                .crt0 = if (crt_basenames.crt0) |basename| try crt_dir_path.join(arena, basename) else null,
+                .crti = if (crt_basenames.crti) |basename| try crt_dir_path.join(arena, basename) else null,
+                .crtbegin = if (crt_basenames.crtbegin) |basename| .{
+                    .root_dir = crt_dir_path.root_dir,
+                    .sub_path = try fs.path.join(arena, &.{ crt_dir_path.sub_path, gccv, basename }),
+                } else null,
+                .crtend = if (crt_basenames.crtend) |basename| .{
+                    .root_dir = crt_dir_path.root_dir,
+                    .sub_path = try fs.path.join(arena, &.{ crt_dir_path.sub_path, gccv, basename }),
+                } else null,
+                .crtn = if (crt_basenames.crtn) |basename| try crt_dir_path.join(arena, basename) else null,
+            };
+        },
+        .haiku => {
+            const gcc_dir_path: Path = .{
+                .root_dir = std.Build.Cache.Directory.cwd(),
+                .sub_path = lci.gcc_dir orelse return error.LibCInstallationMissingCrtDir,
+            };
+            return .{
+                .crt0 = if (crt_basenames.crt0) |basename| try crt_dir_path.join(arena, basename) else null,
+                .crti = if (crt_basenames.crti) |basename| try crt_dir_path.join(arena, basename) else null,
+                .crtbegin = if (crt_basenames.crtbegin) |basename| try gcc_dir_path.join(arena, basename) else null,
+                .crtend = if (crt_basenames.crtend) |basename| try gcc_dir_path.join(arena, basename) else null,
+                .crtn = if (crt_basenames.crtn) |basename| try crt_dir_path.join(arena, basename) else null,
+            };
+        },
+        else => {
+            return .{
+                .crt0 = if (crt_basenames.crt0) |basename| try crt_dir_path.join(arena, basename) else null,
+                .crti = if (crt_basenames.crti) |basename| try crt_dir_path.join(arena, basename) else null,
+                .crtbegin = if (crt_basenames.crtbegin) |basename| try crt_dir_path.join(arena, basename) else null,
+                .crtend = if (crt_basenames.crtend) |basename| try crt_dir_path.join(arena, basename) else null,
+                .crtn = if (crt_basenames.crtn) |basename| try crt_dir_path.join(arena, basename) else null,
+            };
+        },
+    }
+}
+
 const LibCInstallation = @This();
 const std = @import("std");
 const builtin = @import("builtin");
 const Target = std.Target;
 const fs = std.fs;
 const Allocator = std.mem.Allocator;
+const Path = std.Build.Cache.Path;
 
 const is_darwin = builtin.target.isDarwin();
 const is_windows = builtin.target.os.tag == .windows;
diff --git a/zig/lib/std/zig/Zir.zig b/zig/lib/std/zig/Zir.zig
index dda7e7bbd0..9c76f72663 100644
--- a/zig/lib/std/zig/Zir.zig
+++ b/zig/lib/std/zig/Zir.zig
@@ -247,9 +247,9 @@ pub const Inst = struct {
         /// element type. Emits a compile error if the type is not an indexable pointer.
         /// Uses the `un_node` field.
         indexable_ptr_elem_type,
-        /// Given a vector type, returns its element type.
+        /// Given a vector or array type, returns its element type.
         /// Uses the `un_node` field.
-        vector_elem_type,
+        vec_arr_elem_type,
         /// Given a pointer to an indexable object, returns the len property. This is
         /// used by for loops. This instruction also emits a for-loop specific compile
         /// error if the indexable object is not indexable.
@@ -1065,7 +1065,7 @@ pub const Inst = struct {
                 .vector_type,
                 .elem_type,
                 .indexable_ptr_elem_type,
-                .vector_elem_type,
+                .vec_arr_elem_type,
                 .indexable_ptr_len,
                 .anyframe_type,
                 .as_node,
@@ -1375,7 +1375,7 @@ pub const Inst = struct {
                 .vector_type,
                 .elem_type,
                 .indexable_ptr_elem_type,
-                .vector_elem_type,
+                .vec_arr_elem_type,
                 .indexable_ptr_len,
                 .anyframe_type,
                 .as_node,
@@ -1575,7 +1575,7 @@ pub const Inst = struct {
                 => false,
 
                 .extended => switch (data.extended.opcode) {
-                    .fence, .branch_hint, .breakpoint, .disable_instrumentation => true,
+                    .branch_hint, .breakpoint, .disable_instrumentation => true,
                     else => false,
                 },
             };
@@ -1607,7 +1607,7 @@ pub const Inst = struct {
                 .vector_type = .pl_node,
                 .elem_type = .un_node,
                 .indexable_ptr_elem_type = .un_node,
-                .vector_elem_type = .un_node,
+                .vec_arr_elem_type = .un_node,
                 .indexable_ptr_len = .un_node,
                 .anyframe_type = .un_node,
                 .as_node = .pl_node,
@@ -1979,9 +1979,6 @@ pub const Inst = struct {
         /// The `@prefetch` builtin.
         /// `operand` is payload index to `BinNode`.
         prefetch,
-        /// Implements the `@fence` builtin.
-        /// `operand` is payload index to `UnNode`.
-        fence,
         /// Implement builtin `@setFloatMode`.
         /// `operand` is payload index to `UnNode`.
         set_float_mode,
@@ -3784,7 +3781,7 @@ fn findDeclsInner(
         .vector_type,
         .elem_type,
         .indexable_ptr_elem_type,
-        .vector_elem_type,
+        .vec_arr_elem_type,
         .indexable_ptr_len,
         .anyframe_type,
         .as_node,
@@ -4014,7 +4011,6 @@ fn findDeclsInner(
                 .wasm_memory_size,
                 .wasm_memory_grow,
                 .prefetch,
-                .fence,
                 .set_float_mode,
                 .set_align_stack,
                 .error_cast,
diff --git a/zig/lib/std/zig/system.zig b/zig/lib/std/zig/system.zig
index 046bd3854e..5feb08ab28 100644
--- a/zig/lib/std/zig/system.zig
+++ b/zig/lib/std/zig/system.zig
@@ -172,6 +172,7 @@ pub const DetectError = error{
     DeviceBusy,
     OSVersionDetectionFail,
     Unexpected,
+    ProcessNotFound,
 };
 
 /// Given a `Target.Query`, which specifies in detail which parts of the
@@ -385,6 +386,16 @@ pub fn resolveTargetQuery(query: Target.Query) DetectError!Target {
         query.cpu_features_sub,
     );
 
+    if (cpu_arch == .hexagon) {
+        // Both LLVM and LLD have broken support for the small data area. Yet LLVM has the feature
+        // on by default for all Hexagon CPUs. Clang sort of solves this by defaulting the `-gpsize`
+        // command line parameter for the Hexagon backend to 0, so that no constants get placed in
+        // the SDA. (This of course breaks down if the user passes `-G <n>` to Clang...) We can't do
+        // the `-gpsize` hack because we can have multiple concurrent LLVM emit jobs, and command
+        // line options in LLVM are shared globally. So just force this feature off. Lovely stuff.
+        result.cpu.features.removeFeature(@intFromEnum(Target.hexagon.Feature.small_data));
+    }
+
     // https://github.com/llvm/llvm-project/issues/105978
     if (result.cpu.arch.isArmOrThumb() and result.floatAbi() == .soft) {
         result.cpu.features.removeFeature(@intFromEnum(Target.arm.Feature.vfp2));
@@ -443,6 +454,7 @@ pub const AbiAndDynamicLinkerFromFileError = error{
     Unexpected,
     UnexpectedEndOfFile,
     NameTooLong,
+    ProcessNotFound,
 };
 
 pub fn abiAndDynamicLinkerFromFile(
@@ -831,6 +843,7 @@ fn glibcVerFromRPath(rpath: []const u8) !std.SemanticVersion {
         error.UnableToReadElfFile,
         error.Unexpected,
         error.FileSystem,
+        error.ProcessNotFound,
         => |e| return e,
     };
 }
@@ -1077,6 +1090,7 @@ fn detectAbiAndDynamicLinker(
             const len = preadAtLeast(file, &buffer, 0, min_len) catch |err| switch (err) {
                 error.UnexpectedEndOfFile,
                 error.UnableToReadElfFile,
+                error.ProcessNotFound,
                 => return defaultAbiAndDynamicLinker(cpu, os, query),
 
                 else => |e| return e,
@@ -1120,6 +1134,7 @@ fn detectAbiAndDynamicLinker(
         error.SymLinkLoop,
         error.ProcessFdQuotaExceeded,
         error.SystemFdQuotaExceeded,
+        error.ProcessNotFound,
         => |e| return e,
 
         error.UnableToReadElfFile,
@@ -1147,7 +1162,7 @@ fn defaultAbiAndDynamicLinker(cpu: Target.Cpu, os: Target.Os, query: Target.Quer
         .abi = abi,
         .ofmt = query.ofmt orelse Target.ObjectFormat.default(os.tag, cpu.arch),
         .dynamic_linker = if (query.dynamic_linker.get() == null)
-            Target.DynamicLinker.standard(cpu, os.tag, abi)
+            Target.DynamicLinker.standard(cpu, os, abi)
         else
             query.dynamic_linker,
     };
@@ -1176,6 +1191,8 @@ fn preadAtLeast(file: fs.File, buf: []u8, offset: u64, min_read_len: usize) !usi
             error.Unexpected => return error.Unexpected,
             error.InputOutput => return error.FileSystem,
             error.AccessDenied => return error.Unexpected,
+            error.ProcessNotFound => return error.ProcessNotFound,
+            error.LockViolation => return error.UnableToReadElfFile,
         };
         if (len == 0) return error.UnexpectedEndOfFile;
         i += len;
diff --git a/zig/lib/std/zig/target.zig b/zig/lib/std/zig/target.zig
index b60586da85..59fccc582c 100644
--- a/zig/lib/std/zig/target.zig
+++ b/zig/lib/std/zig/target.zig
@@ -35,6 +35,7 @@ pub const available_libcs = [_]ArchOsAbi{
     .{ .arch = .x86, .os = .linux, .abi = .musl },
     .{ .arch = .x86, .os = .windows, .abi = .gnu },
     .{ .arch = .loongarch64, .os = .linux, .abi = .gnu, .glibc_min = .{ .major = 2, .minor = 36, .patch = 0 } },
+    .{ .arch = .loongarch64, .os = .linux, .abi = .gnusf, .glibc_min = .{ .major = 2, .minor = 36, .patch = 0 } },
     .{ .arch = .loongarch64, .os = .linux, .abi = .musl },
     .{ .arch = .m68k, .os = .linux, .abi = .gnu },
     .{ .arch = .m68k, .os = .linux, .abi = .musl },
diff --git a/zig/lib/std/zig/tokenizer.zig b/zig/lib/std/zig/tokenizer.zig
index db69693a93..7f82db786f 100644
--- a/zig/lib/std/zig/tokenizer.zig
+++ b/zig/lib/std/zig/tokenizer.zig
@@ -535,6 +535,8 @@ pub const Tokenizer = struct {
                 switch (self.buffer[self.index]) {
                     0 => if (self.index == self.buffer.len) {
                         result.tag = .invalid;
+                    } else {
+                        continue :state .invalid;
                     },
                     '\n' => result.tag = .invalid,
                     else => continue :state .invalid,
@@ -1250,6 +1252,7 @@ test "invalid token characters" {
 
 test "invalid literal/comment characters" {
     try testTokenize("\"\x00\"", &.{.invalid});
+    try testTokenize("`\x00`", &.{.invalid});
     try testTokenize("//\x00", &.{.invalid});
     try testTokenize("//\x1f", &.{.invalid});
     try testTokenize("//\x7f", &.{.invalid});
diff --git a/zig/lib/tsan/builtins/assembly.h b/zig/lib/tsan/builtins/assembly.h
new file mode 100644
index 0000000000..8c42fc7734
--- /dev/null
+++ b/zig/lib/tsan/builtins/assembly.h
@@ -0,0 +1,293 @@
+//===-- assembly.h - compiler-rt assembler support macros -----------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines macros for use in compiler-rt assembler source.
+// This file is not part of the interface of this library.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef COMPILERRT_ASSEMBLY_H
+#define COMPILERRT_ASSEMBLY_H
+
+#if defined(__linux__) && defined(__CET__)
+#if __has_include(<cet.h>)
+#include <cet.h>
+#endif
+#endif
+
+#if defined(__APPLE__) && defined(__aarch64__)
+#define SEPARATOR %%
+#else
+#define SEPARATOR ;
+#endif
+
+#if defined(__APPLE__)
+#define HIDDEN(name) .private_extern name
+#define LOCAL_LABEL(name) L_##name
+// tell linker it can break up file at label boundaries
+#define FILE_LEVEL_DIRECTIVE .subsections_via_symbols
+#define SYMBOL_IS_FUNC(name)
+#define CONST_SECTION .const
+
+#define NO_EXEC_STACK_DIRECTIVE
+
+#elif defined(__ELF__)
+
+#define HIDDEN(name) .hidden name
+#define LOCAL_LABEL(name) .L_##name
+#define FILE_LEVEL_DIRECTIVE
+#if defined(__arm__) || defined(__aarch64__)
+#define SYMBOL_IS_FUNC(name) .type name,%function
+#else
+#define SYMBOL_IS_FUNC(name) .type name,@function
+#endif
+#define CONST_SECTION .section .rodata
+
+#if defined(__GNU__) || defined(__FreeBSD__) || defined(__Fuchsia__) ||        \
+    defined(__linux__)
+#define NO_EXEC_STACK_DIRECTIVE .section .note.GNU-stack,"",%progbits
+#else
+#define NO_EXEC_STACK_DIRECTIVE
+#endif
+
+#else // !__APPLE__ && !__ELF__
+
+#define HIDDEN(name)
+#define LOCAL_LABEL(name) .L ## name
+#define FILE_LEVEL_DIRECTIVE
+#define SYMBOL_IS_FUNC(name)                                                   \
+  .def name SEPARATOR                                                          \
+    .scl 2 SEPARATOR                                                           \
+    .type 32 SEPARATOR                                                         \
+  .endef
+#define CONST_SECTION .section .rdata,"rd"
+
+#define NO_EXEC_STACK_DIRECTIVE
+
+#endif
+
+#if defined(__arm__) || defined(__aarch64__)
+#define FUNC_ALIGN                                                             \
+  .text SEPARATOR                                                              \
+  .balign 16 SEPARATOR
+#else
+#define FUNC_ALIGN
+#endif
+
+// BTI and PAC gnu property note
+#define NT_GNU_PROPERTY_TYPE_0 5
+#define GNU_PROPERTY_AARCH64_FEATURE_1_AND 0xc0000000
+#define GNU_PROPERTY_AARCH64_FEATURE_1_BTI 1
+#define GNU_PROPERTY_AARCH64_FEATURE_1_PAC 2
+
+#if defined(__ARM_FEATURE_BTI_DEFAULT)
+#define BTI_FLAG GNU_PROPERTY_AARCH64_FEATURE_1_BTI
+#else
+#define BTI_FLAG 0
+#endif
+
+#if __ARM_FEATURE_PAC_DEFAULT & 3
+#define PAC_FLAG GNU_PROPERTY_AARCH64_FEATURE_1_PAC
+#else
+#define PAC_FLAG 0
+#endif
+
+#define GNU_PROPERTY(type, value)                                              \
+  .pushsection .note.gnu.property, "a" SEPARATOR                               \
+  .p2align 3 SEPARATOR                                                         \
+  .word 4 SEPARATOR                                                            \
+  .word 16 SEPARATOR                                                           \
+  .word NT_GNU_PROPERTY_TYPE_0 SEPARATOR                                       \
+  .asciz "GNU" SEPARATOR                                                       \
+  .word type SEPARATOR                                                         \
+  .word 4 SEPARATOR                                                            \
+  .word value SEPARATOR                                                        \
+  .word 0 SEPARATOR                                                            \
+  .popsection
+
+#if BTI_FLAG != 0
+#define BTI_C hint #34
+#define BTI_J hint #36
+#else
+#define BTI_C
+#define BTI_J
+#endif
+
+#if (BTI_FLAG | PAC_FLAG) != 0
+#define GNU_PROPERTY_BTI_PAC                                                   \
+  GNU_PROPERTY(GNU_PROPERTY_AARCH64_FEATURE_1_AND, BTI_FLAG | PAC_FLAG)
+#else
+#define GNU_PROPERTY_BTI_PAC
+#endif
+
+#if defined(__clang__) || defined(__GCC_HAVE_DWARF2_CFI_ASM)
+#define CFI_START .cfi_startproc
+#define CFI_END .cfi_endproc
+#else
+#define CFI_START
+#define CFI_END
+#endif
+
+#if defined(__arm__)
+
+// Determine actual [ARM][THUMB[1][2]] ISA using compiler predefined macros:
+// - for '-mthumb -march=armv6' compiler defines '__thumb__'
+// - for '-mthumb -march=armv7' compiler defines '__thumb__' and '__thumb2__'
+#if defined(__thumb2__) || defined(__thumb__)
+#define DEFINE_CODE_STATE .thumb SEPARATOR
+#define DECLARE_FUNC_ENCODING    .thumb_func SEPARATOR
+#if defined(__thumb2__)
+#define USE_THUMB_2
+#define IT(cond)  it cond
+#define ITT(cond) itt cond
+#define ITE(cond) ite cond
+#else
+#define USE_THUMB_1
+#define IT(cond)
+#define ITT(cond)
+#define ITE(cond)
+#endif // defined(__thumb__2)
+#else // !defined(__thumb2__) && !defined(__thumb__)
+#define DEFINE_CODE_STATE .arm SEPARATOR
+#define DECLARE_FUNC_ENCODING
+#define IT(cond)
+#define ITT(cond)
+#define ITE(cond)
+#endif
+
+#if defined(USE_THUMB_1) && defined(USE_THUMB_2)
+#error "USE_THUMB_1 and USE_THUMB_2 can't be defined together."
+#endif
+
+#if defined(__ARM_ARCH_4T__) || __ARM_ARCH >= 5
+#define ARM_HAS_BX
+#endif
+#if !defined(__ARM_FEATURE_CLZ) && !defined(USE_THUMB_1) &&  \
+    (__ARM_ARCH >= 6 || (__ARM_ARCH == 5 && !defined(__ARM_ARCH_5__)))
+#define __ARM_FEATURE_CLZ
+#endif
+
+#ifdef ARM_HAS_BX
+#define JMP(r) bx r
+#define JMPc(r, c) bx##c r
+#else
+#define JMP(r) mov pc, r
+#define JMPc(r, c) mov##c pc, r
+#endif
+
+// pop {pc} can't switch Thumb mode on ARMv4T
+#if __ARM_ARCH >= 5
+#define POP_PC() pop {pc}
+#else
+#define POP_PC()                                                               \
+  pop {ip};                                                                    \
+  JMP(ip)
+#endif
+
+#if defined(USE_THUMB_2)
+#define WIDE(op) op.w
+#else
+#define WIDE(op) op
+#endif
+#else // !defined(__arm)
+#define DECLARE_FUNC_ENCODING
+#define DEFINE_CODE_STATE
+#endif
+
+#define GLUE2_(a, b) a##b
+#define GLUE(a, b) GLUE2_(a, b)
+#define GLUE2(a, b) GLUE2_(a, b)
+#define GLUE3_(a, b, c) a##b##c
+#define GLUE3(a, b, c) GLUE3_(a, b, c)
+#define GLUE4_(a, b, c, d) a##b##c##d
+#define GLUE4(a, b, c, d) GLUE4_(a, b, c, d)
+
+#define SYMBOL_NAME(name) GLUE(__USER_LABEL_PREFIX__, name)
+
+#ifdef VISIBILITY_HIDDEN
+#define DECLARE_SYMBOL_VISIBILITY(name)                                        \
+  HIDDEN(SYMBOL_NAME(name)) SEPARATOR
+#define DECLARE_SYMBOL_VISIBILITY_UNMANGLED(name) \
+  HIDDEN(name) SEPARATOR
+#else
+#define DECLARE_SYMBOL_VISIBILITY(name)
+#define DECLARE_SYMBOL_VISIBILITY_UNMANGLED(name)
+#endif
+
+#define DEFINE_COMPILERRT_FUNCTION(name)                                       \
+  DEFINE_CODE_STATE                                                            \
+  FILE_LEVEL_DIRECTIVE SEPARATOR                                               \
+  .globl SYMBOL_NAME(name) SEPARATOR                                           \
+  SYMBOL_IS_FUNC(SYMBOL_NAME(name)) SEPARATOR                                  \
+  DECLARE_SYMBOL_VISIBILITY(name)                                              \
+  DECLARE_FUNC_ENCODING                                                        \
+  SYMBOL_NAME(name):
+
+#define DEFINE_COMPILERRT_THUMB_FUNCTION(name)                                 \
+  DEFINE_CODE_STATE                                                            \
+  FILE_LEVEL_DIRECTIVE SEPARATOR                                               \
+  .globl SYMBOL_NAME(name) SEPARATOR                                           \
+  SYMBOL_IS_FUNC(SYMBOL_NAME(name)) SEPARATOR                                  \
+  DECLARE_SYMBOL_VISIBILITY(name) SEPARATOR                                    \
+  .thumb_func SEPARATOR                                                        \
+  SYMBOL_NAME(name):
+
+#define DEFINE_COMPILERRT_PRIVATE_FUNCTION(name)                               \
+  DEFINE_CODE_STATE                                                            \
+  FILE_LEVEL_DIRECTIVE SEPARATOR                                               \
+  .globl SYMBOL_NAME(name) SEPARATOR                                           \
+  SYMBOL_IS_FUNC(SYMBOL_NAME(name)) SEPARATOR                                  \
+  HIDDEN(SYMBOL_NAME(name)) SEPARATOR                                          \
+  DECLARE_FUNC_ENCODING                                                        \
+  SYMBOL_NAME(name):
+
+#define DEFINE_COMPILERRT_PRIVATE_FUNCTION_UNMANGLED(name)                     \
+  DEFINE_CODE_STATE                                                            \
+  .globl name SEPARATOR                                                        \
+  SYMBOL_IS_FUNC(name) SEPARATOR                                               \
+  HIDDEN(name) SEPARATOR                                                       \
+  DECLARE_FUNC_ENCODING                                                        \
+  name:
+
+#define DEFINE_COMPILERRT_OUTLINE_FUNCTION_UNMANGLED(name)                     \
+  DEFINE_CODE_STATE                                                            \
+  FUNC_ALIGN                                                                   \
+  .globl name SEPARATOR                                                        \
+  SYMBOL_IS_FUNC(name) SEPARATOR                                               \
+  DECLARE_SYMBOL_VISIBILITY_UNMANGLED(name) SEPARATOR                          \
+  DECLARE_FUNC_ENCODING                                                        \
+  name:                                                                        \
+  SEPARATOR CFI_START                                                          \
+  SEPARATOR BTI_C
+
+#define DEFINE_COMPILERRT_FUNCTION_ALIAS(name, target)                         \
+  .globl SYMBOL_NAME(name) SEPARATOR                                           \
+  SYMBOL_IS_FUNC(SYMBOL_NAME(name)) SEPARATOR                                  \
+  DECLARE_SYMBOL_VISIBILITY(name) SEPARATOR                                    \
+  .set SYMBOL_NAME(name), SYMBOL_NAME(target) SEPARATOR
+
+#if defined(__ARM_EABI__)
+#define DEFINE_AEABI_FUNCTION_ALIAS(aeabi_name, name)                          \
+  DEFINE_COMPILERRT_FUNCTION_ALIAS(aeabi_name, name)
+#else
+#define DEFINE_AEABI_FUNCTION_ALIAS(aeabi_name, name)
+#endif
+
+#ifdef __ELF__
+#define END_COMPILERRT_FUNCTION(name)                                          \
+  .size SYMBOL_NAME(name), . - SYMBOL_NAME(name)
+#define END_COMPILERRT_OUTLINE_FUNCTION(name)                                  \
+  CFI_END SEPARATOR                                                            \
+  .size SYMBOL_NAME(name), . - SYMBOL_NAME(name)
+#else
+#define END_COMPILERRT_FUNCTION(name)
+#define END_COMPILERRT_OUTLINE_FUNCTION(name)                                  \
+  CFI_END
+#endif
+
+#endif // COMPILERRT_ASSEMBLY_H
diff --git a/zig/lib/tsan/interception/interception.h b/zig/lib/tsan/interception/interception.h
index 069f73d276..38c152952e 100644
--- a/zig/lib/tsan/interception/interception.h
+++ b/zig/lib/tsan/interception/interception.h
@@ -185,6 +185,11 @@ const interpose_substitution substitution_##func_name[]             \
 #  else
 #   define __ASM_WEAK_WRAPPER(func) ".weak " #func "\n"
 #  endif  // SANITIZER_FREEBSD || SANITIZER_NETBSD
+#  if defined(__arm__) || defined(__aarch64__)
+#   define ASM_TYPE_FUNCTION_STR "%function"
+#  else
+#   define ASM_TYPE_FUNCTION_STR "@function"
+#  endif
 // Keep trampoline implementation in sync with sanitizer_common/sanitizer_asm.h
 #  define DECLARE_WRAPPER(ret_type, func, ...)                                 \
      extern "C" ret_type func(__VA_ARGS__);                                    \
@@ -196,12 +201,14 @@ const interpose_substitution substitution_##func_name[]             \
        __ASM_WEAK_WRAPPER(func)                                                \
        ".set " #func ", " SANITIZER_STRINGIFY(TRAMPOLINE(func)) "\n"           \
        ".globl " SANITIZER_STRINGIFY(TRAMPOLINE(func)) "\n"                    \
-       ".type  " SANITIZER_STRINGIFY(TRAMPOLINE(func)) ", %function\n"         \
+       ".type  " SANITIZER_STRINGIFY(TRAMPOLINE(func)) ", "                    \
+         ASM_TYPE_FUNCTION_STR "\n"                                            \
        SANITIZER_STRINGIFY(TRAMPOLINE(func)) ":\n"                             \
-       SANITIZER_STRINGIFY(CFI_STARTPROC) "\n"                                 \
-       SANITIZER_STRINGIFY(ASM_TAIL_CALL) " __interceptor_"                    \
-         SANITIZER_STRINGIFY(ASM_PREEMPTIBLE_SYM(func)) "\n"                   \
-       SANITIZER_STRINGIFY(CFI_ENDPROC) "\n"                                   \
+       C_ASM_STARTPROC "\n"                                                    \
+       C_ASM_TAIL_CALL(SANITIZER_STRINGIFY(TRAMPOLINE(func)),                  \
+                       "__interceptor_"                                        \
+                         SANITIZER_STRINGIFY(ASM_PREEMPTIBLE_SYM(func))) "\n"  \
+       C_ASM_ENDPROC "\n"                                                      \
        ".size  " SANITIZER_STRINGIFY(TRAMPOLINE(func)) ", "                    \
             ".-" SANITIZER_STRINGIFY(TRAMPOLINE(func)) "\n"                    \
      );
@@ -341,6 +348,18 @@ typedef unsigned long long uptr;
 #else
 typedef unsigned long uptr;
 #endif  // _WIN64
+
+#if defined(__ELF__) && !SANITIZER_FUCHSIA
+// The use of interceptors makes many sanitizers unusable for static linking.
+// Define a function, if called, will cause a linker error (undefined _DYNAMIC).
+// However, -static-pie (which is not common) cannot be detected at link time.
+extern uptr kDynamic[] asm("_DYNAMIC");
+inline void DoesNotSupportStaticLinking() {
+  [[maybe_unused]] volatile auto x = &kDynamic;
+}
+#else
+inline void DoesNotSupportStaticLinking() {}
+#endif
 }  // namespace __interception
 
 #define INCLUDED_FROM_INTERCEPTION_LIB
diff --git a/zig/lib/tsan/interception/interception_linux.h b/zig/lib/tsan/interception/interception_linux.h
index 433a3d9bd7..2e01ff4457 100644
--- a/zig/lib/tsan/interception/interception_linux.h
+++ b/zig/lib/tsan/interception/interception_linux.h
@@ -28,12 +28,14 @@ bool InterceptFunction(const char *name, const char *ver, uptr *ptr_to_real,
                        uptr func, uptr trampoline);
 }  // namespace __interception
 
-#define INTERCEPT_FUNCTION_LINUX_OR_FREEBSD(func) \
-  ::__interception::InterceptFunction(            \
-      #func,                                      \
-      (::__interception::uptr *)&REAL(func),      \
-      (::__interception::uptr)&(func),            \
-      (::__interception::uptr)&TRAMPOLINE(func))
+// Cast func to type of REAL(func) before casting to uptr in case it is an
+// overloaded function, which is the case for some glibc functions when
+// _FORTIFY_SOURCE is used. This disambiguates which overload to use.
+#define INTERCEPT_FUNCTION_LINUX_OR_FREEBSD(func)            \
+  ::__interception::InterceptFunction(                       \
+      #func, (::__interception::uptr *)&REAL(func),          \
+      (::__interception::uptr)(decltype(REAL(func)))&(func), \
+      (::__interception::uptr) &TRAMPOLINE(func))
 
 // dlvsym is a GNU extension supported by some other platforms.
 #if SANITIZER_GLIBC || SANITIZER_FREEBSD || SANITIZER_NETBSD
@@ -41,7 +43,7 @@ bool InterceptFunction(const char *name, const char *ver, uptr *ptr_to_real,
   ::__interception::InterceptFunction(                        \
       #func, symver,                                          \
       (::__interception::uptr *)&REAL(func),                  \
-      (::__interception::uptr)&(func),                        \
+      (::__interception::uptr)(decltype(REAL(func)))&(func),  \
       (::__interception::uptr)&TRAMPOLINE(func))
 #else
 #define INTERCEPT_FUNCTION_VER_LINUX_OR_FREEBSD(func, symver) \
diff --git a/zig/lib/tsan/interception/interception_win.cpp b/zig/lib/tsan/interception/interception_win.cpp
index 00c317510e..a638e66ecc 100644
--- a/zig/lib/tsan/interception/interception_win.cpp
+++ b/zig/lib/tsan/interception/interception_win.cpp
@@ -1,4 +1,4 @@
-//===-- interception_linux.cpp ----------------------------------*- C++ -*-===//
+//===-- interception_win.cpp ------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -339,7 +339,7 @@ struct TrampolineMemoryRegion {
   uptr max_size;
 };
 
-UNUSED static const uptr kTrampolineScanLimitRange = 1 << 31;  // 2 gig
+UNUSED static const uptr kTrampolineScanLimitRange = 1ull << 31;  // 2 gig
 static const int kMaxTrampolineRegion = 1024;
 static TrampolineMemoryRegion TrampolineRegions[kMaxTrampolineRegion];
 
@@ -431,7 +431,8 @@ static uptr AllocateMemoryForTrampoline(uptr image_address, size_t size) {
 // The following prologues cannot be patched because of the short jump
 // jumping to the patching region.
 
-#if SANITIZER_WINDOWS64
+// Short jump patterns  below are only for x86_64.
+#  if SANITIZER_WINDOWS_x64
 // ntdll!wcslen in Win11
 //   488bc1          mov     rax,rcx
 //   0fb710          movzx   edx,word ptr [rax]
@@ -457,7 +458,12 @@ static const u8 kPrologueWithShortJump2[] = {
 
 // Returns 0 on error.
 static size_t GetInstructionSize(uptr address, size_t* rel_offset = nullptr) {
-#if SANITIZER_WINDOWS64
+#if SANITIZER_ARM64
+  // An ARM64 instruction is 4 bytes long.
+  return 4;
+#endif
+
+#  if SANITIZER_WINDOWS_x64
   if (memcmp((u8*)address, kPrologueWithShortJump1,
              sizeof(kPrologueWithShortJump1)) == 0 ||
       memcmp((u8*)address, kPrologueWithShortJump2,
@@ -473,6 +479,8 @@ static size_t GetInstructionSize(uptr address, size_t* rel_offset = nullptr) {
 
   switch (*(u8*)address) {
     case 0x90:  // 90 : nop
+    case 0xC3:  // C3 : ret   (for small/empty function interception
+    case 0xCC:  // CC : int 3  i.e. registering weak functions)
       return 1;
 
     case 0x50:  // push eax / rax
@@ -496,7 +504,6 @@ static size_t GetInstructionSize(uptr address, size_t* rel_offset = nullptr) {
     // Cannot overwrite control-instruction. Return 0 to indicate failure.
     case 0xE9:  // E9 XX XX XX XX : jmp <label>
     case 0xE8:  // E8 XX XX XX XX : call <func>
-    case 0xC3:  // C3 : ret
     case 0xEB:  // EB XX : jmp XX (short jump)
     case 0x70:  // 7Y YY : jy XX (short conditional jump)
     case 0x71:
@@ -539,7 +546,12 @@ static size_t GetInstructionSize(uptr address, size_t* rel_offset = nullptr) {
       return 7;
   }
 
-#if SANITIZER_WINDOWS64
+  switch (0x000000FF & *(u32 *)address) {
+    case 0xc2:  // C2 XX XX : ret XX (needed for registering weak functions)
+      return 3;
+  }
+
+#  if SANITIZER_WINDOWS_x64
   switch (*(u8*)address) {
     case 0xA1:  // A1 XX XX XX XX XX XX XX XX :
                 //   movabs eax, dword ptr ds:[XXXXXXXX]
@@ -572,6 +584,7 @@ static size_t GetInstructionSize(uptr address, size_t* rel_offset = nullptr) {
     case 0x018a:  // mov al, byte ptr [rcx]
       return 2;
 
+    case 0x058A:  // 8A 05 XX XX XX XX : mov al, byte ptr [XX XX XX XX]
     case 0x058B:  // 8B 05 XX XX XX XX : mov eax, dword ptr [XX XX XX XX]
       if (rel_offset)
         *rel_offset = 2;
@@ -598,6 +611,7 @@ static size_t GetInstructionSize(uptr address, size_t* rel_offset = nullptr) {
     case 0xc18b4c:    // 4C 8B C1 : mov r8, rcx
     case 0xd2b60f:    // 0f b6 d2 : movzx edx, dl
     case 0xca2b48:    // 48 2b ca : sub rcx, rdx
+    case 0xca3b48:    // 48 3b ca : cmp rcx, rdx
     case 0x10b70f:    // 0f b7 10 : movzx edx, WORD PTR [rax]
     case 0xc00b4d:    // 3d 0b c0 : or r8, r8
     case 0xc08b41:    // 41 8b c0 : mov eax, r8d
@@ -617,9 +631,11 @@ static size_t GetInstructionSize(uptr address, size_t* rel_offset = nullptr) {
 
     case 0x058b48:    // 48 8b 05 XX XX XX XX :
                       //   mov rax, QWORD PTR [rip + XXXXXXXX]
+    case 0x058d48:    // 48 8d 05 XX XX XX XX :
+                      //   lea rax, QWORD PTR [rip + XXXXXXXX]
     case 0x25ff48:    // 48 ff 25 XX XX XX XX :
                       //   rex.W jmp QWORD PTR [rip + XXXXXXXX]
-
+    case 0x158D4C:    // 4c 8d 15 XX XX XX XX : lea r10, [rip + XX]
       // Instructions having offset relative to 'rip' need offset adjustment.
       if (rel_offset)
         *rel_offset = 3;
@@ -721,16 +737,22 @@ static bool CopyInstructions(uptr to, uptr from, size_t size) {
     size_t instruction_size = GetInstructionSize(from + cursor, &rel_offset);
     if (!instruction_size)
       return false;
-    _memcpy((void*)(to + cursor), (void*)(from + cursor),
+    _memcpy((void *)(to + cursor), (void *)(from + cursor),
             (size_t)instruction_size);
     if (rel_offset) {
-      uptr delta = to - from;
-      uptr relocated_offset = *(u32*)(to + cursor + rel_offset) - delta;
-#if SANITIZER_WINDOWS64
-      if (relocated_offset + 0x80000000U >= 0xFFFFFFFFU)
+#  if SANITIZER_WINDOWS64
+      // we want to make sure that the new relative offset still fits in 32-bits
+      // this will be untrue if relocated_offset \notin [-2**31, 2**31)
+      s64 delta = to - from;
+      s64 relocated_offset = *(s32 *)(to + cursor + rel_offset) - delta;
+      if (-0x8000'0000ll > relocated_offset || relocated_offset > 0x7FFF'FFFFll)
         return false;
-#endif
-      *(u32*)(to + cursor + rel_offset) = relocated_offset;
+#  else
+      // on 32-bit, the relative offset will always be correct
+      s32 delta = to - from;
+      s32 relocated_offset = *(s32 *)(to + cursor + rel_offset) - delta;
+#  endif
+      *(s32 *)(to + cursor + rel_offset) = relocated_offset;
     }
     cursor += instruction_size;
   }
@@ -932,19 +954,26 @@ bool OverrideFunction(
 
 static void **InterestingDLLsAvailable() {
   static const char *InterestingDLLs[] = {
-      "kernel32.dll",
-      "msvcr100.dll",      // VS2010
-      "msvcr110.dll",      // VS2012
-      "msvcr120.dll",      // VS2013
-      "vcruntime140.dll",  // VS2015
-      "ucrtbase.dll",      // Universal CRT
-#if (defined(__MINGW32__) && defined(__i386__))
-      "libc++.dll",        // libc++
-      "libunwind.dll",     // libunwind
-#endif
-      // NTDLL should go last as it exports some functions that we should
-      // override in the CRT [presumably only used internally].
-      "ntdll.dll", NULL};
+    "kernel32.dll",
+    "msvcr100d.dll",      // VS2010
+    "msvcr110d.dll",      // VS2012
+    "msvcr120d.dll",      // VS2013
+    "vcruntime140d.dll",  // VS2015
+    "ucrtbased.dll",      // Universal CRT
+    "msvcr100.dll",       // VS2010
+    "msvcr110.dll",       // VS2012
+    "msvcr120.dll",       // VS2013
+    "vcruntime140.dll",   // VS2015
+    "ucrtbase.dll",       // Universal CRT
+#  if (defined(__MINGW32__) && defined(__i386__))
+    "libc++.dll",     // libc++
+    "libunwind.dll",  // libunwind
+#  endif
+    // NTDLL should go last as it exports some functions that we should
+    // override in the CRT [presumably only used internally].
+    "ntdll.dll",
+    NULL
+  };
   static void *result[ARRAY_SIZE(InterestingDLLs)] = { 0 };
   if (!result[0]) {
     for (size_t i = 0, j = 0; InterestingDLLs[i]; ++i) {
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_allocator.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_allocator.cpp
index 03392b6150..1d5058c81a 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_allocator.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_allocator.cpp
@@ -25,7 +25,7 @@ namespace __sanitizer {
 const char *PrimaryAllocatorName = "SizeClassAllocator";
 const char *SecondaryAllocatorName = "LargeMmapAllocator";
 
-static ALIGNED(64) char internal_alloc_placeholder[sizeof(InternalAllocator)];
+alignas(64) static char internal_alloc_placeholder[sizeof(InternalAllocator)];
 static atomic_uint8_t internal_allocator_initialized;
 static StaticSpinMutex internal_alloc_init_mu;
 
@@ -138,14 +138,20 @@ void InternalAllocatorUnlock() SANITIZER_NO_THREAD_SAFETY_ANALYSIS {
 
 // LowLevelAllocator
 constexpr uptr kLowLevelAllocatorDefaultAlignment = 8;
+constexpr uptr kMinNumPagesRounded = 16;
+constexpr uptr kMinRoundedSize = 65536;
 static uptr low_level_alloc_min_alignment = kLowLevelAllocatorDefaultAlignment;
 static LowLevelAllocateCallback low_level_alloc_callback;
 
+static LowLevelAllocator Alloc;
+LowLevelAllocator &GetGlobalLowLevelAllocator() { return Alloc; }
+
 void *LowLevelAllocator::Allocate(uptr size) {
   // Align allocation size.
   size = RoundUpTo(size, low_level_alloc_min_alignment);
   if (allocated_end_ - allocated_current_ < (sptr)size) {
-    uptr size_to_allocate = RoundUpTo(size, GetPageSizeCached());
+    uptr size_to_allocate = RoundUpTo(
+        size, Min(GetPageSizeCached() * kMinNumPagesRounded, kMinRoundedSize));
     allocated_current_ = (char *)MmapOrDie(size_to_allocate, __func__);
     allocated_end_ = allocated_current_ + size_to_allocate;
     if (low_level_alloc_callback) {
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_allocator_interface.h b/zig/lib/tsan/sanitizer_common/sanitizer_allocator_interface.h
index de2b271fb0..d1a33a40ba 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_allocator_interface.h
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_allocator_interface.h
@@ -40,6 +40,8 @@ SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
     void __sanitizer_malloc_hook(void *ptr, uptr size);
 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
     void __sanitizer_free_hook(void *ptr);
+SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE int
+__sanitizer_ignore_free_hook(void *ptr);
 
 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void
 __sanitizer_purge_allocator();
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_allocator_primary32.h b/zig/lib/tsan/sanitizer_common/sanitizer_allocator_primary32.h
index 52fe3fe3d1..602b197c42 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_allocator_primary32.h
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_allocator_primary32.h
@@ -278,7 +278,7 @@ class SizeClassAllocator32 {
   static const uptr kRegionSize = 1 << kRegionSizeLog;
   static const uptr kNumPossibleRegions = kSpaceSize / kRegionSize;
 
-  struct ALIGNED(SANITIZER_CACHE_LINE_SIZE) SizeClassInfo {
+  struct alignas(SANITIZER_CACHE_LINE_SIZE) SizeClassInfo {
     StaticSpinMutex mutex;
     IntrusiveList<TransferBatch> free_list;
     u32 rand_state;
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_allocator_primary64.h b/zig/lib/tsan/sanitizer_common/sanitizer_allocator_primary64.h
index fa43ac50c6..0b0bdb0704 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_allocator_primary64.h
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_allocator_primary64.h
@@ -316,13 +316,13 @@ class SizeClassAllocator64 {
     Printf(
         "%s %02zd (%6zd): mapped: %6zdK allocs: %7zd frees: %7zd inuse: %6zd "
         "num_freed_chunks %7zd avail: %6zd rss: %6zdK releases: %6zd "
-        "last released: %6lldK region: 0x%zx\n",
+        "last released: %6lldK region: %p\n",
         region->exhausted ? "F" : " ", class_id, ClassIdToSize(class_id),
         region->mapped_user >> 10, region->stats.n_allocated,
         region->stats.n_freed, in_use, region->num_freed_chunks, avail_chunks,
         rss >> 10, region->rtoi.num_releases,
         region->rtoi.last_released_bytes >> 10,
-        SpaceBeg() + kRegionSize * class_id);
+        (void *)(SpaceBeg() + kRegionSize * class_id));
   }
 
   void PrintStats() {
@@ -636,15 +636,17 @@ class SizeClassAllocator64 {
   }
   uptr SpaceEnd() const { return  SpaceBeg() + kSpaceSize; }
   // kRegionSize should be able to satisfy the largest size class.
-  static_assert(kRegionSize >= SizeClassMap::kMaxSize);
+  static_assert(kRegionSize >= SizeClassMap::kMaxSize,
+                "Region size exceed largest size");
   // kRegionSize must be <= 2^36, see CompactPtrT.
-  COMPILER_CHECK((kRegionSize) <= (1ULL << (SANITIZER_WORDSIZE / 2 + 4)));
+  COMPILER_CHECK((kRegionSize) <=
+                 (1ULL << (sizeof(CompactPtrT) * 8 + kCompactPtrScale)));
   // Call mmap for user memory with at least this size.
-  static const uptr kUserMapSize = 1 << 16;
+  static const uptr kUserMapSize = 1 << 18;
   // Call mmap for metadata memory with at least this size.
   static const uptr kMetaMapSize = 1 << 16;
   // Call mmap for free array memory with at least this size.
-  static const uptr kFreeArrayMapSize = 1 << 16;
+  static const uptr kFreeArrayMapSize = 1 << 18;
 
   atomic_sint32_t release_to_os_interval_ms_;
 
@@ -665,7 +667,7 @@ class SizeClassAllocator64 {
     u64 last_released_bytes;
   };
 
-  struct ALIGNED(SANITIZER_CACHE_LINE_SIZE) RegionInfo {
+  struct alignas(SANITIZER_CACHE_LINE_SIZE) RegionInfo {
     Mutex mutex;
     uptr num_freed_chunks;  // Number of elements in the freearray.
     uptr mapped_free_array;  // Bytes mapped for freearray.
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_asm.h b/zig/lib/tsan/sanitizer_common/sanitizer_asm.h
index 3c9bbdc967..30e9d15184 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_asm.h
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_asm.h
@@ -42,6 +42,16 @@
 # define CFI_RESTORE(reg)
 #endif
 
+#if defined(__aarch64__) && defined(__ARM_FEATURE_BTI_DEFAULT)
+# define ASM_STARTPROC CFI_STARTPROC; hint #34
+# define C_ASM_STARTPROC SANITIZER_STRINGIFY(CFI_STARTPROC) "\nhint #34"
+#else
+# define ASM_STARTPROC CFI_STARTPROC
+# define C_ASM_STARTPROC SANITIZER_STRINGIFY(CFI_STARTPROC)
+#endif
+#define ASM_ENDPROC CFI_ENDPROC
+#define C_ASM_ENDPROC SANITIZER_STRINGIFY(CFI_ENDPROC)
+
 #if defined(__x86_64__) || defined(__i386__) || defined(__sparc__)
 # define ASM_TAIL_CALL jmp
 #elif defined(__arm__) || defined(__aarch64__) || defined(__mips__) || \
@@ -53,6 +63,29 @@
 # define ASM_TAIL_CALL tail
 #endif
 
+// Currently, almost all of the shared libraries rely on the value of
+// $t9 to get the address of current function, instead of PCREL, even
+// on MIPSr6. To be compatiable with them, we have to set $t9 properly.
+// MIPS uses GOT to get the address of preemptible functions.
+#if defined(__mips64)
+#  define C_ASM_TAIL_CALL(t_func, i_func)                       \
+    "lui $t8, %hi(%neg(%gp_rel(" t_func ")))\n"                 \
+    "daddu $t8, $t8, $t9\n"                                     \
+    "daddiu $t8, $t8, %lo(%neg(%gp_rel(" t_func ")))\n"         \
+    "ld $t9, %got_disp(" i_func ")($t8)\n"                      \
+    "jr $t9\n"
+#elif defined(__mips__)
+#  define C_ASM_TAIL_CALL(t_func, i_func)                       \
+    ".set    noreorder\n"                                       \
+    ".cpload $t9\n"                                             \
+    ".set    reorder\n"                                         \
+    "lw $t9, %got(" i_func ")($gp)\n"                           \
+    "jr $t9\n"
+#elif defined(ASM_TAIL_CALL)
+#  define C_ASM_TAIL_CALL(t_func, i_func)                       \
+    SANITIZER_STRINGIFY(ASM_TAIL_CALL) " " i_func
+#endif
+
 #if defined(__ELF__) && defined(__x86_64__) || defined(__i386__) || \
     defined(__riscv)
 # define ASM_PREEMPTIBLE_SYM(sym) sym@plt
@@ -62,7 +95,11 @@
 
 #if !defined(__APPLE__)
 # define ASM_HIDDEN(symbol) .hidden symbol
-# define ASM_TYPE_FUNCTION(symbol) .type symbol, %function
+# if defined(__arm__) || defined(__aarch64__)
+#  define ASM_TYPE_FUNCTION(symbol) .type symbol, %function
+# else
+#  define ASM_TYPE_FUNCTION(symbol) .type symbol, @function
+# endif
 # define ASM_SIZE(symbol) .size symbol, .-symbol
 # define ASM_SYMBOL(symbol) symbol
 # define ASM_SYMBOL_INTERCEPTOR(symbol) symbol
@@ -87,9 +124,9 @@
          .globl __interceptor_trampoline_##name;                               \
          ASM_TYPE_FUNCTION(__interceptor_trampoline_##name);                   \
          __interceptor_trampoline_##name:                                      \
-                 CFI_STARTPROC;                                                \
+                 ASM_STARTPROC;                                                \
                  ASM_TAIL_CALL ASM_PREEMPTIBLE_SYM(__interceptor_##name);      \
-                 CFI_ENDPROC;                                                  \
+                 ASM_ENDPROC;                                                  \
          ASM_SIZE(__interceptor_trampoline_##name)
 #  define ASM_INTERCEPTOR_TRAMPOLINE_SUPPORT 1
 # endif  // Architecture supports interceptor trampoline
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_atomic.h b/zig/lib/tsan/sanitizer_common/sanitizer_atomic.h
index 46f0695722..257c457351 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_atomic.h
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_atomic.h
@@ -18,12 +18,24 @@
 namespace __sanitizer {
 
 enum memory_order {
+// If the __atomic atomic builtins are supported (Clang/GCC), use the
+// compiler provided macro values so that we can map the atomic operations
+// to __atomic_* directly.
+#ifdef __ATOMIC_SEQ_CST
+  memory_order_relaxed = __ATOMIC_RELAXED,
+  memory_order_consume = __ATOMIC_CONSUME,
+  memory_order_acquire = __ATOMIC_ACQUIRE,
+  memory_order_release = __ATOMIC_RELEASE,
+  memory_order_acq_rel = __ATOMIC_ACQ_REL,
+  memory_order_seq_cst = __ATOMIC_SEQ_CST
+#else
   memory_order_relaxed = 1 << 0,
   memory_order_consume = 1 << 1,
   memory_order_acquire = 1 << 2,
   memory_order_release = 1 << 3,
   memory_order_acq_rel = 1 << 4,
   memory_order_seq_cst = 1 << 5
+#endif
 };
 
 struct atomic_uint8_t {
@@ -49,7 +61,7 @@ struct atomic_uint32_t {
 struct atomic_uint64_t {
   typedef u64 Type;
   // On 32-bit platforms u64 is not necessary aligned on 8 bytes.
-  volatile ALIGNED(8) Type val_dont_use;
+  alignas(8) volatile Type val_dont_use;
 };
 
 struct atomic_uintptr_t {
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_atomic_clang.h b/zig/lib/tsan/sanitizer_common/sanitizer_atomic_clang.h
index 4318d64d16..1414092e38 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_atomic_clang.h
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_atomic_clang.h
@@ -14,60 +14,63 @@
 #ifndef SANITIZER_ATOMIC_CLANG_H
 #define SANITIZER_ATOMIC_CLANG_H
 
-#if defined(__i386__) || defined(__x86_64__)
-# include "sanitizer_atomic_clang_x86.h"
-#else
-# include "sanitizer_atomic_clang_other.h"
-#endif
-
 namespace __sanitizer {
 
-// We would like to just use compiler builtin atomic operations
-// for loads and stores, but they are mostly broken in clang:
-// - they lead to vastly inefficient code generation
-// (http://llvm.org/bugs/show_bug.cgi?id=17281)
-// - 64-bit atomic operations are not implemented on x86_32
-// (http://llvm.org/bugs/show_bug.cgi?id=15034)
-// - they are not implemented on ARM
-// error: undefined reference to '__atomic_load_4'
+// We use the compiler builtin atomic operations for loads and stores, which
+// generates correct code for all architectures, but may require libatomic
+// on platforms where e.g. 64-bit atomics are not supported natively.
 
 // See http://www.cl.cam.ac.uk/~pes20/cpp/cpp0xmappings.html
 // for mappings of the memory model to different processors.
 
-inline void atomic_signal_fence(memory_order) {
+inline void atomic_signal_fence(memory_order mo) { __atomic_signal_fence(mo); }
+
+inline void atomic_thread_fence(memory_order mo) { __atomic_thread_fence(mo); }
+
+inline void proc_yield(int cnt) {
+  __asm__ __volatile__("" ::: "memory");
+#if defined(__i386__) || defined(__x86_64__)
+  for (int i = 0; i < cnt; i++) __asm__ __volatile__("pause");
   __asm__ __volatile__("" ::: "memory");
+#endif
 }
 
-inline void atomic_thread_fence(memory_order) {
-  __sync_synchronize();
+template <typename T>
+inline typename T::Type atomic_load(const volatile T *a, memory_order mo) {
+  DCHECK(mo == memory_order_relaxed || mo == memory_order_consume ||
+         mo == memory_order_acquire || mo == memory_order_seq_cst);
+  DCHECK(!((uptr)a % sizeof(*a)));
+  return __atomic_load_n(&a->val_dont_use, mo);
 }
 
-template<typename T>
-inline typename T::Type atomic_fetch_add(volatile T *a,
-    typename T::Type v, memory_order mo) {
-  (void)mo;
+template <typename T>
+inline void atomic_store(volatile T *a, typename T::Type v, memory_order mo) {
+  DCHECK(mo == memory_order_relaxed || mo == memory_order_release ||
+         mo == memory_order_seq_cst);
   DCHECK(!((uptr)a % sizeof(*a)));
-  return __sync_fetch_and_add(&a->val_dont_use, v);
+  __atomic_store_n(&a->val_dont_use, v, mo);
 }
 
-template<typename T>
-inline typename T::Type atomic_fetch_sub(volatile T *a,
-    typename T::Type v, memory_order mo) {
+template <typename T>
+inline typename T::Type atomic_fetch_add(volatile T *a, typename T::Type v,
+                                         memory_order mo) {
+  DCHECK(!((uptr)a % sizeof(*a)));
+  return __atomic_fetch_add(&a->val_dont_use, v, mo);
+}
+
+template <typename T>
+inline typename T::Type atomic_fetch_sub(volatile T *a, typename T::Type v,
+                                         memory_order mo) {
   (void)mo;
   DCHECK(!((uptr)a % sizeof(*a)));
-  return __sync_fetch_and_add(&a->val_dont_use, -v);
+  return __atomic_fetch_sub(&a->val_dont_use, v, mo);
 }
 
-template<typename T>
-inline typename T::Type atomic_exchange(volatile T *a,
-    typename T::Type v, memory_order mo) {
+template <typename T>
+inline typename T::Type atomic_exchange(volatile T *a, typename T::Type v,
+                                        memory_order mo) {
   DCHECK(!((uptr)a % sizeof(*a)));
-  if (mo & (memory_order_release | memory_order_acq_rel | memory_order_seq_cst))
-    __sync_synchronize();
-  v = __sync_lock_test_and_set(&a->val_dont_use, v);
-  if (mo == memory_order_seq_cst)
-    __sync_synchronize();
-  return v;
+  return __atomic_exchange_n(&a->val_dont_use, v, mo);
 }
 
 template <typename T>
@@ -82,9 +85,8 @@ inline bool atomic_compare_exchange_strong(volatile T *a, typename T::Type *cmp,
                                    __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
 }
 
-template<typename T>
-inline bool atomic_compare_exchange_weak(volatile T *a,
-                                         typename T::Type *cmp,
+template <typename T>
+inline bool atomic_compare_exchange_weak(volatile T *a, typename T::Type *cmp,
                                          typename T::Type xchg,
                                          memory_order mo) {
   return atomic_compare_exchange_strong(a, cmp, xchg, mo);
@@ -92,13 +94,6 @@ inline bool atomic_compare_exchange_weak(volatile T *a,
 
 }  // namespace __sanitizer
 
-// This include provides explicit template instantiations for atomic_uint64_t
-// on MIPS32, which does not directly support 8 byte atomics. It has to
-// proceed the template definitions above.
-#if defined(_MIPS_SIM) && defined(_ABIO32) && _MIPS_SIM == _ABIO32
-#  include "sanitizer_atomic_clang_mips.h"
-#endif
-
 #undef ATOMIC_ORDER
 
 #endif  // SANITIZER_ATOMIC_CLANG_H
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_atomic_clang_mips.h b/zig/lib/tsan/sanitizer_common/sanitizer_atomic_clang_mips.h
deleted file mode 100644
index f3d3052e5b..0000000000
--- a/zig/lib/tsan/sanitizer_common/sanitizer_atomic_clang_mips.h
+++ /dev/null
@@ -1,117 +0,0 @@
-//===-- sanitizer_atomic_clang_mips.h ---------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file is a part of ThreadSanitizer/AddressSanitizer runtime.
-// Not intended for direct inclusion. Include sanitizer_atomic.h.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef SANITIZER_ATOMIC_CLANG_MIPS_H
-#define SANITIZER_ATOMIC_CLANG_MIPS_H
-
-namespace __sanitizer {
-
-// MIPS32 does not support atomics > 4 bytes. To address this lack of
-// functionality, the sanitizer library provides helper methods which use an
-// internal spin lock mechanism to emulate atomic operations when the size is
-// 8 bytes.
-static void __spin_lock(volatile int *lock) {
-  while (__sync_lock_test_and_set(lock, 1))
-    while (*lock) {
-    }
-}
-
-static void __spin_unlock(volatile int *lock) { __sync_lock_release(lock); }
-
-// Make sure the lock is on its own cache line to prevent false sharing.
-// Put it inside a struct that is aligned and padded to the typical MIPS
-// cacheline which is 32 bytes.
-static struct {
-  int lock;
-  char pad[32 - sizeof(int)];
-} __attribute__((aligned(32))) lock = {0, {0}};
-
-template <>
-inline atomic_uint64_t::Type atomic_fetch_add(volatile atomic_uint64_t *ptr,
-                                              atomic_uint64_t::Type val,
-                                              memory_order mo) {
-  DCHECK(mo &
-         (memory_order_relaxed | memory_order_release | memory_order_seq_cst));
-  DCHECK(!((uptr)ptr % sizeof(*ptr)));
-
-  atomic_uint64_t::Type ret;
-
-  __spin_lock(&lock.lock);
-  ret = *(const_cast<atomic_uint64_t::Type volatile *>(&ptr->val_dont_use));
-  ptr->val_dont_use = ret + val;
-  __spin_unlock(&lock.lock);
-
-  return ret;
-}
-
-template <>
-inline atomic_uint64_t::Type atomic_fetch_sub(volatile atomic_uint64_t *ptr,
-                                              atomic_uint64_t::Type val,
-                                              memory_order mo) {
-  return atomic_fetch_add(ptr, -val, mo);
-}
-
-template <>
-inline bool atomic_compare_exchange_strong(volatile atomic_uint64_t *ptr,
-                                           atomic_uint64_t::Type *cmp,
-                                           atomic_uint64_t::Type xchg,
-                                           memory_order mo) {
-  DCHECK(mo &
-         (memory_order_relaxed | memory_order_release | memory_order_seq_cst));
-  DCHECK(!((uptr)ptr % sizeof(*ptr)));
-
-  typedef atomic_uint64_t::Type Type;
-  Type cmpv = *cmp;
-  Type prev;
-  bool ret = false;
-
-  __spin_lock(&lock.lock);
-  prev = *(const_cast<Type volatile *>(&ptr->val_dont_use));
-  if (prev == cmpv) {
-    ret = true;
-    ptr->val_dont_use = xchg;
-  }
-  __spin_unlock(&lock.lock);
-
-  return ret;
-}
-
-template <>
-inline atomic_uint64_t::Type atomic_load(const volatile atomic_uint64_t *ptr,
-                                         memory_order mo) {
-  DCHECK(mo &
-         (memory_order_relaxed | memory_order_release | memory_order_seq_cst));
-  DCHECK(!((uptr)ptr % sizeof(*ptr)));
-
-  atomic_uint64_t::Type zero = 0;
-  volatile atomic_uint64_t *Newptr =
-      const_cast<volatile atomic_uint64_t *>(ptr);
-  return atomic_fetch_add(Newptr, zero, mo);
-}
-
-template <>
-inline void atomic_store(volatile atomic_uint64_t *ptr, atomic_uint64_t::Type v,
-                         memory_order mo) {
-  DCHECK(mo &
-         (memory_order_relaxed | memory_order_release | memory_order_seq_cst));
-  DCHECK(!((uptr)ptr % sizeof(*ptr)));
-
-  __spin_lock(&lock.lock);
-  ptr->val_dont_use = v;
-  __spin_unlock(&lock.lock);
-}
-
-}  // namespace __sanitizer
-
-#endif  // SANITIZER_ATOMIC_CLANG_MIPS_H
-
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_atomic_clang_other.h b/zig/lib/tsan/sanitizer_common/sanitizer_atomic_clang_other.h
deleted file mode 100644
index 4a39889e53..0000000000
--- a/zig/lib/tsan/sanitizer_common/sanitizer_atomic_clang_other.h
+++ /dev/null
@@ -1,85 +0,0 @@
-//===-- sanitizer_atomic_clang_other.h --------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file is a part of ThreadSanitizer/AddressSanitizer runtime.
-// Not intended for direct inclusion. Include sanitizer_atomic.h.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef SANITIZER_ATOMIC_CLANG_OTHER_H
-#define SANITIZER_ATOMIC_CLANG_OTHER_H
-
-namespace __sanitizer {
-
-
-inline void proc_yield(int cnt) {
-  __asm__ __volatile__("" ::: "memory");
-}
-
-template<typename T>
-inline typename T::Type atomic_load(
-    const volatile T *a, memory_order mo) {
-  DCHECK(mo & (memory_order_relaxed | memory_order_consume
-      | memory_order_acquire | memory_order_seq_cst));
-  DCHECK(!((uptr)a % sizeof(*a)));
-  typename T::Type v;
-
-  if (sizeof(*a) < 8 || sizeof(void*) == 8) {
-    // Assume that aligned loads are atomic.
-    if (mo == memory_order_relaxed) {
-      v = a->val_dont_use;
-    } else if (mo == memory_order_consume) {
-      // Assume that processor respects data dependencies
-      // (and that compiler won't break them).
-      __asm__ __volatile__("" ::: "memory");
-      v = a->val_dont_use;
-      __asm__ __volatile__("" ::: "memory");
-    } else if (mo == memory_order_acquire) {
-      __asm__ __volatile__("" ::: "memory");
-      v = a->val_dont_use;
-      __sync_synchronize();
-    } else {  // seq_cst
-      // E.g. on POWER we need a hw fence even before the store.
-      __sync_synchronize();
-      v = a->val_dont_use;
-      __sync_synchronize();
-    }
-  } else {
-    __atomic_load(const_cast<typename T::Type volatile *>(&a->val_dont_use), &v,
-                  __ATOMIC_SEQ_CST);
-  }
-  return v;
-}
-
-template<typename T>
-inline void atomic_store(volatile T *a, typename T::Type v, memory_order mo) {
-  DCHECK(mo & (memory_order_relaxed | memory_order_release
-      | memory_order_seq_cst));
-  DCHECK(!((uptr)a % sizeof(*a)));
-
-  if (sizeof(*a) < 8 || sizeof(void*) == 8) {
-    // Assume that aligned loads are atomic.
-    if (mo == memory_order_relaxed) {
-      a->val_dont_use = v;
-    } else if (mo == memory_order_release) {
-      __sync_synchronize();
-      a->val_dont_use = v;
-      __asm__ __volatile__("" ::: "memory");
-    } else {  // seq_cst
-      __sync_synchronize();
-      a->val_dont_use = v;
-      __sync_synchronize();
-    }
-  } else {
-    __atomic_store(&a->val_dont_use, &v, __ATOMIC_SEQ_CST);
-  }
-}
-
-}  // namespace __sanitizer
-
-#endif  // #ifndef SANITIZER_ATOMIC_CLANG_OTHER_H
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_atomic_clang_x86.h b/zig/lib/tsan/sanitizer_common/sanitizer_atomic_clang_x86.h
deleted file mode 100644
index 51597b4927..0000000000
--- a/zig/lib/tsan/sanitizer_common/sanitizer_atomic_clang_x86.h
+++ /dev/null
@@ -1,113 +0,0 @@
-//===-- sanitizer_atomic_clang_x86.h ----------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file is a part of ThreadSanitizer/AddressSanitizer runtime.
-// Not intended for direct inclusion. Include sanitizer_atomic.h.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef SANITIZER_ATOMIC_CLANG_X86_H
-#define SANITIZER_ATOMIC_CLANG_X86_H
-
-namespace __sanitizer {
-
-inline void proc_yield(int cnt) {
-  __asm__ __volatile__("" ::: "memory");
-  for (int i = 0; i < cnt; i++)
-    __asm__ __volatile__("pause");
-  __asm__ __volatile__("" ::: "memory");
-}
-
-template<typename T>
-inline typename T::Type atomic_load(
-    const volatile T *a, memory_order mo) {
-  DCHECK(mo & (memory_order_relaxed | memory_order_consume
-      | memory_order_acquire | memory_order_seq_cst));
-  DCHECK(!((uptr)a % sizeof(*a)));
-  typename T::Type v;
-
-  if (sizeof(*a) < 8 || sizeof(void*) == 8) {
-    // Assume that aligned loads are atomic.
-    if (mo == memory_order_relaxed) {
-      v = a->val_dont_use;
-    } else if (mo == memory_order_consume) {
-      // Assume that processor respects data dependencies
-      // (and that compiler won't break them).
-      __asm__ __volatile__("" ::: "memory");
-      v = a->val_dont_use;
-      __asm__ __volatile__("" ::: "memory");
-    } else if (mo == memory_order_acquire) {
-      __asm__ __volatile__("" ::: "memory");
-      v = a->val_dont_use;
-      // On x86 loads are implicitly acquire.
-      __asm__ __volatile__("" ::: "memory");
-    } else {  // seq_cst
-      // On x86 plain MOV is enough for seq_cst store.
-      __asm__ __volatile__("" ::: "memory");
-      v = a->val_dont_use;
-      __asm__ __volatile__("" ::: "memory");
-    }
-  } else {
-    // 64-bit load on 32-bit platform.
-    __asm__ __volatile__(
-        "movq %1, %%mm0;"  // Use mmx reg for 64-bit atomic moves
-        "movq %%mm0, %0;"  // (ptr could be read-only)
-        "emms;"            // Empty mmx state/Reset FP regs
-        : "=m" (v)
-        : "m" (a->val_dont_use)
-        : // mark the mmx registers as clobbered
-#ifdef __MMX__
-          "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
-#endif  // #ifdef __MMX__
-          "memory");
-  }
-  return v;
-}
-
-template<typename T>
-inline void atomic_store(volatile T *a, typename T::Type v, memory_order mo) {
-  DCHECK(mo & (memory_order_relaxed | memory_order_release
-      | memory_order_seq_cst));
-  DCHECK(!((uptr)a % sizeof(*a)));
-
-  if (sizeof(*a) < 8 || sizeof(void*) == 8) {
-    // Assume that aligned loads are atomic.
-    if (mo == memory_order_relaxed) {
-      a->val_dont_use = v;
-    } else if (mo == memory_order_release) {
-      // On x86 stores are implicitly release.
-      __asm__ __volatile__("" ::: "memory");
-      a->val_dont_use = v;
-      __asm__ __volatile__("" ::: "memory");
-    } else {  // seq_cst
-      // On x86 stores are implicitly release.
-      __asm__ __volatile__("" ::: "memory");
-      a->val_dont_use = v;
-      __sync_synchronize();
-    }
-  } else {
-    // 64-bit store on 32-bit platform.
-    __asm__ __volatile__(
-        "movq %1, %%mm0;"  // Use mmx reg for 64-bit atomic moves
-        "movq %%mm0, %0;"
-        "emms;"            // Empty mmx state/Reset FP regs
-        : "=m" (a->val_dont_use)
-        : "m" (v)
-        : // mark the mmx registers as clobbered
-#ifdef __MMX__
-          "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
-#endif  // #ifdef __MMX__
-          "memory");
-    if (mo == memory_order_seq_cst)
-      __sync_synchronize();
-  }
-}
-
-}  // namespace __sanitizer
-
-#endif  // #ifndef SANITIZER_ATOMIC_CLANG_X86_H
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_atomic_msvc.h b/zig/lib/tsan/sanitizer_common/sanitizer_atomic_msvc.h
index 31317adcdf..d80bfdbf6a 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_atomic_msvc.h
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_atomic_msvc.h
@@ -70,8 +70,8 @@ inline void proc_yield(int cnt) {
 template<typename T>
 inline typename T::Type atomic_load(
     const volatile T *a, memory_order mo) {
-  DCHECK(mo & (memory_order_relaxed | memory_order_consume
-      | memory_order_acquire | memory_order_seq_cst));
+  DCHECK(mo == memory_order_relaxed || mo == memory_order_consume ||
+         mo == memory_order_acquire || mo == memory_order_seq_cst);
   DCHECK(!((uptr)a % sizeof(*a)));
   typename T::Type v;
   // FIXME(dvyukov): 64-bit load is not atomic on 32-bits.
@@ -87,8 +87,8 @@ inline typename T::Type atomic_load(
 
 template<typename T>
 inline void atomic_store(volatile T *a, typename T::Type v, memory_order mo) {
-  DCHECK(mo & (memory_order_relaxed | memory_order_release
-      | memory_order_seq_cst));
+  DCHECK(mo == memory_order_relaxed || mo == memory_order_release ||
+         mo == memory_order_seq_cst);
   DCHECK(!((uptr)a % sizeof(*a)));
   // FIXME(dvyukov): 64-bit store is not atomic on 32-bits.
   if (mo == memory_order_relaxed) {
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_bitvector.h b/zig/lib/tsan/sanitizer_common/sanitizer_bitvector.h
index 07a59ab11c..eef1e7e9d9 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_bitvector.h
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_bitvector.h
@@ -321,23 +321,23 @@ class TwoLevelBitVector {
   };
 
  private:
-  void check(uptr idx) const { CHECK_LE(idx, size()); }
+  void check(uptr idx) const { CHECK_LT(idx, size()); }
 
   uptr idx0(uptr idx) const {
     uptr res = idx / (BV::kSize * BV::kSize);
-    CHECK_LE(res, kLevel1Size);
+    CHECK_LT(res, kLevel1Size);
     return res;
   }
 
   uptr idx1(uptr idx) const {
     uptr res = (idx / BV::kSize) % BV::kSize;
-    CHECK_LE(res, BV::kSize);
+    CHECK_LT(res, BV::kSize);
     return res;
   }
 
   uptr idx2(uptr idx) const {
     uptr res = idx % BV::kSize;
-    CHECK_LE(res, BV::kSize);
+    CHECK_LT(res, BV::kSize);
     return res;
   }
 
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_chained_origin_depot.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_chained_origin_depot.cpp
index e0e2bd0106..df2b2eb23d 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_chained_origin_depot.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_chained_origin_depot.cpp
@@ -139,9 +139,11 @@ u32 ChainedOriginDepot::Get(u32 id, u32 *other) {
   return desc.here_id;
 }
 
-void ChainedOriginDepot::LockAll() { depot.LockAll(); }
+void ChainedOriginDepot::LockBeforeFork() { depot.LockBeforeFork(); }
 
-void ChainedOriginDepot::UnlockAll() { depot.UnlockAll(); }
+void ChainedOriginDepot::UnlockAfterFork(bool fork_child) {
+  depot.UnlockAfterFork(fork_child);
+}
 
 void ChainedOriginDepot::TestOnlyUnmap() { depot.TestOnlyUnmap(); }
 
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_chained_origin_depot.h b/zig/lib/tsan/sanitizer_common/sanitizer_chained_origin_depot.h
index f9f192b685..f3da28129e 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_chained_origin_depot.h
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_chained_origin_depot.h
@@ -32,8 +32,8 @@ class ChainedOriginDepot {
   // Retrieves the stored StackDepot ID for the given origin ID.
   u32 Get(u32 id, u32 *other);
 
-  void LockAll();
-  void UnlockAll();
+  void LockBeforeFork();
+  void UnlockAfterFork(bool fork_child);
   void TestOnlyUnmap();
 
  private:
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_common.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_common.cpp
index 79b7748b8f..6cd69a5309 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_common.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_common.cpp
@@ -115,8 +115,9 @@ void ReportErrorSummary(const char *error_message, const char *alt_tool_name) {
   if (!common_flags()->print_summary)
     return;
   InternalScopedString buff;
-  buff.append("SUMMARY: %s: %s",
-              alt_tool_name ? alt_tool_name : SanitizerToolName, error_message);
+  buff.AppendF("SUMMARY: %s: %s",
+               alt_tool_name ? alt_tool_name : SanitizerToolName,
+               error_message);
   __sanitizer_report_error_summary(buff.data());
 }
 
@@ -346,7 +347,13 @@ void RunMallocHooks(void *ptr, uptr size) {
   }
 }
 
-void RunFreeHooks(void *ptr) {
+// Returns '1' if the call to free() should be ignored (based on
+// __sanitizer_ignore_free_hook), or '0' otherwise.
+int RunFreeHooks(void *ptr) {
+  if (__sanitizer_ignore_free_hook(ptr)) {
+    return 1;
+  }
+
   __sanitizer_free_hook(ptr);
   for (int i = 0; i < kMaxMallocFreeHooks; i++) {
     auto hook = MFHooks[i].free_hook;
@@ -354,6 +361,8 @@ void RunFreeHooks(void *ptr) {
       break;
     hook(ptr);
   }
+
+  return 0;
 }
 
 static int InstallMallocFreeHooks(void (*malloc_hook)(const void *, uptr),
@@ -418,4 +427,9 @@ SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_free_hook, void *ptr) {
   (void)ptr;
 }
 
+SANITIZER_INTERFACE_WEAK_DEF(int, __sanitizer_ignore_free_hook, void *ptr) {
+  (void)ptr;
+  return 0;
+}
+
 } // extern "C"
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_common.h b/zig/lib/tsan/sanitizer_common/sanitizer_common.h
index e7e4b8cb50..2428a8cd14 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_common.h
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_common.h
@@ -32,6 +32,7 @@ struct AddressInfo;
 struct BufferedStackTrace;
 struct SignalContext;
 struct StackTrace;
+struct SymbolizedStack;
 
 // Constants.
 const uptr kWordSize = SANITIZER_WORDSIZE / 8;
@@ -59,14 +60,10 @@ inline int Verbosity() {
   return atomic_load(&current_verbosity, memory_order_relaxed);
 }
 
-#if SANITIZER_ANDROID
-inline uptr GetPageSize() {
-// Android post-M sysconf(_SC_PAGESIZE) crashes if called from .preinit_array.
-  return 4096;
-}
-inline uptr GetPageSizeCached() {
-  return 4096;
-}
+#if SANITIZER_ANDROID && !defined(__aarch64__)
+// 32-bit Android only has 4k pages.
+inline uptr GetPageSize() { return 4096; }
+inline uptr GetPageSizeCached() { return 4096; }
 #else
 uptr GetPageSize();
 extern uptr PageSizeCached;
@@ -76,6 +73,7 @@ inline uptr GetPageSizeCached() {
   return PageSizeCached;
 }
 #endif
+
 uptr GetMmapGranularity();
 uptr GetMaxVirtualAddress();
 uptr GetMaxUserVirtualAddress();
@@ -90,10 +88,11 @@ void GetThreadStackAndTls(bool main, uptr *stk_addr, uptr *stk_size,
 
 // Memory management
 void *MmapOrDie(uptr size, const char *mem_type, bool raw_report = false);
+
 inline void *MmapOrDieQuietly(uptr size, const char *mem_type) {
   return MmapOrDie(size, mem_type, /*raw_report*/ true);
 }
-void UnmapOrDie(void *addr, uptr size);
+void UnmapOrDie(void *addr, uptr size, bool raw_report = false);
 // Behaves just like MmapOrDie, but tolerates out of memory condition, in that
 // case returns nullptr.
 void *MmapOrDieOnFatalError(uptr size, const char *mem_type);
@@ -138,7 +137,8 @@ void UnmapFromTo(uptr from, uptr to);
 // shadow_size_bytes bytes on the right, which on linux is mapped no access.
 // The high_mem_end may be updated if the original shadow size doesn't fit.
 uptr MapDynamicShadow(uptr shadow_size_bytes, uptr shadow_scale,
-                      uptr min_shadow_base_alignment, uptr &high_mem_end);
+                      uptr min_shadow_base_alignment, uptr &high_mem_end,
+                      uptr granularity);
 
 // Let S = max(shadow_size, num_aliases * alias_size, ring_buffer_size).
 // Reserves 2*S bytes of address space to the right of the returned address and
@@ -177,7 +177,7 @@ bool DontDumpShadowMemory(uptr addr, uptr length);
 // Check if the built VMA size matches the runtime one.
 void CheckVMASize();
 void RunMallocHooks(void *ptr, uptr size);
-void RunFreeHooks(void *ptr);
+int RunFreeHooks(void *ptr);
 
 class ReservedAddressRange {
  public:
@@ -208,6 +208,11 @@ void ParseUnixMemoryProfile(fill_profile_f cb, uptr *stats, char *smaps,
 // Simple low-level (mmap-based) allocator for internal use. Doesn't have
 // constructor, so all instances of LowLevelAllocator should be
 // linker initialized.
+//
+// NOTE: Users should instead use the singleton provided via
+// `GetGlobalLowLevelAllocator()` rather than create a new one. This way, the
+// number of mmap fragments can be reduced and use the same contiguous mmap
+// provided by this singleton.
 class LowLevelAllocator {
  public:
   // Requires an external lock.
@@ -224,6 +229,8 @@ typedef void (*LowLevelAllocateCallback)(uptr ptr, uptr size);
 // Passing NULL removes the callback.
 void SetLowLevelAllocateCallback(LowLevelAllocateCallback callback);
 
+LowLevelAllocator &GetGlobalLowLevelAllocator();
+
 // IO
 void CatastrophicErrorWrite(const char *buffer, uptr length);
 void RawWrite(const char *buffer);
@@ -386,6 +393,8 @@ void ReportErrorSummary(const char *error_type, const AddressInfo &info,
 // Same as above, but obtains AddressInfo by symbolizing top stack trace frame.
 void ReportErrorSummary(const char *error_type, const StackTrace *trace,
                         const char *alt_tool_name = nullptr);
+// Skips frames which we consider internal and not usefull to the users.
+const SymbolizedStack *SkipInternalFrames(const SymbolizedStack *frames);
 
 void ReportMmapWriteExec(int prot, int mflags);
 
@@ -500,7 +509,7 @@ inline int ToLower(int c) {
 // A low-level vector based on mmap. May incur a significant memory overhead for
 // small vectors.
 // WARNING: The current implementation supports only POD types.
-template<typename T>
+template <typename T, bool raw_report = false>
 class InternalMmapVectorNoCtor {
  public:
   using value_type = T;
@@ -510,7 +519,7 @@ class InternalMmapVectorNoCtor {
     data_ = 0;
     reserve(initial_capacity);
   }
-  void Destroy() { UnmapOrDie(data_, capacity_bytes_); }
+  void Destroy() { UnmapOrDie(data_, capacity_bytes_, raw_report); }
   T &operator[](uptr i) {
     CHECK_LT(i, size_);
     return data_[i];
@@ -586,9 +595,10 @@ class InternalMmapVectorNoCtor {
     CHECK_LE(size_, new_capacity);
     uptr new_capacity_bytes =
         RoundUpTo(new_capacity * sizeof(T), GetPageSizeCached());
-    T *new_data = (T *)MmapOrDie(new_capacity_bytes, "InternalMmapVector");
+    T *new_data =
+        (T *)MmapOrDie(new_capacity_bytes, "InternalMmapVector", raw_report);
     internal_memcpy(new_data, data_, size_ * sizeof(T));
-    UnmapOrDie(data_, capacity_bytes_);
+    UnmapOrDie(data_, capacity_bytes_, raw_report);
     data_ = new_data;
     capacity_bytes_ = new_capacity_bytes;
   }
@@ -636,7 +646,8 @@ class InternalScopedString {
     buffer_.resize(1);
     buffer_[0] = '\0';
   }
-  void append(const char *format, ...) FORMAT(2, 3);
+  void Append(const char *str);
+  void AppendF(const char *format, ...) FORMAT(2, 3);
   const char *data() const { return buffer_.data(); }
   char *data() { return buffer_.data(); }
 
@@ -1086,7 +1097,7 @@ inline u32 GetNumberOfCPUsCached() {
 
 }  // namespace __sanitizer
 
-inline void *operator new(__sanitizer::operator_new_size_type size,
+inline void *operator new(__sanitizer::usize size,
                           __sanitizer::LowLevelAllocator &alloc) {
   return alloc.Allocate(size);
 }
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_common_interceptors.inc b/zig/lib/tsan/sanitizer_common/sanitizer_common_interceptors.inc
index 0e563fa120..49c9dcbef3 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_common_interceptors.inc
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_common_interceptors.inc
@@ -33,16 +33,17 @@
 //   COMMON_INTERCEPTOR_STRERROR
 //===----------------------------------------------------------------------===//
 
+#include <stdarg.h>
+
 #include "interception/interception.h"
 #include "sanitizer_addrhashmap.h"
+#include "sanitizer_dl.h"
 #include "sanitizer_errno.h"
 #include "sanitizer_placement_new.h"
 #include "sanitizer_platform_interceptors.h"
 #include "sanitizer_symbolizer.h"
 #include "sanitizer_tls_get_addr.h"
 
-#include <stdarg.h>
-
 #if SANITIZER_INTERCEPTOR_HOOKS
 #define CALL_WEAK_INTERCEPTOR_HOOK(f, ...) f(__VA_ARGS__);
 #define DECLARE_WEAK_INTERCEPTOR_HOOK(f, ...) \
@@ -445,11 +446,13 @@ INTERCEPTOR(char*, textdomain, const char *domainname) {
 #define INIT_TEXTDOMAIN
 #endif
 
-#if SANITIZER_INTERCEPT_STRCMP
+#if SANITIZER_INTERCEPT_STRCMP || SANITIZER_INTERCEPT_MEMCMP
 static inline int CharCmpX(unsigned char c1, unsigned char c2) {
   return (c1 == c2) ? 0 : (c1 < c2) ? -1 : 1;
 }
+#endif
 
+#if SANITIZER_INTERCEPT_STRCMP
 DECLARE_WEAK_INTERCEPTOR_HOOK(__sanitizer_weak_hook_strcmp, uptr called_pc,
                               const char *s1, const char *s2, int result)
 
@@ -971,7 +974,7 @@ INTERCEPTOR(SSIZE_T, read, int fd, void *ptr, SIZE_T count) {
   // FIXME: under ASan the call below may write to freed memory and corrupt
   // its metadata. See
   // https://github.com/google/sanitizers/issues/321.
-  SSIZE_T res = REAL(read)(fd, ptr, count);
+  SSIZE_T res = COMMON_INTERCEPTOR_BLOCK_REAL(read)(fd, ptr, count);
   if (res > 0) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ptr, res);
   if (res >= 0 && fd >= 0) COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd);
   return res;
@@ -1006,7 +1009,7 @@ INTERCEPTOR(SSIZE_T, pread, int fd, void *ptr, SIZE_T count, OFF_T offset) {
   // FIXME: under ASan the call below may write to freed memory and corrupt
   // its metadata. See
   // https://github.com/google/sanitizers/issues/321.
-  SSIZE_T res = REAL(pread)(fd, ptr, count, offset);
+  SSIZE_T res = COMMON_INTERCEPTOR_BLOCK_REAL(pread)(fd, ptr, count, offset);
   if (res > 0) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ptr, res);
   if (res >= 0 && fd >= 0) COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd);
   return res;
@@ -1024,7 +1027,7 @@ INTERCEPTOR(SSIZE_T, pread64, int fd, void *ptr, SIZE_T count, OFF64_T offset) {
   // FIXME: under ASan the call below may write to freed memory and corrupt
   // its metadata. See
   // https://github.com/google/sanitizers/issues/321.
-  SSIZE_T res = REAL(pread64)(fd, ptr, count, offset);
+  SSIZE_T res = COMMON_INTERCEPTOR_BLOCK_REAL(pread64)(fd, ptr, count, offset);
   if (res > 0) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ptr, res);
   if (res >= 0 && fd >= 0) COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd);
   return res;
@@ -1040,7 +1043,7 @@ INTERCEPTOR_WITH_SUFFIX(SSIZE_T, readv, int fd, __sanitizer_iovec *iov,
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, readv, fd, iov, iovcnt);
   COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
-  SSIZE_T res = REAL(readv)(fd, iov, iovcnt);
+  SSIZE_T res = COMMON_INTERCEPTOR_BLOCK_REAL(readv)(fd, iov, iovcnt);
   if (res > 0) write_iovec(ctx, iov, iovcnt, res);
   if (res >= 0 && fd >= 0) COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd);
   return res;
@@ -1056,7 +1059,7 @@ INTERCEPTOR(SSIZE_T, preadv, int fd, __sanitizer_iovec *iov, int iovcnt,
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, preadv, fd, iov, iovcnt, offset);
   COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
-  SSIZE_T res = REAL(preadv)(fd, iov, iovcnt, offset);
+  SSIZE_T res = COMMON_INTERCEPTOR_BLOCK_REAL(preadv)(fd, iov, iovcnt, offset);
   if (res > 0) write_iovec(ctx, iov, iovcnt, res);
   if (res >= 0 && fd >= 0) COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd);
   return res;
@@ -1072,7 +1075,8 @@ INTERCEPTOR(SSIZE_T, preadv64, int fd, __sanitizer_iovec *iov, int iovcnt,
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, preadv64, fd, iov, iovcnt, offset);
   COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
-  SSIZE_T res = REAL(preadv64)(fd, iov, iovcnt, offset);
+  SSIZE_T res =
+      COMMON_INTERCEPTOR_BLOCK_REAL(preadv64)(fd, iov, iovcnt, offset);
   if (res > 0) write_iovec(ctx, iov, iovcnt, res);
   if (res >= 0 && fd >= 0) COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd);
   return res;
@@ -1088,8 +1092,9 @@ INTERCEPTOR(SSIZE_T, write, int fd, void *ptr, SIZE_T count) {
   COMMON_INTERCEPTOR_ENTER(ctx, write, fd, ptr, count);
   COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
   if (fd >= 0) COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd);
-  SSIZE_T res = REAL(write)(fd, ptr, count);
-  // FIXME: this check should be _before_ the call to REAL(write), not after
+  SSIZE_T res = COMMON_INTERCEPTOR_BLOCK_REAL(write)(fd, ptr, count);
+  // FIXME: this check should be _before_ the call to
+  // COMMON_INTERCEPTOR_BLOCK_REAL(write), not after
   if (res > 0) COMMON_INTERCEPTOR_READ_RANGE(ctx, ptr, res);
   return res;
 }
@@ -1118,7 +1123,7 @@ INTERCEPTOR(SSIZE_T, pwrite, int fd, void *ptr, SIZE_T count, OFF_T offset) {
   COMMON_INTERCEPTOR_ENTER(ctx, pwrite, fd, ptr, count, offset);
   COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
   if (fd >= 0) COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd);
-  SSIZE_T res = REAL(pwrite)(fd, ptr, count, offset);
+  SSIZE_T res = COMMON_INTERCEPTOR_BLOCK_REAL(pwrite)(fd, ptr, count, offset);
   if (res > 0) COMMON_INTERCEPTOR_READ_RANGE(ctx, ptr, res);
   return res;
 }
@@ -1134,7 +1139,7 @@ INTERCEPTOR(SSIZE_T, pwrite64, int fd, void *ptr, OFF64_T count,
   COMMON_INTERCEPTOR_ENTER(ctx, pwrite64, fd, ptr, count, offset);
   COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
   if (fd >= 0) COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd);
-  SSIZE_T res = REAL(pwrite64)(fd, ptr, count, offset);
+  SSIZE_T res = COMMON_INTERCEPTOR_BLOCK_REAL(pwrite64)(fd, ptr, count, offset);
   if (res > 0) COMMON_INTERCEPTOR_READ_RANGE(ctx, ptr, res);
   return res;
 }
@@ -1150,7 +1155,7 @@ INTERCEPTOR_WITH_SUFFIX(SSIZE_T, writev, int fd, __sanitizer_iovec *iov,
   COMMON_INTERCEPTOR_ENTER(ctx, writev, fd, iov, iovcnt);
   COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
   if (fd >= 0) COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd);
-  SSIZE_T res = REAL(writev)(fd, iov, iovcnt);
+  SSIZE_T res = COMMON_INTERCEPTOR_BLOCK_REAL(writev)(fd, iov, iovcnt);
   if (res > 0) read_iovec(ctx, iov, iovcnt, res);
   return res;
 }
@@ -1166,7 +1171,7 @@ INTERCEPTOR(SSIZE_T, pwritev, int fd, __sanitizer_iovec *iov, int iovcnt,
   COMMON_INTERCEPTOR_ENTER(ctx, pwritev, fd, iov, iovcnt, offset);
   COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
   if (fd >= 0) COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd);
-  SSIZE_T res = REAL(pwritev)(fd, iov, iovcnt, offset);
+  SSIZE_T res = COMMON_INTERCEPTOR_BLOCK_REAL(pwritev)(fd, iov, iovcnt, offset);
   if (res > 0) read_iovec(ctx, iov, iovcnt, res);
   return res;
 }
@@ -1182,7 +1187,8 @@ INTERCEPTOR(SSIZE_T, pwritev64, int fd, __sanitizer_iovec *iov, int iovcnt,
   COMMON_INTERCEPTOR_ENTER(ctx, pwritev64, fd, iov, iovcnt, offset);
   COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
   if (fd >= 0) COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd);
-  SSIZE_T res = REAL(pwritev64)(fd, iov, iovcnt, offset);
+  SSIZE_T res =
+      COMMON_INTERCEPTOR_BLOCK_REAL(pwritev64)(fd, iov, iovcnt, offset);
   if (res > 0) read_iovec(ctx, iov, iovcnt, res);
   return res;
 }
@@ -1245,6 +1251,7 @@ INTERCEPTOR(int, prctl, int option, unsigned long arg2, unsigned long arg3,
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, prctl, option, arg2, arg3, arg4, arg5);
   static const int PR_SET_NAME = 15;
+  static const int PR_GET_NAME = 16;
   static const int PR_SET_VMA = 0x53564d41;
   static const int PR_SCHED_CORE = 62;
   static const int PR_SCHED_CORE_GET = 0;
@@ -1258,7 +1265,11 @@ INTERCEPTOR(int, prctl, int option, unsigned long arg2, unsigned long arg3,
     internal_strncpy(buff, (char *)arg2, 15);
     buff[15] = 0;
     COMMON_INTERCEPTOR_SET_THREAD_NAME(ctx, buff);
-  } else if (res != -1 && option == PR_SCHED_CORE && arg2 == PR_SCHED_CORE_GET) {
+  } else if (res == 0 && option == PR_GET_NAME) {
+    char *name = (char *)arg2;
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, name, internal_strlen(name) + 1);
+  } else if (res != -1 && option == PR_SCHED_CORE &&
+             arg2 == PR_SCHED_CORE_GET) {
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, (u64*)(arg5), sizeof(u64));
   }
   return res;
@@ -2546,7 +2557,7 @@ INTERCEPTOR_WITH_SUFFIX(int, wait, int *status) {
   // FIXME: under ASan the call below may write to freed memory and corrupt
   // its metadata. See
   // https://github.com/google/sanitizers/issues/321.
-  int res = REAL(wait)(status);
+  int res = COMMON_INTERCEPTOR_BLOCK_REAL(wait)(status);
   if (res != -1 && status)
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, status, sizeof(*status));
   return res;
@@ -2564,7 +2575,7 @@ INTERCEPTOR_WITH_SUFFIX(int, waitid, int idtype, int id, void *infop,
   // FIXME: under ASan the call below may write to freed memory and corrupt
   // its metadata. See
   // https://github.com/google/sanitizers/issues/321.
-  int res = REAL(waitid)(idtype, id, infop, options);
+  int res = COMMON_INTERCEPTOR_BLOCK_REAL(waitid)(idtype, id, infop, options);
   if (res != -1 && infop)
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, infop, siginfo_t_sz);
   return res;
@@ -2575,7 +2586,7 @@ INTERCEPTOR_WITH_SUFFIX(int, waitpid, int pid, int *status, int options) {
   // FIXME: under ASan the call below may write to freed memory and corrupt
   // its metadata. See
   // https://github.com/google/sanitizers/issues/321.
-  int res = REAL(waitpid)(pid, status, options);
+  int res = COMMON_INTERCEPTOR_BLOCK_REAL(waitpid)(pid, status, options);
   if (res != -1 && status)
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, status, sizeof(*status));
   return res;
@@ -2586,7 +2597,7 @@ INTERCEPTOR(int, wait3, int *status, int options, void *rusage) {
   // FIXME: under ASan the call below may write to freed memory and corrupt
   // its metadata. See
   // https://github.com/google/sanitizers/issues/321.
-  int res = REAL(wait3)(status, options, rusage);
+  int res = COMMON_INTERCEPTOR_BLOCK_REAL(wait3)(status, options, rusage);
   if (res != -1) {
     if (status) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, status, sizeof(*status));
     if (rusage) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, rusage, struct_rusage_sz);
@@ -2600,7 +2611,8 @@ INTERCEPTOR(int, __wait4, int pid, int *status, int options, void *rusage) {
   // FIXME: under ASan the call below may write to freed memory and corrupt
   // its metadata. See
   // https://github.com/google/sanitizers/issues/321.
-  int res = REAL(__wait4)(pid, status, options, rusage);
+  int res =
+      COMMON_INTERCEPTOR_BLOCK_REAL(__wait4)(pid, status, options, rusage);
   if (res != -1) {
     if (status) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, status, sizeof(*status));
     if (rusage) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, rusage, struct_rusage_sz);
@@ -2615,7 +2627,7 @@ INTERCEPTOR(int, wait4, int pid, int *status, int options, void *rusage) {
   // FIXME: under ASan the call below may write to freed memory and corrupt
   // its metadata. See
   // https://github.com/google/sanitizers/issues/321.
-  int res = REAL(wait4)(pid, status, options, rusage);
+  int res = COMMON_INTERCEPTOR_BLOCK_REAL(wait4)(pid, status, options, rusage);
   if (res != -1) {
     if (status) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, status, sizeof(*status));
     if (rusage) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, rusage, struct_rusage_sz);
@@ -2993,7 +3005,7 @@ INTERCEPTOR(int, accept, int fd, void *addr, unsigned *addrlen) {
     COMMON_INTERCEPTOR_READ_RANGE(ctx, addrlen, sizeof(*addrlen));
     addrlen0 = *addrlen;
   }
-  int fd2 = REAL(accept)(fd, addr, addrlen);
+  int fd2 = COMMON_INTERCEPTOR_BLOCK_REAL(accept)(fd, addr, addrlen);
   if (fd2 >= 0) {
     if (fd >= 0) COMMON_INTERCEPTOR_FD_SOCKET_ACCEPT(ctx, fd, fd2);
     if (addr && addrlen)
@@ -3018,7 +3030,7 @@ INTERCEPTOR(int, accept4, int fd, void *addr, unsigned *addrlen, int f) {
   // FIXME: under ASan the call below may write to freed memory and corrupt
   // its metadata. See
   // https://github.com/google/sanitizers/issues/321.
-  int fd2 = REAL(accept4)(fd, addr, addrlen, f);
+  int fd2 = COMMON_INTERCEPTOR_BLOCK_REAL(accept4)(fd, addr, addrlen, f);
   if (fd2 >= 0) {
     if (fd >= 0) COMMON_INTERCEPTOR_FD_SOCKET_ACCEPT(ctx, fd, fd2);
     if (addr && addrlen)
@@ -3042,7 +3054,7 @@ INTERCEPTOR(int, paccept, int fd, void *addr, unsigned *addrlen,
     addrlen0 = *addrlen;
   }
   if (set) COMMON_INTERCEPTOR_READ_RANGE(ctx, set, sizeof(*set));
-  int fd2 = REAL(paccept)(fd, addr, addrlen, set, f);
+  int fd2 = COMMON_INTERCEPTOR_BLOCK_REAL(paccept)(fd, addr, addrlen, set, f);
   if (fd2 >= 0) {
     if (fd >= 0) COMMON_INTERCEPTOR_FD_SOCKET_ACCEPT(ctx, fd, fd2);
     if (addr && addrlen)
@@ -3123,7 +3135,7 @@ INTERCEPTOR(SSIZE_T, recvmsg, int fd, struct __sanitizer_msghdr *msg,
   // FIXME: under ASan the call below may write to freed memory and corrupt
   // its metadata. See
   // https://github.com/google/sanitizers/issues/321.
-  SSIZE_T res = REAL(recvmsg)(fd, msg, flags);
+  SSIZE_T res = COMMON_INTERCEPTOR_BLOCK_REAL(recvmsg)(fd, msg, flags);
   if (res >= 0) {
     if (fd >= 0) COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd);
     if (msg) {
@@ -3144,7 +3156,8 @@ INTERCEPTOR(int, recvmmsg, int fd, struct __sanitizer_mmsghdr *msgvec,
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, recvmmsg, fd, msgvec, vlen, flags, timeout);
   if (timeout) COMMON_INTERCEPTOR_READ_RANGE(ctx, timeout, struct_timespec_sz);
-  int res = REAL(recvmmsg)(fd, msgvec, vlen, flags, timeout);
+  int res =
+      COMMON_INTERCEPTOR_BLOCK_REAL(recvmmsg)(fd, msgvec, vlen, flags, timeout);
   if (res >= 0) {
     if (fd >= 0) COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd);
     for (int i = 0; i < res; ++i) {
@@ -3222,7 +3235,7 @@ INTERCEPTOR(SSIZE_T, sendmsg, int fd, struct __sanitizer_msghdr *msg,
     COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
     COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd);
   }
-  SSIZE_T res = REAL(sendmsg)(fd, msg, flags);
+  SSIZE_T res = COMMON_INTERCEPTOR_BLOCK_REAL(sendmsg)(fd, msg, flags);
   if (common_flags()->intercept_send && res >= 0 && msg)
     read_msghdr(ctx, msg, res);
   return res;
@@ -3241,7 +3254,7 @@ INTERCEPTOR(int, sendmmsg, int fd, struct __sanitizer_mmsghdr *msgvec,
     COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
     COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd);
   }
-  int res = REAL(sendmmsg)(fd, msgvec, vlen, flags);
+  int res = COMMON_INTERCEPTOR_BLOCK_REAL(sendmmsg)(fd, msgvec, vlen, flags);
   if (res >= 0 && msgvec) {
     for (int i = 0; i < res; ++i) {
       COMMON_INTERCEPTOR_WRITE_RANGE(ctx, &msgvec[i].msg_len,
@@ -3264,7 +3277,7 @@ INTERCEPTOR(int, msgsnd, int msqid, const void *msgp, SIZE_T msgsz,
   COMMON_INTERCEPTOR_ENTER(ctx, msgsnd, msqid, msgp, msgsz, msgflg);
   if (msgp)
     COMMON_INTERCEPTOR_READ_RANGE(ctx, msgp, sizeof(long) + msgsz);
-  int res = REAL(msgsnd)(msqid, msgp, msgsz, msgflg);
+  int res = COMMON_INTERCEPTOR_BLOCK_REAL(msgsnd)(msqid, msgp, msgsz, msgflg);
   return res;
 }
 
@@ -3272,7 +3285,8 @@ INTERCEPTOR(SSIZE_T, msgrcv, int msqid, void *msgp, SIZE_T msgsz,
             long msgtyp, int msgflg) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, msgrcv, msqid, msgp, msgsz, msgtyp, msgflg);
-  SSIZE_T len = REAL(msgrcv)(msqid, msgp, msgsz, msgtyp, msgflg);
+  SSIZE_T len =
+      COMMON_INTERCEPTOR_BLOCK_REAL(msgrcv)(msqid, msgp, msgsz, msgtyp, msgflg);
   if (len != -1)
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, msgp, sizeof(long) + len);
   return len;
@@ -6116,7 +6130,7 @@ INTERCEPTOR(int, flopen, const char *path, int flags, ...) {
   if (path) {
     COMMON_INTERCEPTOR_READ_RANGE(ctx, path, internal_strlen(path) + 1);
   }
-  return REAL(flopen)(path, flags, mode);
+  return COMMON_INTERCEPTOR_BLOCK_REAL(flopen)(path, flags, mode);
 }
 
 INTERCEPTOR(int, flopenat, int dirfd, const char *path, int flags, ...) {
@@ -6129,7 +6143,7 @@ INTERCEPTOR(int, flopenat, int dirfd, const char *path, int flags, ...) {
   if (path) {
     COMMON_INTERCEPTOR_READ_RANGE(ctx, path, internal_strlen(path) + 1);
   }
-  return REAL(flopenat)(dirfd, path, flags, mode);
+  return COMMON_INTERCEPTOR_BLOCK_REAL(flopenat)(dirfd, path, flags, mode);
 }
 
 #define INIT_FLOPEN    \
@@ -6305,7 +6319,36 @@ INTERCEPTOR(int, fclose, __sanitizer_FILE *fp) {
 INTERCEPTOR(void*, dlopen, const char *filename, int flag) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER_NOIGNORE(ctx, dlopen, filename, flag);
-  if (filename) COMMON_INTERCEPTOR_READ_STRING(ctx, filename, 0);
+
+  if (filename) {
+    COMMON_INTERCEPTOR_READ_STRING(ctx, filename, 0);
+
+#  if !SANITIZER_DYNAMIC
+    // We care about a very specific use-case: dladdr on
+    // statically-linked ASan may return <main program>
+    // instead of the library.
+    // We therefore only take effect if the sanitizer is statically
+    // linked, and we don't bother canonicalizing paths because
+    // dladdr should return the same address both times (we assume
+    // the user did not canonicalize the result from dladdr).
+    if (common_flags()->test_only_replace_dlopen_main_program) {
+      VPrintf(1, "dlopen interceptor: filename: %s\n", filename);
+
+      const char *SelfFName = DladdrSelfFName();
+      VPrintf(1, "dlopen interceptor: DladdrSelfFName: %p %s\n",
+              (const void *)SelfFName, SelfFName);
+
+      if (SelfFName && internal_strcmp(SelfFName, filename) == 0) {
+        // It's possible they copied the string from dladdr, so
+        // we do a string comparison rather than pointer comparison.
+        VPrintf(1, "dlopen interceptor: replacing %s because it matches %s\n",
+                filename, SelfFName);
+        filename = (char *)0;  // RTLD_DEFAULT
+      }
+    }
+#  endif  // !SANITIZER_DYNAMIC
+  }
+
   void *res = COMMON_INTERCEPTOR_DLOPEN(filename, flag);
   Symbolizer::GetOrInit()->InvalidateModuleList();
   COMMON_INTERCEPTOR_LIBRARY_LOADED(filename, res);
@@ -6685,7 +6728,7 @@ INTERCEPTOR(SSIZE_T, recv, int fd, void *buf, SIZE_T len, int flags) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, recv, fd, buf, len, flags);
   COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
-  SSIZE_T res = REAL(recv)(fd, buf, len, flags);
+  SSIZE_T res = COMMON_INTERCEPTOR_BLOCK_REAL(recv)(fd, buf, len, flags);
   if (res > 0) {
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, Min((SIZE_T)res, len));
   }
@@ -6702,7 +6745,8 @@ INTERCEPTOR(SSIZE_T, recvfrom, int fd, void *buf, SIZE_T len, int flags,
   SIZE_T srcaddr_sz;
   if (srcaddr) srcaddr_sz = *addrlen;
   (void)srcaddr_sz;  // prevent "set but not used" warning
-  SSIZE_T res = REAL(recvfrom)(fd, buf, len, flags, srcaddr, addrlen);
+  SSIZE_T res = COMMON_INTERCEPTOR_BLOCK_REAL(recvfrom)(fd, buf, len, flags,
+                                                        srcaddr, addrlen);
   if (res > 0)
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, Min((SIZE_T)res, len));
   if (res >= 0 && srcaddr)
@@ -6725,7 +6769,7 @@ INTERCEPTOR(SSIZE_T, send, int fd, void *buf, SIZE_T len, int flags) {
     COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
     COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd);
   }
-  SSIZE_T res = REAL(send)(fd, buf, len, flags);
+  SSIZE_T res = COMMON_INTERCEPTOR_BLOCK_REAL(send)(fd, buf, len, flags);
   if (common_flags()->intercept_send && res > 0)
     COMMON_INTERCEPTOR_READ_RANGE(ctx, buf, Min((SIZE_T)res, len));
   return res;
@@ -6740,7 +6784,8 @@ INTERCEPTOR(SSIZE_T, sendto, int fd, void *buf, SIZE_T len, int flags,
     COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd);
   }
   // Can't check dstaddr as it may have uninitialized padding at the end.
-  SSIZE_T res = REAL(sendto)(fd, buf, len, flags, dstaddr, addrlen);
+  SSIZE_T res = COMMON_INTERCEPTOR_BLOCK_REAL(sendto)(fd, buf, len, flags,
+                                                      dstaddr, addrlen);
   if (common_flags()->intercept_send && res > 0)
     COMMON_INTERCEPTOR_READ_RANGE(ctx, buf, Min((SIZE_T)res, len));
   return res;
@@ -6753,25 +6798,25 @@ INTERCEPTOR(SSIZE_T, sendto, int fd, void *buf, SIZE_T len, int flags,
 #endif
 
 #if SANITIZER_INTERCEPT_EVENTFD_READ_WRITE
-INTERCEPTOR(int, eventfd_read, int fd, u64 *value) {
+INTERCEPTOR(int, eventfd_read, int fd, __sanitizer_eventfd_t *value) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, eventfd_read, fd, value);
   COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
-  int res = REAL(eventfd_read)(fd, value);
+  int res = COMMON_INTERCEPTOR_BLOCK_REAL(eventfd_read)(fd, value);
   if (res == 0) {
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, value, sizeof(*value));
     if (fd >= 0) COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd);
   }
   return res;
 }
-INTERCEPTOR(int, eventfd_write, int fd, u64 value) {
+INTERCEPTOR(int, eventfd_write, int fd, __sanitizer_eventfd_t value) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, eventfd_write, fd, value);
   if (fd >= 0) {
     COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
     COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd);
   }
-  int res = REAL(eventfd_write)(fd, value);
+  int res = COMMON_INTERCEPTOR_BLOCK_REAL(eventfd_write)(fd, value);
   return res;
 }
 #define INIT_EVENTFD_READ_WRITE            \
@@ -7394,7 +7439,8 @@ INTERCEPTOR(int, open_by_handle_at, int mount_fd, struct file_handle* handle,
   COMMON_INTERCEPTOR_READ_RANGE(
       ctx, &sanitizer_handle->f_handle, sanitizer_handle->handle_bytes);
 
-  return REAL(open_by_handle_at)(mount_fd, handle, flags);
+  return COMMON_INTERCEPTOR_BLOCK_REAL(open_by_handle_at)(mount_fd, handle,
+                                                          flags);
 }
 
 #define INIT_OPEN_BY_HANDLE_AT COMMON_INTERCEPT_FUNCTION(open_by_handle_at)
@@ -7609,9 +7655,9 @@ static void write_protoent(void *ctx, struct __sanitizer_protoent *p) {
   COMMON_INTERCEPTOR_WRITE_RANGE(ctx, p->p_aliases, pp_size * sizeof(char *));
 }
 
-INTERCEPTOR(struct __sanitizer_protoent *, getprotoent) {
+INTERCEPTOR(struct __sanitizer_protoent *, getprotoent,) {
   void *ctx;
-  COMMON_INTERCEPTOR_ENTER(ctx, getprotoent);
+  COMMON_INTERCEPTOR_ENTER(ctx, getprotoent,);
   struct __sanitizer_protoent *p = REAL(getprotoent)();
   if (p)
     write_protoent(ctx, p);
@@ -7698,9 +7744,9 @@ INTERCEPTOR(int, getprotobynumber_r, int num,
 #endif
 
 #if SANITIZER_INTERCEPT_NETENT
-INTERCEPTOR(struct __sanitizer_netent *, getnetent) {
+INTERCEPTOR(struct __sanitizer_netent *, getnetent,) {
   void *ctx;
-  COMMON_INTERCEPTOR_ENTER(ctx, getnetent);
+  COMMON_INTERCEPTOR_ENTER(ctx, getnetent,);
   struct __sanitizer_netent *n = REAL(getnetent)();
   if (n) {
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, n, sizeof(*n));
@@ -9862,9 +9908,9 @@ INTERCEPTOR(char *, fdevname_r,  int fd, char *buf, SIZE_T len) {
 #endif
 
 #if SANITIZER_INTERCEPT_GETUSERSHELL
-INTERCEPTOR(char *, getusershell) {
+INTERCEPTOR(char *, getusershell,) {
   void *ctx;
-  COMMON_INTERCEPTOR_ENTER(ctx, getusershell);
+  COMMON_INTERCEPTOR_ENTER(ctx, getusershell,);
   char *res = REAL(getusershell)();
   if (res)
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res, internal_strlen(res) + 1);
@@ -9933,7 +9979,13 @@ INTERCEPTOR(void, sl_free, void *sl, int freeall) {
 INTERCEPTOR(SSIZE_T, getrandom, void *buf, SIZE_T buflen, unsigned int flags) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, getrandom, buf, buflen, flags);
-  SSIZE_T n = REAL(getrandom)(buf, buflen, flags);
+  // If GRND_NONBLOCK is set in the flags, it is non blocking.
+  static const int grnd_nonblock = 1; 
+  SSIZE_T n;
+  if ((flags & grnd_nonblock))
+    n = REAL(getrandom)(buf, buflen, flags);
+  else
+    n = COMMON_INTERCEPTOR_BLOCK_REAL(getrandom)(buf, buflen, flags);
   if (n > 0) {
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, n);
   }
@@ -10180,20 +10232,6 @@ INTERCEPTOR(int, __xuname, int size, void *utsname) {
 #define INIT___XUNAME
 #endif
 
-#if SANITIZER_INTERCEPT_HEXDUMP
-INTERCEPTOR(void, hexdump, const void *ptr, int length, const char *header, int flags) {
-  void *ctx;
-  COMMON_INTERCEPTOR_ENTER(ctx, hexdump, ptr, length, header, flags);
-  COMMON_INTERCEPTOR_READ_RANGE(ctx, ptr, length);
-  COMMON_INTERCEPTOR_READ_RANGE(ctx, header, internal_strlen(header) + 1);
-  REAL(hexdump)(ptr, length, header, flags);
-}
-
-#define INIT_HEXDUMP COMMON_INTERCEPT_FUNCTION(hexdump);
-#else
-#define INIT_HEXDUMP
-#endif
-
 #if SANITIZER_INTERCEPT_ARGP_PARSE
 INTERCEPTOR(int, argp_parse, const struct argp *argp, int argc, char **argv,
             unsigned flags, int *arg_index, void *input) {
@@ -10226,6 +10264,38 @@ INTERCEPTOR(int, cpuset_getaffinity, int level, int which, __int64_t id, SIZE_T
 #define INIT_CPUSET_GETAFFINITY
 #endif
 
+#if SANITIZER_INTERCEPT_PREADV2
+INTERCEPTOR(SSIZE_T, preadv2, int fd, __sanitizer_iovec *iov, int iovcnt,
+            OFF_T offset, int flags) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, preadv2, fd, iov, iovcnt, offset, flags);
+  COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
+  SSIZE_T res = REAL(preadv2)(fd, iov, iovcnt, offset, flags);
+  if (res > 0) write_iovec(ctx, iov, iovcnt, res);
+  if (res >= 0 && fd >= 0) COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd);
+  return res;
+}
+#define INIT_PREADV2 COMMON_INTERCEPT_FUNCTION(preadv2)
+#else
+#define INIT_PREADV2
+#endif
+
+#if SANITIZER_INTERCEPT_PWRITEV2
+INTERCEPTOR(SSIZE_T, pwritev2, int fd, __sanitizer_iovec *iov, int iovcnt,
+            OFF_T offset, int flags) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, pwritev2, fd, iov, iovcnt, offset, flags);
+  COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
+  if (fd >= 0) COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd);
+  SSIZE_T res = REAL(pwritev2)(fd, iov, iovcnt, offset, flags);
+  if (res > 0) read_iovec(ctx, iov, iovcnt, res);
+  return res;
+}
+#define INIT_PWRITEV2 COMMON_INTERCEPT_FUNCTION(pwritev2)
+#else
+#define INIT_PWRITEV2
+#endif
+
 #include "sanitizer_common_interceptors_netbsd_compat.inc"
 
 namespace __sanitizer {
@@ -10543,9 +10613,10 @@ static void InitializeCommonInterceptors() {
   INIT_PROCCTL
   INIT_UNAME;
   INIT___XUNAME;
-  INIT_HEXDUMP;
   INIT_ARGP_PARSE;
   INIT_CPUSET_GETAFFINITY;
+  INIT_PREADV2;
+  INIT_PWRITEV2;
 
   INIT___PRINTF_CHK;
 }
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_common_interceptors_format.inc b/zig/lib/tsan/sanitizer_common/sanitizer_common_interceptors_format.inc
index 2448590064..24e5dc0fb2 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_common_interceptors_format.inc
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_common_interceptors_format.inc
@@ -547,24 +547,25 @@ static void printf_common(void *ctx, const char *format, va_list aq) {
       continue;
     } else if (size == FSS_STRLEN) {
       if (void *argp = va_arg(aq, void *)) {
+        uptr len;
         if (dir.starredPrecision) {
           // FIXME: properly support starred precision for strings.
-          size = 0;
+          len = 0;
         } else if (dir.fieldPrecision > 0) {
           // Won't read more than "precision" symbols.
-          size = internal_strnlen((const char *)argp, dir.fieldPrecision);
-          if (size < dir.fieldPrecision) size++;
+          len = internal_strnlen((const char *)argp, dir.fieldPrecision);
+          if (len < (uptr)dir.fieldPrecision)
+            len++;
         } else {
           // Whole string will be accessed.
-          size = internal_strlen((const char *)argp) + 1;
+          len = internal_strlen((const char *)argp) + 1;
         }
-        COMMON_INTERCEPTOR_READ_RANGE(ctx, argp, size);
+        COMMON_INTERCEPTOR_READ_RANGE(ctx, argp, len);
       }
     } else if (size == FSS_WCSLEN) {
       if (void *argp = va_arg(aq, void *)) {
         // FIXME: Properly support wide-character strings (via wcsrtombs).
-        size = 0;
-        COMMON_INTERCEPTOR_READ_RANGE(ctx, argp, size);
+        COMMON_INTERCEPTOR_READ_RANGE(ctx, argp, 0);
       }
     } else {
       // Skip non-pointer args
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_common_interface.inc b/zig/lib/tsan/sanitizer_common/sanitizer_common_interface.inc
index 557207fe62..d5981a38ff 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_common_interface.inc
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_common_interface.inc
@@ -46,6 +46,7 @@ INTERFACE_FUNCTION(__sanitizer_purge_allocator)
 INTERFACE_FUNCTION(__sanitizer_print_memory_profile)
 INTERFACE_WEAK_FUNCTION(__sanitizer_free_hook)
 INTERFACE_WEAK_FUNCTION(__sanitizer_malloc_hook)
+INTERFACE_WEAK_FUNCTION(__sanitizer_ignore_free_hook)
 // Memintrinsic functions.
 INTERFACE_FUNCTION(__sanitizer_internal_memcpy)
 INTERFACE_FUNCTION(__sanitizer_internal_memmove)
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_common_interface_posix.inc b/zig/lib/tsan/sanitizer_common/sanitizer_common_interface_posix.inc
index a5259be933..6b567edc97 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_common_interface_posix.inc
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_common_interface_posix.inc
@@ -9,6 +9,7 @@
 //===----------------------------------------------------------------------===//
 INTERFACE_WEAK_FUNCTION(__sanitizer_symbolize_code)
 INTERFACE_WEAK_FUNCTION(__sanitizer_symbolize_data)
+INTERFACE_WEAK_FUNCTION(__sanitizer_symbolize_frame)
 INTERFACE_WEAK_FUNCTION(__sanitizer_symbolize_demangle)
 INTERFACE_WEAK_FUNCTION(__sanitizer_symbolize_flush)
 INTERFACE_WEAK_FUNCTION(__sanitizer_symbolize_set_demangle)
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_common_libcdep.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_common_libcdep.cpp
index 895763ac6b..3966d82d51 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_common_libcdep.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_common_libcdep.cpp
@@ -87,8 +87,8 @@ void MaybeStartBackgroudThread() {
   if (!common_flags()->hard_rss_limit_mb &&
       !common_flags()->soft_rss_limit_mb &&
       !common_flags()->heap_profile) return;
-  if (!&real_pthread_create) {
-    VPrintf(1, "%s: real_pthread_create undefined\n", SanitizerToolName);
+  if (!&internal_pthread_create) {
+    VPrintf(1, "%s: internal_pthread_create undefined\n", SanitizerToolName);
     return;  // Can't spawn the thread anyway.
   }
 
@@ -119,8 +119,10 @@ void MaybeStartBackgroudThread() {}
 #endif
 
 void WriteToSyslog(const char *msg) {
+  if (!msg)
+    return;
   InternalScopedString msg_copy;
-  msg_copy.append("%s", msg);
+  msg_copy.Append(msg);
   const char *p = msg_copy.data();
 
   // Print one line at a time.
@@ -167,7 +169,7 @@ void ReserveShadowMemoryRange(uptr beg, uptr end, const char *name,
                      : !MmapFixedNoReserve(beg, size, name)) {
     Report(
         "ReserveShadowMemoryRange failed while trying to map 0x%zx bytes. "
-        "Perhaps you're using ulimit -v\n",
+        "Perhaps you're using ulimit -v or ulimit -d\n",
         size);
     Abort();
   }
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_common_syscalls.inc b/zig/lib/tsan/sanitizer_common/sanitizer_common_syscalls.inc
index c10943b3e4..14615f9668 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_common_syscalls.inc
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_common_syscalls.inc
@@ -38,6 +38,10 @@
 //          Called before fork syscall.
 //   COMMON_SYSCALL_POST_FORK(long res)
 //          Called after fork syscall.
+//   COMMON_SYSCALL_BLOCKING_START()
+//         Called before blocking syscall.
+//   COMMON_SYSCALL_BLOCKING_END()
+//         Called after blocking syscall.
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_platform.h"
@@ -85,6 +89,16 @@
       {}
 #  endif
 
+#  ifndef COMMON_SYSCALL_BLOCKING_START
+#    define COMMON_SYSCALL_BLOCKING_START() \
+      {}
+#  endif
+
+#  ifndef COMMON_SYSCALL_BLOCKING_END
+#    define COMMON_SYSCALL_BLOCKING_END() \
+      {}
+#  endif
+
 // FIXME: do some kind of PRE_READ for all syscall arguments (int(s) and such).
 
 extern "C" {
@@ -2808,6 +2822,15 @@ PRE_SYSCALL(fchownat)
 POST_SYSCALL(fchownat)
 (long res, long dfd, const void *filename, long user, long group, long flag) {}
 
+PRE_SYSCALL(fchmodat2)(long dfd, const void *filename, long mode, long flag) {
+  if (filename)
+    PRE_READ(filename,
+             __sanitizer::internal_strlen((const char *)filename) + 1);
+}
+
+POST_SYSCALL(fchmodat2)
+(long res, long dfd, const void *filename, long mode, long flag) {}
+
 PRE_SYSCALL(openat)(long dfd, const void *filename, long flags, long mode) {
   if (filename)
     PRE_READ(filename,
@@ -3167,6 +3190,18 @@ POST_SYSCALL(sigaltstack)(long res, void *ss, void *oss) {
     }
   }
 }
+
+PRE_SYSCALL(futex)
+(void *uaddr, long futex_op, long val, void *timeout, void *uaddr2, long val3) {
+  COMMON_SYSCALL_BLOCKING_START();
+}
+
+POST_SYSCALL(futex)
+(long res, void *uaddr, long futex_op, long val, void *timeout, void *uaddr2,
+ long val3) {
+  COMMON_SYSCALL_BLOCKING_END();
+}
+
 }  // extern "C"
 
 #  undef PRE_SYSCALL
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_dl.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_dl.cpp
new file mode 100644
index 0000000000..e957d529c2
--- /dev/null
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_dl.cpp
@@ -0,0 +1,37 @@
+//===-- sanitizer_dl.cpp --------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file has helper functions that depend on libc's dynamic loading
+// introspection.
+//
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_dl.h"
+
+#include "sanitizer_common/sanitizer_platform.h"
+
+#if SANITIZER_GLIBC
+#  include <dlfcn.h>
+#endif
+
+namespace __sanitizer {
+extern const char *SanitizerToolName;
+
+const char *DladdrSelfFName(void) {
+#if SANITIZER_GLIBC
+  Dl_info info;
+  int ret = dladdr((void *)&SanitizerToolName, &info);
+  if (ret) {
+    return info.dli_fname;
+  }
+#endif
+
+  return nullptr;
+}
+
+}  // namespace __sanitizer
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_dl.h b/zig/lib/tsan/sanitizer_common/sanitizer_dl.h
new file mode 100644
index 0000000000..ecde0664eb
--- /dev/null
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_dl.h
@@ -0,0 +1,26 @@
+//===-- sanitizer_dl.h ----------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file has helper functions that depend on libc's dynamic loading
+// introspection.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_DL_H
+#define SANITIZER_DL_H
+
+namespace __sanitizer {
+
+// Returns the path to the shared object or - in the case of statically linked
+// sanitizers
+// - the main program itself, that contains the sanitizer.
+const char* DladdrSelfFName(void);
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_DL_H
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_file.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_file.cpp
index 7ef499ce07..96af270f9d 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_file.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_file.cpp
@@ -69,7 +69,7 @@ void ReportFile::ReopenIfNecessary() {
     WriteToFile(kStderrFd, ErrorMsgPrefix, internal_strlen(ErrorMsgPrefix));
     WriteToFile(kStderrFd, full_path, internal_strlen(full_path));
     char errmsg[100];
-    internal_snprintf(errmsg, sizeof(errmsg), " (reason: %d)", err);
+    internal_snprintf(errmsg, sizeof(errmsg), " (reason: %d)\n", err);
     WriteToFile(kStderrFd, errmsg, internal_strlen(errmsg));
     Die();
   }
@@ -88,6 +88,8 @@ static void RecursiveCreateParentDirs(char *path) {
       const char *ErrorMsgPrefix = "ERROR: Can't create directory: ";
       WriteToFile(kStderrFd, ErrorMsgPrefix, internal_strlen(ErrorMsgPrefix));
       WriteToFile(kStderrFd, path, internal_strlen(path));
+      const char *ErrorMsgSuffix = "\n";
+      WriteToFile(kStderrFd, ErrorMsgSuffix, internal_strlen(ErrorMsgSuffix));
       Die();
     }
     path[i] = save;
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_file.h b/zig/lib/tsan/sanitizer_common/sanitizer_file.h
index 9459c6b00a..bef2c842d9 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_file.h
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_file.h
@@ -84,7 +84,7 @@ bool IsPathSeparator(const char c);
 bool IsAbsolutePath(const char *path);
 // Returns true on success, false on failure.
 bool CreateDir(const char *pathname);
-// Starts a subprocess and returs its pid.
+// Starts a subprocess and returns its pid.
 // If *_fd parameters are not kInvalidFd their corresponding input/output
 // streams will be redirect to the file. The files will always be closed
 // in parent process even in case of an error.
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_flag_parser.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_flag_parser.cpp
index c620da7f22..ca37df3485 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_flag_parser.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_flag_parser.cpp
@@ -19,8 +19,6 @@
 
 namespace __sanitizer {
 
-LowLevelAllocator FlagParser::Alloc;
-
 class UnknownFlags {
   static const int kMaxUnknownFlags = 20;
   const char *unknown_flags_[kMaxUnknownFlags];
@@ -49,7 +47,7 @@ void ReportUnrecognizedFlags() {
 
 char *FlagParser::ll_strndup(const char *s, uptr n) {
   uptr len = internal_strnlen(s, n);
-  char *s2 = (char*)Alloc.Allocate(len + 1);
+  char *s2 = (char *)GetGlobalLowLevelAllocator().Allocate(len + 1);
   internal_memcpy(s2, s, len);
   s2[len] = 0;
   return s2;
@@ -185,7 +183,8 @@ void FlagParser::RegisterHandler(const char *name, FlagHandlerBase *handler,
 }
 
 FlagParser::FlagParser() : n_flags_(0), buf_(nullptr), pos_(0) {
-  flags_ = (Flag *)Alloc.Allocate(sizeof(Flag) * kMaxFlags);
+  flags_ =
+      (Flag *)GetGlobalLowLevelAllocator().Allocate(sizeof(Flag) * kMaxFlags);
 }
 
 }  // namespace __sanitizer
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_flag_parser.h b/zig/lib/tsan/sanitizer_common/sanitizer_flag_parser.h
index ae49294dde..dccdee4da2 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_flag_parser.h
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_flag_parser.h
@@ -178,8 +178,6 @@ class FlagParser {
   bool ParseFile(const char *path, bool ignore_missing);
   void PrintFlagDescriptions();
 
-  static LowLevelAllocator Alloc;
-
  private:
   void fatal_error(const char *err);
   bool is_space(char c);
@@ -193,7 +191,7 @@ class FlagParser {
 template <typename T>
 static void RegisterFlag(FlagParser *parser, const char *name, const char *desc,
                          T *var) {
-  FlagHandler<T> *fh = new (FlagParser::Alloc) FlagHandler<T>(var);
+  FlagHandler<T> *fh = new (GetGlobalLowLevelAllocator()) FlagHandler<T>(var);
   parser->RegisterHandler(name, fh, desc);
 }
 
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_flags.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_flags.cpp
index d52e96a7c3..849a122386 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_flags.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_flags.cpp
@@ -108,11 +108,11 @@ class FlagHandlerInclude final : public FlagHandlerBase {
 };
 
 void RegisterIncludeFlags(FlagParser *parser, CommonFlags *cf) {
-  FlagHandlerInclude *fh_include = new (FlagParser::Alloc)
+  FlagHandlerInclude *fh_include = new (GetGlobalLowLevelAllocator())
       FlagHandlerInclude(parser, /*ignore_missing*/ false);
   parser->RegisterHandler("include", fh_include,
                           "read more options from the given file");
-  FlagHandlerInclude *fh_include_if_exists = new (FlagParser::Alloc)
+  FlagHandlerInclude *fh_include_if_exists = new (GetGlobalLowLevelAllocator())
       FlagHandlerInclude(parser, /*ignore_missing*/ true);
   parser->RegisterHandler(
       "include_if_exists", fh_include_if_exists,
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_flags.inc b/zig/lib/tsan/sanitizer_common/sanitizer_flags.inc
index 6148ae5606..c1e3530618 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_flags.inc
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_flags.inc
@@ -269,3 +269,16 @@ COMMON_FLAG(bool, detect_write_exec, false,
 COMMON_FLAG(bool, test_only_emulate_no_memorymap, false,
             "TEST ONLY fail to read memory mappings to emulate sanitized "
             "\"init\"")
+// With static linking, dladdr((void*)pthread_join) or similar will return the
+// path to the main program. This flag will replace dlopen(<main program,...>
+// with dlopen(NULL,...), which is the correct way to get a handle to the main
+// program.
+COMMON_FLAG(bool, test_only_replace_dlopen_main_program, false,
+            "TEST ONLY replace dlopen(<main program>,...) with dlopen(NULL)")
+
+COMMON_FLAG(bool, enable_symbolizer_markup, SANITIZER_FUCHSIA,
+            "Use sanitizer symbolizer markup, available on Linux "
+            "and always set true for Fuchsia.")
+
+COMMON_FLAG(bool, detect_invalid_join, true,
+            "If set, check invalid joins of threads.")
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_flat_map.h b/zig/lib/tsan/sanitizer_common/sanitizer_flat_map.h
index 8bb8304910..d246781fe1 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_flat_map.h
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_flat_map.h
@@ -109,6 +109,10 @@ class TwoLevelMap {
     return *AddressSpaceView::LoadWritable(&map2[idx % kSize2]);
   }
 
+  void Lock() SANITIZER_NO_THREAD_SAFETY_ANALYSIS { mu_.Lock(); }
+
+  void Unlock() SANITIZER_NO_THREAD_SAFETY_ANALYSIS { mu_.Unlock(); }
+
  private:
   constexpr uptr MmapSize() const {
     return RoundUpTo(kSize2 * sizeof(T), GetPageSizeCached());
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_freebsd.h b/zig/lib/tsan/sanitizer_common/sanitizer_freebsd.h
deleted file mode 100644
index 82b227eab6..0000000000
--- a/zig/lib/tsan/sanitizer_common/sanitizer_freebsd.h
+++ /dev/null
@@ -1,137 +0,0 @@
-//===-- sanitizer_freebsd.h -------------------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file is a part of Sanitizer runtime. It contains FreeBSD-specific
-// definitions.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef SANITIZER_FREEBSD_H
-#define SANITIZER_FREEBSD_H
-
-#include "sanitizer_internal_defs.h"
-
-// x86-64 FreeBSD 9.2 and older define 'ucontext_t' incorrectly in
-// 32-bit mode.
-#if SANITIZER_FREEBSD && (SANITIZER_WORDSIZE == 32)
-#include <osreldate.h>
-#if __FreeBSD_version <= 902001  // v9.2
-#include <link.h>
-#include <sys/param.h>
-#include <ucontext.h>
-
-namespace __sanitizer {
-
-typedef unsigned long long __xuint64_t;
-
-typedef __int32_t __xregister_t;
-
-typedef struct __xmcontext {
-  __xregister_t mc_onstack;
-  __xregister_t mc_gs;
-  __xregister_t mc_fs;
-  __xregister_t mc_es;
-  __xregister_t mc_ds;
-  __xregister_t mc_edi;
-  __xregister_t mc_esi;
-  __xregister_t mc_ebp;
-  __xregister_t mc_isp;
-  __xregister_t mc_ebx;
-  __xregister_t mc_edx;
-  __xregister_t mc_ecx;
-  __xregister_t mc_eax;
-  __xregister_t mc_trapno;
-  __xregister_t mc_err;
-  __xregister_t mc_eip;
-  __xregister_t mc_cs;
-  __xregister_t mc_eflags;
-  __xregister_t mc_esp;
-  __xregister_t mc_ss;
-
-  int mc_len;
-  int mc_fpformat;
-  int mc_ownedfp;
-  __xregister_t mc_flags;
-
-  int mc_fpstate[128] __aligned(16);
-  __xregister_t mc_fsbase;
-  __xregister_t mc_gsbase;
-  __xregister_t mc_xfpustate;
-  __xregister_t mc_xfpustate_len;
-
-  int mc_spare2[4];
-} xmcontext_t;
-
-typedef struct __xucontext {
-  sigset_t uc_sigmask;
-  xmcontext_t uc_mcontext;
-
-  struct __ucontext *uc_link;
-  stack_t uc_stack;
-  int uc_flags;
-  int __spare__[4];
-} xucontext_t;
-
-struct xkinfo_vmentry {
-  int kve_structsize;
-  int kve_type;
-  __xuint64_t kve_start;
-  __xuint64_t kve_end;
-  __xuint64_t kve_offset;
-  __xuint64_t kve_vn_fileid;
-  __uint32_t kve_vn_fsid;
-  int kve_flags;
-  int kve_resident;
-  int kve_private_resident;
-  int kve_protection;
-  int kve_ref_count;
-  int kve_shadow_count;
-  int kve_vn_type;
-  __xuint64_t kve_vn_size;
-  __uint32_t kve_vn_rdev;
-  __uint16_t kve_vn_mode;
-  __uint16_t kve_status;
-  int _kve_ispare[12];
-  char kve_path[PATH_MAX];
-};
-
-typedef struct {
-  __uint32_t p_type;
-  __uint32_t p_offset;
-  __uint32_t p_vaddr;
-  __uint32_t p_paddr;
-  __uint32_t p_filesz;
-  __uint32_t p_memsz;
-  __uint32_t p_flags;
-  __uint32_t p_align;
-} XElf32_Phdr;
-
-struct xdl_phdr_info {
-  Elf_Addr dlpi_addr;
-  const char *dlpi_name;
-  const XElf32_Phdr *dlpi_phdr;
-  Elf_Half dlpi_phnum;
-  unsigned long long int dlpi_adds;
-  unsigned long long int dlpi_subs;
-  size_t dlpi_tls_modid;
-  void *dlpi_tls_data;
-};
-
-typedef int (*__xdl_iterate_hdr_callback)(struct xdl_phdr_info *, size_t,
-                                          void *);
-typedef int xdl_iterate_phdr_t(__xdl_iterate_hdr_callback, void *);
-
-#define xdl_iterate_phdr(callback, param) \
-  (((xdl_iterate_phdr_t *)dl_iterate_phdr)((callback), (param)))
-
-}  // namespace __sanitizer
-
-#endif  // __FreeBSD_version <= 902001
-#endif  // SANITIZER_FREEBSD && (SANITIZER_WORDSIZE == 32)
-
-#endif  // SANITIZER_FREEBSD_H
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_fuchsia.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_fuchsia.cpp
index 1e25265c00..a67b2a8725 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_fuchsia.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_fuchsia.cpp
@@ -129,6 +129,60 @@ uptr GetMaxVirtualAddress() { return GetMaxUserVirtualAddress(); }
 
 bool ErrorIsOOM(error_t err) { return err == ZX_ERR_NO_MEMORY; }
 
+// For any sanitizer internal that needs to map something which can be unmapped
+// later, first attempt to map to a pre-allocated VMAR. This helps reduce
+// fragmentation from many small anonymous mmap calls. A good value for this
+// VMAR size would be the total size of your typical sanitizer internal objects
+// allocated in an "average" process lifetime. Examples of this include:
+// FakeStack, LowLevelAllocator mappings, TwoLevelMap, InternalMmapVector,
+// StackStore, CreateAsanThread, etc.
+//
+// This is roughly equal to the total sum of sanitizer internal mappings for a
+// large test case.
+constexpr size_t kSanitizerHeapVmarSize = 13ULL << 20;
+static zx_handle_t gSanitizerHeapVmar = ZX_HANDLE_INVALID;
+
+static zx_status_t GetSanitizerHeapVmar(zx_handle_t *vmar) {
+  zx_status_t status = ZX_OK;
+  if (gSanitizerHeapVmar == ZX_HANDLE_INVALID) {
+    CHECK_EQ(kSanitizerHeapVmarSize % GetPageSizeCached(), 0);
+    uintptr_t base;
+    status = _zx_vmar_allocate(
+        _zx_vmar_root_self(),
+        ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE | ZX_VM_CAN_MAP_SPECIFIC, 0,
+        kSanitizerHeapVmarSize, &gSanitizerHeapVmar, &base);
+  }
+  *vmar = gSanitizerHeapVmar;
+  if (status == ZX_OK)
+    CHECK_NE(gSanitizerHeapVmar, ZX_HANDLE_INVALID);
+  return status;
+}
+
+static zx_status_t TryVmoMapSanitizerVmar(zx_vm_option_t options,
+                                          size_t vmar_offset, zx_handle_t vmo,
+                                          size_t size, uintptr_t *addr,
+                                          zx_handle_t *vmar_used = nullptr) {
+  zx_handle_t vmar;
+  zx_status_t status = GetSanitizerHeapVmar(&vmar);
+  if (status != ZX_OK)
+    return status;
+
+  status = _zx_vmar_map(gSanitizerHeapVmar, options, vmar_offset, vmo,
+                        /*vmo_offset=*/0, size, addr);
+  if (vmar_used)
+    *vmar_used = gSanitizerHeapVmar;
+  if (status == ZX_ERR_NO_RESOURCES || status == ZX_ERR_INVALID_ARGS) {
+    // This means there's no space in the heap VMAR, so fallback to the root
+    // VMAR.
+    status = _zx_vmar_map(_zx_vmar_root_self(), options, vmar_offset, vmo,
+                          /*vmo_offset=*/0, size, addr);
+    if (vmar_used)
+      *vmar_used = _zx_vmar_root_self();
+  }
+
+  return status;
+}
+
 static void *DoAnonymousMmapOrDie(uptr size, const char *mem_type,
                                   bool raw_report, bool die_for_nomem) {
   size = RoundUpTo(size, GetPageSize());
@@ -144,11 +198,9 @@ static void *DoAnonymousMmapOrDie(uptr size, const char *mem_type,
   _zx_object_set_property(vmo, ZX_PROP_NAME, mem_type,
                           internal_strlen(mem_type));
 
-  // TODO(mcgrathr): Maybe allocate a VMAR for all sanitizer heap and use that?
   uintptr_t addr;
-  status =
-      _zx_vmar_map(_zx_vmar_root_self(), ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0,
-                   vmo, 0, size, &addr);
+  status = TryVmoMapSanitizerVmar(ZX_VM_PERM_READ | ZX_VM_PERM_WRITE,
+                                  /*vmar_offset=*/0, vmo, size, &addr);
   _zx_handle_close(vmo);
 
   if (status != ZX_OK) {
@@ -226,27 +278,32 @@ static uptr DoMmapFixedOrDie(zx_handle_t vmar, uptr fixed_addr, uptr map_size,
 
 uptr ReservedAddressRange::Map(uptr fixed_addr, uptr map_size,
                                const char *name) {
-  return DoMmapFixedOrDie(os_handle_, fixed_addr, map_size, base_, name_,
-                          false);
+  return DoMmapFixedOrDie(os_handle_, fixed_addr, map_size, base_,
+                          name ? name : name_, false);
 }
 
 uptr ReservedAddressRange::MapOrDie(uptr fixed_addr, uptr map_size,
                                     const char *name) {
-  return DoMmapFixedOrDie(os_handle_, fixed_addr, map_size, base_, name_, true);
+  return DoMmapFixedOrDie(os_handle_, fixed_addr, map_size, base_,
+                          name ? name : name_, true);
 }
 
-void UnmapOrDieVmar(void *addr, uptr size, zx_handle_t target_vmar) {
+void UnmapOrDieVmar(void *addr, uptr size, zx_handle_t target_vmar,
+                    bool raw_report) {
   if (!addr || !size)
     return;
   size = RoundUpTo(size, GetPageSize());
 
   zx_status_t status =
       _zx_vmar_unmap(target_vmar, reinterpret_cast<uintptr_t>(addr), size);
-  if (status != ZX_OK) {
-    Report("ERROR: %s failed to deallocate 0x%zx (%zd) bytes at address %p\n",
-           SanitizerToolName, size, size, addr);
-    CHECK("unable to unmap" && 0);
+  if (status == ZX_ERR_INVALID_ARGS && target_vmar == gSanitizerHeapVmar) {
+    // If there wasn't any space in the heap vmar, the fallback was the root
+    // vmar.
+    status = _zx_vmar_unmap(_zx_vmar_root_self(),
+                            reinterpret_cast<uintptr_t>(addr), size);
   }
+  if (status != ZX_OK)
+    ReportMunmapFailureAndDie(addr, size, status, raw_report);
 
   DecreaseTotalMmap(size);
 }
@@ -268,7 +325,8 @@ void ReservedAddressRange::Unmap(uptr addr, uptr size) {
   }
   // Partial unmapping does not affect the fact that the initial range is still
   // reserved, and the resulting unmapped memory can't be reused.
-  UnmapOrDieVmar(reinterpret_cast<void *>(addr), size, vmar);
+  UnmapOrDieVmar(reinterpret_cast<void *>(addr), size, vmar,
+                 /*raw_report=*/false);
 }
 
 // This should never be called.
@@ -307,17 +365,16 @@ void *MmapAlignedOrDieOnFatalError(uptr size, uptr alignment,
   _zx_object_set_property(vmo, ZX_PROP_NAME, mem_type,
                           internal_strlen(mem_type));
 
-  // TODO(mcgrathr): Maybe allocate a VMAR for all sanitizer heap and use that?
-
   // Map a larger size to get a chunk of address space big enough that
   // it surely contains an aligned region of the requested size.  Then
   // overwrite the aligned middle portion with a mapping from the
   // beginning of the VMO, and unmap the excess before and after.
   size_t map_size = size + alignment;
   uintptr_t addr;
-  status =
-      _zx_vmar_map(_zx_vmar_root_self(), ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0,
-                   vmo, 0, map_size, &addr);
+  zx_handle_t vmar_used;
+  status = TryVmoMapSanitizerVmar(ZX_VM_PERM_READ | ZX_VM_PERM_WRITE,
+                                  /*vmar_offset=*/0, vmo, map_size, &addr,
+                                  &vmar_used);
   if (status == ZX_OK) {
     uintptr_t map_addr = addr;
     uintptr_t map_end = map_addr + map_size;
@@ -325,12 +382,12 @@ void *MmapAlignedOrDieOnFatalError(uptr size, uptr alignment,
     uintptr_t end = addr + size;
     if (addr != map_addr) {
       zx_info_vmar_t info;
-      status = _zx_object_get_info(_zx_vmar_root_self(), ZX_INFO_VMAR, &info,
-                                   sizeof(info), NULL, NULL);
+      status = _zx_object_get_info(vmar_used, ZX_INFO_VMAR, &info, sizeof(info),
+                                   NULL, NULL);
       if (status == ZX_OK) {
         uintptr_t new_addr;
         status = _zx_vmar_map(
-            _zx_vmar_root_self(),
+            vmar_used,
             ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC_OVERWRITE,
             addr - info.base, vmo, 0, size, &new_addr);
         if (status == ZX_OK)
@@ -338,9 +395,9 @@ void *MmapAlignedOrDieOnFatalError(uptr size, uptr alignment,
       }
     }
     if (status == ZX_OK && addr != map_addr)
-      status = _zx_vmar_unmap(_zx_vmar_root_self(), map_addr, addr - map_addr);
+      status = _zx_vmar_unmap(vmar_used, map_addr, addr - map_addr);
     if (status == ZX_OK && end != map_end)
-      status = _zx_vmar_unmap(_zx_vmar_root_self(), end, map_end - end);
+      status = _zx_vmar_unmap(vmar_used, end, map_end - end);
   }
   _zx_handle_close(vmo);
 
@@ -355,8 +412,8 @@ void *MmapAlignedOrDieOnFatalError(uptr size, uptr alignment,
   return reinterpret_cast<void *>(addr);
 }
 
-void UnmapOrDie(void *addr, uptr size) {
-  UnmapOrDieVmar(addr, size, _zx_vmar_root_self());
+void UnmapOrDie(void *addr, uptr size, bool raw_report) {
+  UnmapOrDieVmar(addr, size, gSanitizerHeapVmar, raw_report);
 }
 
 void ReleaseMemoryPagesToOS(uptr beg, uptr end) {
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_hash.h b/zig/lib/tsan/sanitizer_common/sanitizer_hash.h
index f7cf9f234e..648fcfaa44 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_hash.h
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_hash.h
@@ -62,6 +62,6 @@ class MurMur2Hash64Builder {
     return x;
   }
 };
-}  //namespace __sanitizer
+}  // namespace __sanitizer
 
 #endif  // SANITIZER_HASH_H
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_internal_defs.h b/zig/lib/tsan/sanitizer_common/sanitizer_internal_defs.h
index 552d650679..eebfb00aad 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_internal_defs.h
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_internal_defs.h
@@ -15,6 +15,11 @@
 #include "sanitizer_platform.h"
 #include "sanitizer_redefine_builtins.h"
 
+// GCC does not understand __has_feature.
+#if !defined(__has_feature)
+#define __has_feature(x) 0
+#endif
+
 #ifndef SANITIZER_DEBUG
 # define SANITIZER_DEBUG 0
 #endif
@@ -30,13 +35,20 @@
 # define SANITIZER_INTERFACE_ATTRIBUTE __declspec(dllexport)
 #endif
 # define SANITIZER_WEAK_ATTRIBUTE
+#  define SANITIZER_WEAK_IMPORT
 #elif SANITIZER_GO
 # define SANITIZER_INTERFACE_ATTRIBUTE
 # define SANITIZER_WEAK_ATTRIBUTE
+#  define SANITIZER_WEAK_IMPORT
 #else
 # define SANITIZER_INTERFACE_ATTRIBUTE __attribute__((visibility("default")))
 # define SANITIZER_WEAK_ATTRIBUTE  __attribute__((weak))
-#endif
+#  if SANITIZER_APPLE
+#    define SANITIZER_WEAK_IMPORT extern "C" __attribute((weak_import))
+#  else
+#    define SANITIZER_WEAK_IMPORT extern "C" SANITIZER_WEAK_ATTRIBUTE
+#  endif  // SANITIZER_APPLE
+#endif    // SANITIZER_WINDOWS
 
 //--------------------------- WEAK FUNCTIONS ---------------------------------//
 // When working with weak functions, to simplify the code and make it more
@@ -179,15 +191,19 @@ typedef uptr OFF_T;
 #endif
 typedef u64  OFF64_T;
 
-#if (SANITIZER_WORDSIZE == 64) || SANITIZER_APPLE
-typedef uptr operator_new_size_type;
+#ifdef __SIZE_TYPE__
+typedef __SIZE_TYPE__ usize;
 #else
-# if defined(__s390__) && !defined(__s390x__)
-// Special case: 31-bit s390 has unsigned long as size_t.
-typedef unsigned long operator_new_size_type;
-# else
-typedef u32 operator_new_size_type;
-# endif
+// Since we use this for operator new, usize must match the real size_t, but on
+// 32-bit Windows the definition of uptr does not actually match uintptr_t or
+// size_t because we are working around typedef mismatches for the (S)SIZE_T
+// types used in interception.h.
+// Until the definition of uptr has been fixed we have to special case Win32.
+#  if SANITIZER_WINDOWS && SANITIZER_WORDSIZE == 32
+typedef unsigned int usize;
+#  else
+typedef uptr usize;
+#  endif
 #endif
 
 typedef u64 tid_t;
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_libc.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_libc.cpp
index 4a6fa5e8db..9318066afe 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_libc.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_libc.cpp
@@ -199,6 +199,14 @@ char *internal_strncat(char *dst, const char *src, uptr n) {
   return dst;
 }
 
+wchar_t *internal_wcscpy(wchar_t *dst, const wchar_t *src) {
+  wchar_t *dst_it = dst;
+  do {
+    *dst_it++ = *src++;
+  } while (*src);
+  return dst;
+}
+
 uptr internal_strlcpy(char *dst, const char *src, uptr maxlen) {
   const uptr srclen = internal_strlen(src);
   if (srclen < maxlen) {
@@ -218,6 +226,14 @@ char *internal_strncpy(char *dst, const char *src, uptr n) {
   return dst;
 }
 
+wchar_t *internal_wcsncpy(wchar_t *dst, const wchar_t *src, uptr n) {
+  uptr i;
+  for (i = 0; i < n && src[i]; ++i)
+    dst[i] = src[i];
+  internal_memset(dst + i, 0, (n - i) * sizeof(wchar_t));
+  return dst;
+}
+
 uptr internal_strnlen(const char *s, uptr maxlen) {
   uptr i = 0;
   while (i < maxlen && s[i]) i++;
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_libc.h b/zig/lib/tsan/sanitizer_common/sanitizer_libc.h
index e881db2079..1906569e2a 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_libc.h
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_libc.h
@@ -71,7 +71,8 @@ int internal_snprintf(char *buffer, uptr length, const char *format, ...)
     FORMAT(3, 4);
 uptr internal_wcslen(const wchar_t *s);
 uptr internal_wcsnlen(const wchar_t *s, uptr maxlen);
-
+wchar_t *internal_wcscpy(wchar_t *dst, const wchar_t *src);
+wchar_t *internal_wcsncpy(wchar_t *dst, const wchar_t *src, uptr maxlen);
 // Return true if all bytes in [mem, mem+size) are zero.
 // Optimized for the case when the result is true.
 bool mem_is_zero(const char *mem, uptr size);
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_libignore.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_libignore.cpp
index b7fc9444cc..f0e1e3d69d 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_libignore.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_libignore.cpp
@@ -105,8 +105,8 @@ void LibIgnore::OnLibraryLoaded(const char *name) {
           continue;
         if (IsPcInstrumented(range.beg) && IsPcInstrumented(range.end - 1))
           continue;
-        VReport(1, "Adding instrumented range 0x%zx-0x%zx from library '%s'\n",
-                range.beg, range.end, mod.full_name());
+        VReport(1, "Adding instrumented range %p-%p from library '%s'\n",
+                (void *)range.beg, (void *)range.end, mod.full_name());
         const uptr idx =
             atomic_load(&instrumented_ranges_count_, memory_order_relaxed);
         CHECK_LT(idx, ARRAY_SIZE(instrumented_code_ranges_));
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_linux.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_linux.cpp
index d2b3b63f3a..648df0c4e5 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_linux.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_linux.cpp
@@ -16,101 +16,105 @@
 #if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD || \
     SANITIZER_SOLARIS
 
-#include "sanitizer_common.h"
-#include "sanitizer_flags.h"
-#include "sanitizer_getauxval.h"
-#include "sanitizer_internal_defs.h"
-#include "sanitizer_libc.h"
-#include "sanitizer_linux.h"
-#include "sanitizer_mutex.h"
-#include "sanitizer_placement_new.h"
-#include "sanitizer_procmaps.h"
-
-#if SANITIZER_LINUX && !SANITIZER_GO
-#include <asm/param.h>
-#endif
+#  include "sanitizer_common.h"
+#  include "sanitizer_flags.h"
+#  include "sanitizer_getauxval.h"
+#  include "sanitizer_internal_defs.h"
+#  include "sanitizer_libc.h"
+#  include "sanitizer_linux.h"
+#  include "sanitizer_mutex.h"
+#  include "sanitizer_placement_new.h"
+#  include "sanitizer_procmaps.h"
+
+#  if SANITIZER_LINUX && !SANITIZER_GO
+#    include <asm/param.h>
+#  endif
 
 // For mips64, syscall(__NR_stat) fills the buffer in the 'struct kernel_stat'
 // format. Struct kernel_stat is defined as 'struct stat' in asm/stat.h. To
 // access stat from asm/stat.h, without conflicting with definition in
-// sys/stat.h, we use this trick.
-#if SANITIZER_MIPS64
-#include <asm/unistd.h>
-#include <sys/types.h>
-#define stat kernel_stat
-#if SANITIZER_GO
-#undef st_atime
-#undef st_mtime
-#undef st_ctime
-#define st_atime st_atim
-#define st_mtime st_mtim
-#define st_ctime st_ctim
-#endif
-#include <asm/stat.h>
-#undef stat
-#endif
+// sys/stat.h, we use this trick.  sparc64 is similar, using
+// syscall(__NR_stat64) and struct kernel_stat64.
+#  if SANITIZER_LINUX && (SANITIZER_MIPS64 || SANITIZER_SPARC64)
+#    include <asm/unistd.h>
+#    include <sys/types.h>
+#    define stat kernel_stat
+#    if SANITIZER_SPARC64
+#      define stat64 kernel_stat64
+#    endif
+#    if SANITIZER_GO
+#      undef st_atime
+#      undef st_mtime
+#      undef st_ctime
+#      define st_atime st_atim
+#      define st_mtime st_mtim
+#      define st_ctime st_ctim
+#    endif
+#    include <asm/stat.h>
+#    undef stat
+#    undef stat64
+#  endif
 
-#include <dlfcn.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <link.h>
-#include <pthread.h>
-#include <sched.h>
-#include <signal.h>
-#include <sys/mman.h>
-#include <sys/param.h>
-#if !SANITIZER_SOLARIS
-#include <sys/ptrace.h>
-#endif
-#include <sys/resource.h>
-#include <sys/stat.h>
-#include <sys/syscall.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <ucontext.h>
-#include <unistd.h>
-
-#if SANITIZER_LINUX
-#include <sys/utsname.h>
-#endif
+#  include <dlfcn.h>
+#  include <errno.h>
+#  include <fcntl.h>
+#  include <link.h>
+#  include <pthread.h>
+#  include <sched.h>
+#  include <signal.h>
+#  include <sys/mman.h>
+#  if !SANITIZER_SOLARIS
+#    include <sys/ptrace.h>
+#  endif
+#  include <sys/resource.h>
+#  include <sys/stat.h>
+#  include <sys/syscall.h>
+#  include <sys/time.h>
+#  include <sys/types.h>
+#  include <ucontext.h>
+#  include <unistd.h>
 
-#if SANITIZER_LINUX && !SANITIZER_ANDROID
-#include <sys/personality.h>
-#endif
+#  if SANITIZER_LINUX
+#    include <sys/utsname.h>
+#  endif
 
-#if SANITIZER_LINUX && defined(__loongarch__)
-#  include <sys/sysmacros.h>
-#endif
+#  if SANITIZER_LINUX && !SANITIZER_ANDROID
+#    include <sys/personality.h>
+#  endif
 
-#if SANITIZER_FREEBSD
-#include <sys/exec.h>
-#include <sys/procctl.h>
-#include <sys/sysctl.h>
-#include <machine/atomic.h>
+#  if SANITIZER_LINUX && defined(__loongarch__)
+#    include <sys/sysmacros.h>
+#  endif
+
+#  if SANITIZER_FREEBSD
+#    include <machine/atomic.h>
+#    include <sys/exec.h>
+#    include <sys/procctl.h>
+#    include <sys/sysctl.h>
 extern "C" {
 // <sys/umtx.h> must be included after <errno.h> and <sys/types.h> on
 // FreeBSD 9.2 and 10.0.
-#include <sys/umtx.h>
+#    include <sys/umtx.h>
 }
-#include <sys/thr.h>
-#endif  // SANITIZER_FREEBSD
+#    include <sys/thr.h>
+#  endif  // SANITIZER_FREEBSD
 
-#if SANITIZER_NETBSD
-#include <limits.h>  // For NAME_MAX
-#include <sys/sysctl.h>
-#include <sys/exec.h>
+#  if SANITIZER_NETBSD
+#    include <limits.h>  // For NAME_MAX
+#    include <sys/exec.h>
+#    include <sys/sysctl.h>
 extern struct ps_strings *__ps_strings;
-#endif  // SANITIZER_NETBSD
+#  endif  // SANITIZER_NETBSD
 
-#if SANITIZER_SOLARIS
-#include <stdlib.h>
-#include <thread.h>
-#define environ _environ
-#endif
+#  if SANITIZER_SOLARIS
+#    include <stdlib.h>
+#    include <thread.h>
+#    define environ _environ
+#  endif
 
 extern char **environ;
 
-#if SANITIZER_LINUX
+#  if SANITIZER_LINUX
 // <linux/time.h>
 struct kernel_timeval {
   long tv_sec;
@@ -123,36 +127,32 @@ const int FUTEX_WAKE = 1;
 const int FUTEX_PRIVATE_FLAG = 128;
 const int FUTEX_WAIT_PRIVATE = FUTEX_WAIT | FUTEX_PRIVATE_FLAG;
 const int FUTEX_WAKE_PRIVATE = FUTEX_WAKE | FUTEX_PRIVATE_FLAG;
-#endif  // SANITIZER_LINUX
+#  endif  // SANITIZER_LINUX
 
 // Are we using 32-bit or 64-bit Linux syscalls?
 // x32 (which defines __x86_64__) has SANITIZER_WORDSIZE == 32
 // but it still needs to use 64-bit syscalls.
-#if SANITIZER_LINUX && (defined(__x86_64__) || defined(__powerpc64__) || \
-                        SANITIZER_WORDSIZE == 64 ||                      \
-                        (defined(__mips__) && _MIPS_SIM == _ABIN32))
-# define SANITIZER_LINUX_USES_64BIT_SYSCALLS 1
-#else
-# define SANITIZER_LINUX_USES_64BIT_SYSCALLS 0
-#endif
+#  if SANITIZER_LINUX && (defined(__x86_64__) || defined(__powerpc64__) || \
+                          SANITIZER_WORDSIZE == 64 ||                      \
+                          (defined(__mips__) && _MIPS_SIM == _ABIN32))
+#    define SANITIZER_LINUX_USES_64BIT_SYSCALLS 1
+#  else
+#    define SANITIZER_LINUX_USES_64BIT_SYSCALLS 0
+#  endif
 
-// Note : FreeBSD had implemented both
-// Linux apis, available from
-// future 12.x version most likely
-#if SANITIZER_LINUX && defined(__NR_getrandom)
-# if !defined(GRND_NONBLOCK)
-#  define GRND_NONBLOCK 1
-# endif
-# define SANITIZER_USE_GETRANDOM 1
-#else
-# define SANITIZER_USE_GETRANDOM 0
-#endif  // SANITIZER_LINUX && defined(__NR_getrandom)
-
-#if SANITIZER_FREEBSD && __FreeBSD_version >= 1200000
-#  define SANITIZER_USE_GETENTROPY 1
-#else
-#  define SANITIZER_USE_GETENTROPY 0
-#endif
+// Note : FreeBSD implemented both Linux and OpenBSD apis.
+#  if SANITIZER_LINUX && defined(__NR_getrandom)
+#    if !defined(GRND_NONBLOCK)
+#      define GRND_NONBLOCK 1
+#    endif
+#    define SANITIZER_USE_GETRANDOM 1
+#  else
+#    define SANITIZER_USE_GETRANDOM 0
+#  endif  // SANITIZER_LINUX && defined(__NR_getrandom)
+
+#  if SANITIZER_FREEBSD
+#    define SANITIZER_USE_GETENTROPY 1
+#  endif
 
 namespace __sanitizer {
 
@@ -160,6 +160,7 @@ void SetSigProcMask(__sanitizer_sigset_t *set, __sanitizer_sigset_t *oldset) {
   CHECK_EQ(0, internal_sigprocmask(SIG_SETMASK, set, oldset));
 }
 
+// Block asynchronous signals
 void BlockSignals(__sanitizer_sigset_t *oldset) {
   __sanitizer_sigset_t set;
   internal_sigfillset(&set);
@@ -174,7 +175,17 @@ void BlockSignals(__sanitizer_sigset_t *oldset) {
   // If this signal is blocked, such calls cannot be handled and the process may
   // hang.
   internal_sigdelset(&set, 31);
+
+  // Don't block synchronous signals
+  internal_sigdelset(&set, SIGSEGV);
+  internal_sigdelset(&set, SIGBUS);
+  internal_sigdelset(&set, SIGILL);
+  internal_sigdelset(&set, SIGTRAP);
+  internal_sigdelset(&set, SIGABRT);
+  internal_sigdelset(&set, SIGFPE);
+  internal_sigdelset(&set, SIGPIPE);
 #  endif
+
   SetSigProcMask(&set, oldset);
 }
 
@@ -203,33 +214,33 @@ ScopedBlockSignals::~ScopedBlockSignals() { SetSigProcMask(&saved_, nullptr); }
 #  endif
 
 // --------------- sanitizer_libc.h
-#if !SANITIZER_SOLARIS && !SANITIZER_NETBSD
-#if !SANITIZER_S390
+#  if !SANITIZER_SOLARIS && !SANITIZER_NETBSD
+#    if !SANITIZER_S390
 uptr internal_mmap(void *addr, uptr length, int prot, int flags, int fd,
                    u64 offset) {
-#if SANITIZER_FREEBSD || SANITIZER_LINUX_USES_64BIT_SYSCALLS
+#      if SANITIZER_FREEBSD || SANITIZER_LINUX_USES_64BIT_SYSCALLS
   return internal_syscall(SYSCALL(mmap), (uptr)addr, length, prot, flags, fd,
                           offset);
-#else
+#      else
   // mmap2 specifies file offset in 4096-byte units.
   CHECK(IsAligned(offset, 4096));
   return internal_syscall(SYSCALL(mmap2), addr, length, prot, flags, fd,
-                          offset / 4096);
-#endif
+                          (OFF_T)(offset / 4096));
+#      endif
 }
-#endif // !SANITIZER_S390
+#    endif  // !SANITIZER_S390
 
 uptr internal_munmap(void *addr, uptr length) {
   return internal_syscall(SYSCALL(munmap), (uptr)addr, length);
 }
 
-#if SANITIZER_LINUX
+#    if SANITIZER_LINUX
 uptr internal_mremap(void *old_address, uptr old_size, uptr new_size, int flags,
                      void *new_address) {
   return internal_syscall(SYSCALL(mremap), (uptr)old_address, old_size,
                           new_size, flags, (uptr)new_address);
 }
-#endif
+#    endif
 
 int internal_mprotect(void *addr, uptr length, int prot) {
   return internal_syscall(SYSCALL(mprotect), (uptr)addr, length, prot);
@@ -239,25 +250,23 @@ int internal_madvise(uptr addr, uptr length, int advice) {
   return internal_syscall(SYSCALL(madvise), addr, length, advice);
 }
 
-uptr internal_close(fd_t fd) {
-  return internal_syscall(SYSCALL(close), fd);
-}
+uptr internal_close(fd_t fd) { return internal_syscall(SYSCALL(close), fd); }
 
 uptr internal_open(const char *filename, int flags) {
 #    if SANITIZER_LINUX
   return internal_syscall(SYSCALL(openat), AT_FDCWD, (uptr)filename, flags);
-#else
+#    else
   return internal_syscall(SYSCALL(open), (uptr)filename, flags);
-#endif
+#    endif
 }
 
 uptr internal_open(const char *filename, int flags, u32 mode) {
 #    if SANITIZER_LINUX
   return internal_syscall(SYSCALL(openat), AT_FDCWD, (uptr)filename, flags,
                           mode);
-#else
+#    else
   return internal_syscall(SYSCALL(open), (uptr)filename, flags, mode);
-#endif
+#    endif
 }
 
 uptr internal_read(fd_t fd, void *buf, uptr count) {
@@ -276,12 +285,12 @@ uptr internal_write(fd_t fd, const void *buf, uptr count) {
 
 uptr internal_ftruncate(fd_t fd, uptr size) {
   sptr res;
-  HANDLE_EINTR(res, (sptr)internal_syscall(SYSCALL(ftruncate), fd,
-               (OFF_T)size));
+  HANDLE_EINTR(res,
+               (sptr)internal_syscall(SYSCALL(ftruncate), fd, (OFF_T)size));
   return res;
 }
 
-#if (!SANITIZER_LINUX_USES_64BIT_SYSCALLS || SANITIZER_SPARC) && SANITIZER_LINUX
+#    if !SANITIZER_LINUX_USES_64BIT_SYSCALLS && SANITIZER_LINUX
 static void stat64_to_stat(struct stat64 *in, struct stat *out) {
   internal_memset(out, 0, sizeof(*out));
   out->st_dev = in->st_dev;
@@ -298,9 +307,9 @@ static void stat64_to_stat(struct stat64 *in, struct stat *out) {
   out->st_mtime = in->st_mtime;
   out->st_ctime = in->st_ctime;
 }
-#endif
+#    endif
 
-#if SANITIZER_LINUX && defined(__loongarch__)
+#    if SANITIZER_LINUX && defined(__loongarch__)
 static void statx_to_stat(struct statx *in, struct stat *out) {
   internal_memset(out, 0, sizeof(*out));
   out->st_dev = makedev(in->stx_dev_major, in->stx_dev_minor);
@@ -320,27 +329,32 @@ static void statx_to_stat(struct statx *in, struct stat *out) {
   out->st_ctime = in->stx_ctime.tv_sec;
   out->st_ctim.tv_nsec = in->stx_ctime.tv_nsec;
 }
-#endif
+#    endif
 
-#if SANITIZER_MIPS64
+#    if SANITIZER_MIPS64 || SANITIZER_SPARC64
+#      if SANITIZER_MIPS64
+typedef struct kernel_stat kstat_t;
+#      else
+typedef struct kernel_stat64 kstat_t;
+#      endif
 // Undefine compatibility macros from <sys/stat.h>
 // so that they would not clash with the kernel_stat
 // st_[a|m|c]time fields
-#if !SANITIZER_GO
-#undef st_atime
-#undef st_mtime
-#undef st_ctime
-#endif
-#if defined(SANITIZER_ANDROID)
+#      if !SANITIZER_GO
+#        undef st_atime
+#        undef st_mtime
+#        undef st_ctime
+#      endif
+#      if defined(SANITIZER_ANDROID)
 // Bionic sys/stat.h defines additional macros
 // for compatibility with the old NDKs and
 // they clash with the kernel_stat structure
 // st_[a|m|c]time_nsec fields.
-#undef st_atime_nsec
-#undef st_mtime_nsec
-#undef st_ctime_nsec
-#endif
-static void kernel_stat_to_stat(struct kernel_stat *in, struct stat *out) {
+#        undef st_atime_nsec
+#        undef st_mtime_nsec
+#        undef st_ctime_nsec
+#      endif
+static void kernel_stat_to_stat(kstat_t *in, struct stat *out) {
   internal_memset(out, 0, sizeof(*out));
   out->st_dev = in->st_dev;
   out->st_ino = in->st_ino;
@@ -352,96 +366,113 @@ static void kernel_stat_to_stat(struct kernel_stat *in, struct stat *out) {
   out->st_size = in->st_size;
   out->st_blksize = in->st_blksize;
   out->st_blocks = in->st_blocks;
-#if defined(__USE_MISC)     || \
-    defined(__USE_XOPEN2K8) || \
-    defined(SANITIZER_ANDROID)
+#      if defined(__USE_MISC) || defined(__USE_XOPEN2K8) || \
+          defined(SANITIZER_ANDROID)
   out->st_atim.tv_sec = in->st_atime;
   out->st_atim.tv_nsec = in->st_atime_nsec;
   out->st_mtim.tv_sec = in->st_mtime;
   out->st_mtim.tv_nsec = in->st_mtime_nsec;
   out->st_ctim.tv_sec = in->st_ctime;
   out->st_ctim.tv_nsec = in->st_ctime_nsec;
-#else
+#      else
   out->st_atime = in->st_atime;
   out->st_atimensec = in->st_atime_nsec;
   out->st_mtime = in->st_mtime;
   out->st_mtimensec = in->st_mtime_nsec;
   out->st_ctime = in->st_ctime;
   out->st_atimensec = in->st_ctime_nsec;
-#endif
+#      endif
 }
-#endif
+#    endif
 
 uptr internal_stat(const char *path, void *buf) {
-#  if SANITIZER_FREEBSD
+#    if SANITIZER_FREEBSD
   return internal_syscall(SYSCALL(fstatat), AT_FDCWD, (uptr)path, (uptr)buf, 0);
-#  elif SANITIZER_LINUX
-#    if defined(__loongarch__)
+#    elif SANITIZER_LINUX
+#      if defined(__loongarch__)
   struct statx bufx;
   int res = internal_syscall(SYSCALL(statx), AT_FDCWD, (uptr)path,
                              AT_NO_AUTOMOUNT, STATX_BASIC_STATS, (uptr)&bufx);
   statx_to_stat(&bufx, (struct stat *)buf);
   return res;
-#    elif (SANITIZER_WORDSIZE == 64 || SANITIZER_X32 ||    \
-           (defined(__mips__) && _MIPS_SIM == _ABIN32)) && \
-        !SANITIZER_SPARC
+#      elif (SANITIZER_WORDSIZE == 64 || SANITIZER_X32 ||    \
+             (defined(__mips__) && _MIPS_SIM == _ABIN32)) && \
+          !SANITIZER_SPARC
   return internal_syscall(SYSCALL(newfstatat), AT_FDCWD, (uptr)path, (uptr)buf,
                           0);
-#    else
+#      elif SANITIZER_SPARC64
+  kstat_t buf64;
+  int res = internal_syscall(SYSCALL(fstatat64), AT_FDCWD, (uptr)path,
+                             (uptr)&buf64, 0);
+  kernel_stat_to_stat(&buf64, (struct stat *)buf);
+  return res;
+#      else
   struct stat64 buf64;
   int res = internal_syscall(SYSCALL(fstatat64), AT_FDCWD, (uptr)path,
                              (uptr)&buf64, 0);
   stat64_to_stat(&buf64, (struct stat *)buf);
   return res;
-#    endif
-#  else
+#      endif
+#    else
   struct stat64 buf64;
   int res = internal_syscall(SYSCALL(stat64), path, &buf64);
   stat64_to_stat(&buf64, (struct stat *)buf);
   return res;
-#  endif
+#    endif
 }
 
 uptr internal_lstat(const char *path, void *buf) {
-#  if SANITIZER_FREEBSD
+#    if SANITIZER_FREEBSD
   return internal_syscall(SYSCALL(fstatat), AT_FDCWD, (uptr)path, (uptr)buf,
                           AT_SYMLINK_NOFOLLOW);
-#  elif SANITIZER_LINUX
-#    if defined(__loongarch__)
+#    elif SANITIZER_LINUX
+#      if defined(__loongarch__)
   struct statx bufx;
   int res = internal_syscall(SYSCALL(statx), AT_FDCWD, (uptr)path,
                              AT_SYMLINK_NOFOLLOW | AT_NO_AUTOMOUNT,
                              STATX_BASIC_STATS, (uptr)&bufx);
   statx_to_stat(&bufx, (struct stat *)buf);
   return res;
-#    elif (defined(_LP64) || SANITIZER_X32 ||              \
-           (defined(__mips__) && _MIPS_SIM == _ABIN32)) && \
-        !SANITIZER_SPARC
+#      elif (defined(_LP64) || SANITIZER_X32 ||              \
+             (defined(__mips__) && _MIPS_SIM == _ABIN32)) && \
+          !SANITIZER_SPARC
   return internal_syscall(SYSCALL(newfstatat), AT_FDCWD, (uptr)path, (uptr)buf,
                           AT_SYMLINK_NOFOLLOW);
-#    else
+#      elif SANITIZER_SPARC64
+  kstat_t buf64;
+  int res = internal_syscall(SYSCALL(fstatat64), AT_FDCWD, (uptr)path,
+                             (uptr)&buf64, AT_SYMLINK_NOFOLLOW);
+  kernel_stat_to_stat(&buf64, (struct stat *)buf);
+  return res;
+#      else
   struct stat64 buf64;
   int res = internal_syscall(SYSCALL(fstatat64), AT_FDCWD, (uptr)path,
                              (uptr)&buf64, AT_SYMLINK_NOFOLLOW);
   stat64_to_stat(&buf64, (struct stat *)buf);
   return res;
-#    endif
-#  else
+#      endif
+#    else
   struct stat64 buf64;
   int res = internal_syscall(SYSCALL(lstat64), path, &buf64);
   stat64_to_stat(&buf64, (struct stat *)buf);
   return res;
-#  endif
+#    endif
 }
 
 uptr internal_fstat(fd_t fd, void *buf) {
-#if SANITIZER_FREEBSD || SANITIZER_LINUX_USES_64BIT_SYSCALLS
-#if SANITIZER_MIPS64
+#    if SANITIZER_FREEBSD || SANITIZER_LINUX_USES_64BIT_SYSCALLS
+#      if SANITIZER_MIPS64
   // For mips64, fstat syscall fills buffer in the format of kernel_stat
-  struct kernel_stat kbuf;
+  kstat_t kbuf;
   int res = internal_syscall(SYSCALL(fstat), fd, &kbuf);
   kernel_stat_to_stat(&kbuf, (struct stat *)buf);
   return res;
+#      elif SANITIZER_LINUX && SANITIZER_SPARC64
+  // For sparc64, fstat64 syscall fills buffer in the format of kernel_stat64
+  kstat_t kbuf;
+  int res = internal_syscall(SYSCALL(fstat64), fd, &kbuf);
+  kernel_stat_to_stat(&kbuf, (struct stat *)buf);
+  return res;
 #      elif SANITIZER_LINUX && defined(__loongarch__)
   struct statx bufx;
   int res = internal_syscall(SYSCALL(statx), fd, "", AT_EMPTY_PATH,
@@ -451,12 +482,12 @@ uptr internal_fstat(fd_t fd, void *buf) {
 #      else
   return internal_syscall(SYSCALL(fstat), fd, (uptr)buf);
 #      endif
-#else
+#    else
   struct stat64 buf64;
   int res = internal_syscall(SYSCALL(fstat64), fd, &buf64);
   stat64_to_stat(&buf64, (struct stat *)buf);
   return res;
-#endif
+#    endif
 }
 
 uptr internal_filesize(fd_t fd) {
@@ -466,50 +497,46 @@ uptr internal_filesize(fd_t fd) {
   return (uptr)st.st_size;
 }
 
-uptr internal_dup(int oldfd) {
-  return internal_syscall(SYSCALL(dup), oldfd);
-}
+uptr internal_dup(int oldfd) { return internal_syscall(SYSCALL(dup), oldfd); }
 
 uptr internal_dup2(int oldfd, int newfd) {
 #    if SANITIZER_LINUX
   return internal_syscall(SYSCALL(dup3), oldfd, newfd, 0);
-#else
+#    else
   return internal_syscall(SYSCALL(dup2), oldfd, newfd);
-#endif
+#    endif
 }
 
 uptr internal_readlink(const char *path, char *buf, uptr bufsize) {
 #    if SANITIZER_LINUX
   return internal_syscall(SYSCALL(readlinkat), AT_FDCWD, (uptr)path, (uptr)buf,
                           bufsize);
-#else
+#    else
   return internal_syscall(SYSCALL(readlink), (uptr)path, (uptr)buf, bufsize);
-#endif
+#    endif
 }
 
 uptr internal_unlink(const char *path) {
 #    if SANITIZER_LINUX
   return internal_syscall(SYSCALL(unlinkat), AT_FDCWD, (uptr)path, 0);
-#else
+#    else
   return internal_syscall(SYSCALL(unlink), (uptr)path);
-#endif
+#    endif
 }
 
 uptr internal_rename(const char *oldpath, const char *newpath) {
-#  if (defined(__riscv) || defined(__loongarch__)) && defined(__linux__)
+#    if (defined(__riscv) || defined(__loongarch__)) && defined(__linux__)
   return internal_syscall(SYSCALL(renameat2), AT_FDCWD, (uptr)oldpath, AT_FDCWD,
                           (uptr)newpath, 0);
-#  elif SANITIZER_LINUX
+#    elif SANITIZER_LINUX
   return internal_syscall(SYSCALL(renameat), AT_FDCWD, (uptr)oldpath, AT_FDCWD,
                           (uptr)newpath);
-#  else
+#    else
   return internal_syscall(SYSCALL(rename), (uptr)oldpath, (uptr)newpath);
-#  endif
+#    endif
 }
 
-uptr internal_sched_yield() {
-  return internal_syscall(SYSCALL(sched_yield));
-}
+uptr internal_sched_yield() { return internal_syscall(SYSCALL(sched_yield)); }
 
 void internal_usleep(u64 useconds) {
   struct timespec ts;
@@ -523,18 +550,18 @@ uptr internal_execve(const char *filename, char *const argv[],
   return internal_syscall(SYSCALL(execve), (uptr)filename, (uptr)argv,
                           (uptr)envp);
 }
-#endif  // !SANITIZER_SOLARIS && !SANITIZER_NETBSD
+#  endif  // !SANITIZER_SOLARIS && !SANITIZER_NETBSD
 
-#if !SANITIZER_NETBSD
+#  if !SANITIZER_NETBSD
 void internal__exit(int exitcode) {
-#if SANITIZER_FREEBSD || SANITIZER_SOLARIS
+#    if SANITIZER_FREEBSD || SANITIZER_SOLARIS
   internal_syscall(SYSCALL(exit), exitcode);
-#else
+#    else
   internal_syscall(SYSCALL(exit_group), exitcode);
-#endif
+#    endif
   Die();  // Unreachable.
 }
-#endif  // !SANITIZER_NETBSD
+#  endif  // !SANITIZER_NETBSD
 
 // ----------------- sanitizer_common.h
 bool FileExists(const char *filename) {
@@ -556,30 +583,32 @@ bool DirExists(const char *path) {
 
 #  if !SANITIZER_NETBSD
 tid_t GetTid() {
-#if SANITIZER_FREEBSD
+#    if SANITIZER_FREEBSD
   long Tid;
   thr_self(&Tid);
   return Tid;
-#elif SANITIZER_SOLARIS
+#    elif SANITIZER_SOLARIS
   return thr_self();
-#else
+#    else
   return internal_syscall(SYSCALL(gettid));
-#endif
+#    endif
 }
 
 int TgKill(pid_t pid, tid_t tid, int sig) {
-#if SANITIZER_LINUX
+#    if SANITIZER_LINUX
   return internal_syscall(SYSCALL(tgkill), pid, tid, sig);
-#elif SANITIZER_FREEBSD
+#    elif SANITIZER_FREEBSD
   return internal_syscall(SYSCALL(thr_kill2), pid, tid, sig);
-#elif SANITIZER_SOLARIS
+#    elif SANITIZER_SOLARIS
   (void)pid;
-  return thr_kill(tid, sig);
-#endif
+  errno = thr_kill(tid, sig);
+  // TgKill is expected to return -1 on error, not an errno.
+  return errno != 0 ? -1 : 0;
+#    endif
 }
-#endif
+#  endif
 
-#if SANITIZER_GLIBC
+#  if SANITIZER_GLIBC
 u64 NanoTime() {
   kernel_timeval tv;
   internal_memset(&tv, 0, sizeof(tv));
@@ -590,19 +619,19 @@ u64 NanoTime() {
 uptr internal_clock_gettime(__sanitizer_clockid_t clk_id, void *tp) {
   return internal_syscall(SYSCALL(clock_gettime), clk_id, tp);
 }
-#elif !SANITIZER_SOLARIS && !SANITIZER_NETBSD
+#  elif !SANITIZER_SOLARIS && !SANITIZER_NETBSD
 u64 NanoTime() {
   struct timespec ts;
   clock_gettime(CLOCK_REALTIME, &ts);
   return (u64)ts.tv_sec * 1000 * 1000 * 1000 + ts.tv_nsec;
 }
-#endif
+#  endif
 
 // Like getenv, but reads env directly from /proc (on Linux) or parses the
 // 'environ' array (on some others) and does not use libc. This function
 // should be called first inside __asan_init.
 const char *GetEnv(const char *name) {
-#if SANITIZER_FREEBSD || SANITIZER_NETBSD || SANITIZER_SOLARIS
+#  if SANITIZER_FREEBSD || SANITIZER_NETBSD || SANITIZER_SOLARIS
   if (::environ != 0) {
     uptr NameLen = internal_strlen(name);
     for (char **Env = ::environ; *Env != 0; Env++) {
@@ -611,7 +640,7 @@ const char *GetEnv(const char *name) {
     }
   }
   return 0;  // Not found.
-#elif SANITIZER_LINUX
+#  elif SANITIZER_LINUX
   static char *environ;
   static uptr len;
   static bool inited;
@@ -621,13 +650,13 @@ const char *GetEnv(const char *name) {
     if (!ReadFileToBuffer("/proc/self/environ", &environ, &environ_size, &len))
       environ = nullptr;
   }
-  if (!environ || len == 0) return nullptr;
+  if (!environ || len == 0)
+    return nullptr;
   uptr namelen = internal_strlen(name);
   const char *p = environ;
   while (*p != '\0') {  // will happen at the \0\0 that terminates the buffer
     // proc file has the format NAME=value\0NAME=value\0NAME=value\0...
-    const char* endp =
-        (char*)internal_memchr(p, '\0', len - (p - environ));
+    const char *endp = (char *)internal_memchr(p, '\0', len - (p - environ));
     if (!endp)  // this entry isn't NUL terminated
       return nullptr;
     else if (!internal_memcmp(p, name, namelen) && p[namelen] == '=')  // Match.
@@ -635,18 +664,18 @@ const char *GetEnv(const char *name) {
     p = endp + 1;
   }
   return nullptr;  // Not found.
-#else
-#error "Unsupported platform"
-#endif
+#  else
+#    error "Unsupported platform"
+#  endif
 }
 
-#if !SANITIZER_FREEBSD && !SANITIZER_NETBSD && !SANITIZER_GO
+#  if !SANITIZER_FREEBSD && !SANITIZER_NETBSD && !SANITIZER_GO
 extern "C" {
 SANITIZER_WEAK_ATTRIBUTE extern void *__libc_stack_end;
 }
-#endif
+#  endif
 
-#if !SANITIZER_FREEBSD && !SANITIZER_NETBSD
+#  if !SANITIZER_FREEBSD && !SANITIZER_NETBSD
 static void ReadNullSepFileToArray(const char *path, char ***arr,
                                    int arr_size) {
   char *buff;
@@ -659,20 +688,21 @@ static void ReadNullSepFileToArray(const char *path, char ***arr,
   }
   (*arr)[0] = buff;
   int count, i;
-  for (count = 1, i = 1; ; i++) {
+  for (count = 1, i = 1;; i++) {
     if (buff[i] == 0) {
-      if (buff[i+1] == 0) break;
-      (*arr)[count] = &buff[i+1];
+      if (buff[i + 1] == 0)
+        break;
+      (*arr)[count] = &buff[i + 1];
       CHECK_LE(count, arr_size - 1);  // FIXME: make this more flexible.
       count++;
     }
   }
   (*arr)[count] = nullptr;
 }
-#endif
+#  endif
 
 static void GetArgsAndEnv(char ***argv, char ***envp) {
-#if SANITIZER_FREEBSD
+#  if SANITIZER_FREEBSD
   // On FreeBSD, retrieving the argument and environment arrays is done via the
   // kern.ps_strings sysctl, which returns a pointer to a structure containing
   // this information. See also <sys/exec.h>.
@@ -684,30 +714,30 @@ static void GetArgsAndEnv(char ***argv, char ***envp) {
   }
   *argv = pss->ps_argvstr;
   *envp = pss->ps_envstr;
-#elif SANITIZER_NETBSD
+#  elif SANITIZER_NETBSD
   *argv = __ps_strings->ps_argvstr;
   *envp = __ps_strings->ps_envstr;
-#else // SANITIZER_FREEBSD
-#if !SANITIZER_GO
+#  else  // SANITIZER_FREEBSD
+#    if !SANITIZER_GO
   if (&__libc_stack_end) {
-    uptr* stack_end = (uptr*)__libc_stack_end;
+    uptr *stack_end = (uptr *)__libc_stack_end;
     // Normally argc can be obtained from *stack_end, however, on ARM glibc's
     // _start clobbers it:
     // https://sourceware.org/git/?p=glibc.git;a=blob;f=sysdeps/arm/start.S;hb=refs/heads/release/2.31/master#l75
     // Do not special-case ARM and infer argc from argv everywhere.
     int argc = 0;
     while (stack_end[argc + 1]) argc++;
-    *argv = (char**)(stack_end + 1);
-    *envp = (char**)(stack_end + argc + 2);
+    *argv = (char **)(stack_end + 1);
+    *envp = (char **)(stack_end + argc + 2);
   } else {
-#endif // !SANITIZER_GO
+#    endif  // !SANITIZER_GO
     static const int kMaxArgv = 2000, kMaxEnvp = 2000;
     ReadNullSepFileToArray("/proc/self/cmdline", argv, kMaxArgv);
     ReadNullSepFileToArray("/proc/self/environ", envp, kMaxEnvp);
-#if !SANITIZER_GO
+#    if !SANITIZER_GO
   }
-#endif // !SANITIZER_GO
-#endif // SANITIZER_FREEBSD
+#    endif  // !SANITIZER_GO
+#  endif    // SANITIZER_FREEBSD
 }
 
 char **GetArgv() {
@@ -722,12 +752,12 @@ char **GetEnviron() {
   return envp;
 }
 
-#if !SANITIZER_SOLARIS
+#  if !SANITIZER_SOLARIS
 void FutexWait(atomic_uint32_t *p, u32 cmp) {
 #    if SANITIZER_FREEBSD
   _umtx_op(p, UMTX_OP_WAIT_UINT, cmp, 0, 0);
 #    elif SANITIZER_NETBSD
-  sched_yield();   /* No userspace futex-like synchronization */
+  sched_yield(); /* No userspace futex-like synchronization */
 #    else
   internal_syscall(SYSCALL(futex), (uptr)p, FUTEX_WAIT_PRIVATE, cmp, 0, 0, 0);
 #    endif
@@ -737,7 +767,7 @@ void FutexWake(atomic_uint32_t *p, u32 count) {
 #    if SANITIZER_FREEBSD
   _umtx_op(p, UMTX_OP_WAKE, count, 0, 0);
 #    elif SANITIZER_NETBSD
-                   /* No userspace futex-like synchronization */
+  /* No userspace futex-like synchronization */
 #    else
   internal_syscall(SYSCALL(futex), (uptr)p, FUTEX_WAKE_PRIVATE, count, 0, 0, 0);
 #    endif
@@ -749,26 +779,26 @@ void FutexWake(atomic_uint32_t *p, u32 count) {
 // The actual size of this structure is specified by d_reclen.
 // Note that getdents64 uses a different structure format. We only provide the
 // 32-bit syscall here.
-#if SANITIZER_NETBSD
+#  if SANITIZER_NETBSD
 // Not used
-#else
+#  else
 struct linux_dirent {
 #    if SANITIZER_X32 || SANITIZER_LINUX
   u64 d_ino;
   u64 d_off;
 #    else
-  unsigned long      d_ino;
-  unsigned long      d_off;
+  unsigned long d_ino;
+  unsigned long d_off;
 #    endif
-  unsigned short     d_reclen;
+  unsigned short d_reclen;
 #    if SANITIZER_LINUX
-  unsigned char      d_type;
+  unsigned char d_type;
 #    endif
-  char               d_name[256];
+  char d_name[256];
 };
-#endif
+#  endif
 
-#if !SANITIZER_SOLARIS && !SANITIZER_NETBSD
+#  if !SANITIZER_SOLARIS && !SANITIZER_NETBSD
 // Syscall wrappers.
 uptr internal_ptrace(int request, int pid, void *addr, void *data) {
   return internal_syscall(SYSCALL(ptrace), request, pid, (uptr)addr,
@@ -780,24 +810,20 @@ uptr internal_waitpid(int pid, int *status, int options) {
                           0 /* rusage */);
 }
 
-uptr internal_getpid() {
-  return internal_syscall(SYSCALL(getpid));
-}
+uptr internal_getpid() { return internal_syscall(SYSCALL(getpid)); }
 
-uptr internal_getppid() {
-  return internal_syscall(SYSCALL(getppid));
-}
+uptr internal_getppid() { return internal_syscall(SYSCALL(getppid)); }
 
 int internal_dlinfo(void *handle, int request, void *p) {
-#if SANITIZER_FREEBSD
+#    if SANITIZER_FREEBSD
   return dlinfo(handle, request, p);
-#else
+#    else
   UNIMPLEMENTED();
-#endif
+#    endif
 }
 
 uptr internal_getdents(fd_t fd, struct linux_dirent *dirp, unsigned int count) {
-#if SANITIZER_FREEBSD
+#    if SANITIZER_FREEBSD
   return internal_syscall(SYSCALL(getdirentries), fd, (uptr)dirp, count, NULL);
 #    elif SANITIZER_LINUX
   return internal_syscall(SYSCALL(getdents64), fd, (uptr)dirp, count);
@@ -810,7 +836,7 @@ uptr internal_lseek(fd_t fd, OFF_T offset, int whence) {
   return internal_syscall(SYSCALL(lseek), fd, offset, whence);
 }
 
-#if SANITIZER_LINUX
+#    if SANITIZER_LINUX
 uptr internal_prctl(int option, uptr arg2, uptr arg3, uptr arg4, uptr arg5) {
   return internal_syscall(SYSCALL(prctl), option, arg2, arg3, arg4, arg5);
 }
@@ -827,10 +853,16 @@ uptr internal_sigaltstack(const void *ss, void *oss) {
   return internal_syscall(SYSCALL(sigaltstack), (uptr)ss, (uptr)oss);
 }
 
+extern "C" pid_t __fork(void);
+
 int internal_fork() {
 #    if SANITIZER_LINUX
 #      if SANITIZER_S390
   return internal_syscall(SYSCALL(clone), 0, SIGCHLD);
+#      elif SANITIZER_SPARC
+  // The clone syscall interface on SPARC differs massively from the rest,
+  // so fall back to __fork.
+  return __fork();
 #      else
   return internal_syscall(SYSCALL(clone), SIGCHLD, 0);
 #      endif
@@ -839,7 +871,7 @@ int internal_fork() {
 #    endif
 }
 
-#if SANITIZER_FREEBSD
+#    if SANITIZER_FREEBSD
 int internal_sysctl(const int *name, unsigned int namelen, void *oldp,
                     uptr *oldlenp, const void *newp, uptr newlen) {
   return internal_syscall(SYSCALL(__sysctl), name, namelen, oldp,
@@ -854,11 +886,11 @@ int internal_sysctlbyname(const char *sname, void *oldp, uptr *oldlenp,
   // followed by sysctl(). To avoid calling the intercepted version and
   // asserting if this happens during startup, call the real sysctlnametomib()
   // followed by internal_sysctl() if the syscall is not available.
-#ifdef SYS___sysctlbyname
+#      ifdef SYS___sysctlbyname
   return internal_syscall(SYSCALL(__sysctlbyname), sname,
                           internal_strlen(sname), oldp, (size_t *)oldlenp, newp,
                           (size_t)newlen);
-#else
+#      else
   static decltype(sysctlnametomib) *real_sysctlnametomib = nullptr;
   if (!real_sysctlnametomib)
     real_sysctlnametomib =
@@ -870,12 +902,12 @@ int internal_sysctlbyname(const char *sname, void *oldp, uptr *oldlenp,
   if (real_sysctlnametomib(sname, oid, &len) == -1)
     return (-1);
   return internal_sysctl(oid, len, oldp, oldlenp, newp, newlen);
-#endif
+#      endif
 }
-#endif
+#    endif
 
-#if SANITIZER_LINUX
-#define SA_RESTORER 0x04000000
+#    if SANITIZER_LINUX
+#      define SA_RESTORER 0x04000000
 // Doesn't set sa_restorer if the caller did not set it, so use with caution
 //(see below).
 int internal_sigaction_norestorer(int signum, const void *act, void *oldact) {
@@ -899,15 +931,15 @@ int internal_sigaction_norestorer(int signum, const void *act, void *oldact) {
     // rt_sigaction, so we need to do the same (we'll need to reimplement the
     // restorers; for x86_64 the restorer address can be obtained from
     // oldact->sa_restorer upon a call to sigaction(xxx, NULL, oldact).
-#if !SANITIZER_ANDROID || !SANITIZER_MIPS32
+#      if !SANITIZER_ANDROID || !SANITIZER_MIPS32
     k_act.sa_restorer = u_act->sa_restorer;
-#endif
+#      endif
   }
 
   uptr result = internal_syscall(SYSCALL(rt_sigaction), (uptr)signum,
-      (uptr)(u_act ? &k_act : nullptr),
-      (uptr)(u_oldact ? &k_oldact : nullptr),
-      (uptr)sizeof(__sanitizer_kernel_sigset_t));
+                                 (uptr)(u_act ? &k_act : nullptr),
+                                 (uptr)(u_oldact ? &k_oldact : nullptr),
+                                 (uptr)sizeof(__sanitizer_kernel_sigset_t));
 
   if ((result == 0) && u_oldact) {
     u_oldact->handler = k_oldact.handler;
@@ -915,24 +947,24 @@ int internal_sigaction_norestorer(int signum, const void *act, void *oldact) {
     internal_memcpy(&u_oldact->sa_mask, &k_oldact.sa_mask,
                     sizeof(__sanitizer_kernel_sigset_t));
     u_oldact->sa_flags = k_oldact.sa_flags;
-#if !SANITIZER_ANDROID || !SANITIZER_MIPS32
+#      if !SANITIZER_ANDROID || !SANITIZER_MIPS32
     u_oldact->sa_restorer = k_oldact.sa_restorer;
-#endif
+#      endif
   }
   return result;
 }
-#endif  // SANITIZER_LINUX
+#    endif  // SANITIZER_LINUX
 
 uptr internal_sigprocmask(int how, __sanitizer_sigset_t *set,
                           __sanitizer_sigset_t *oldset) {
-#if SANITIZER_FREEBSD
+#    if SANITIZER_FREEBSD
   return internal_syscall(SYSCALL(sigprocmask), how, set, oldset);
-#else
+#    else
   __sanitizer_kernel_sigset_t *k_set = (__sanitizer_kernel_sigset_t *)set;
   __sanitizer_kernel_sigset_t *k_oldset = (__sanitizer_kernel_sigset_t *)oldset;
   return internal_syscall(SYSCALL(rt_sigprocmask), (uptr)how, (uptr)k_set,
                           (uptr)k_oldset, sizeof(__sanitizer_kernel_sigset_t));
-#endif
+#    endif
 }
 
 void internal_sigfillset(__sanitizer_sigset_t *set) {
@@ -943,7 +975,7 @@ void internal_sigemptyset(__sanitizer_sigset_t *set) {
   internal_memset(set, 0, sizeof(*set));
 }
 
-#if SANITIZER_LINUX
+#    if SANITIZER_LINUX
 void internal_sigdelset(__sanitizer_sigset_t *set, int signum) {
   signum -= 1;
   CHECK_GE(signum, 0);
@@ -963,7 +995,7 @@ bool internal_sigismember(__sanitizer_sigset_t *set, int signum) {
   const uptr bit = signum % (sizeof(k_set->sig[0]) * 8);
   return k_set->sig[idx] & ((uptr)1 << bit);
 }
-#elif SANITIZER_FREEBSD
+#    elif SANITIZER_FREEBSD
 uptr internal_procctl(int type, int id, int cmd, void *data) {
   return internal_syscall(SYSCALL(procctl), type, id, cmd, data);
 }
@@ -977,10 +1009,10 @@ bool internal_sigismember(__sanitizer_sigset_t *set, int signum) {
   sigset_t *rset = reinterpret_cast<sigset_t *>(set);
   return sigismember(rset, signum);
 }
-#endif
-#endif // !SANITIZER_SOLARIS
+#    endif
+#  endif  // !SANITIZER_SOLARIS
 
-#if !SANITIZER_NETBSD
+#  if !SANITIZER_NETBSD
 // ThreadLister implementation.
 ThreadLister::ThreadLister(pid_t pid) : pid_(pid), buffer_(4096) {
   char task_directory_path[80];
@@ -1067,25 +1099,26 @@ ThreadLister::~ThreadLister() {
   if (!internal_iserror(descriptor_))
     internal_close(descriptor_);
 }
-#endif
+#  endif
 
-#if SANITIZER_WORDSIZE == 32
+#  if SANITIZER_WORDSIZE == 32
 // Take care of unusable kernel area in top gigabyte.
 static uptr GetKernelAreaSize() {
-#if SANITIZER_LINUX && !SANITIZER_X32
+#    if SANITIZER_LINUX && !SANITIZER_X32
   const uptr gbyte = 1UL << 30;
 
   // Firstly check if there are writable segments
   // mapped to top gigabyte (e.g. stack).
-  MemoryMappingLayout proc_maps(/*cache_enabled*/true);
+  MemoryMappingLayout proc_maps(/*cache_enabled*/ true);
   if (proc_maps.Error())
     return 0;
   MemoryMappedSegment segment;
   while (proc_maps.Next(&segment)) {
-    if ((segment.end >= 3 * gbyte) && segment.IsWritable()) return 0;
+    if ((segment.end >= 3 * gbyte) && segment.IsWritable())
+      return 0;
   }
 
-#if !SANITIZER_ANDROID
+#      if !SANITIZER_ANDROID
   // Even if nothing is mapped, top Gb may still be accessible
   // if we are running on 64-bit kernel.
   // Uname may report misleading results if personality type
@@ -1095,21 +1128,22 @@ static uptr GetKernelAreaSize() {
   if (!(pers & PER_MASK) && internal_uname(&uname_info) == 0 &&
       internal_strstr(uname_info.machine, "64"))
     return 0;
-#endif  // SANITIZER_ANDROID
+#      endif  // SANITIZER_ANDROID
 
   // Top gigabyte is reserved for kernel.
   return gbyte;
-#else
+#    else
   return 0;
-#endif  // SANITIZER_LINUX && !SANITIZER_X32
+#    endif  // SANITIZER_LINUX && !SANITIZER_X32
 }
-#endif  // SANITIZER_WORDSIZE == 32
+#  endif  // SANITIZER_WORDSIZE == 32
 
 uptr GetMaxVirtualAddress() {
-#if SANITIZER_NETBSD && defined(__x86_64__)
+#  if SANITIZER_NETBSD && defined(__x86_64__)
   return 0x7f7ffffff000ULL;  // (0x00007f8000000000 - PAGE_SIZE)
-#elif SANITIZER_WORDSIZE == 64
-# if defined(__powerpc64__) || defined(__aarch64__) || defined(__loongarch__)
+#  elif SANITIZER_WORDSIZE == 64
+#    if defined(__powerpc64__) || defined(__aarch64__) || \
+        defined(__loongarch__) || SANITIZER_RISCV64
   // On PowerPC64 we have two different address space layouts: 44- and 46-bit.
   // We somehow need to figure out which one we are using now and choose
   // one of 0x00000fffffffffffUL and 0x00003fffffffffffUL.
@@ -1118,97 +1152,97 @@ uptr GetMaxVirtualAddress() {
   // This should (does) work for both PowerPC64 Endian modes.
   // Similarly, aarch64 has multiple address space layouts: 39, 42 and 47-bit.
   // loongarch64 also has multiple address space layouts: default is 47-bit.
+  // RISC-V 64 also has multiple address space layouts: 39, 48 and 57-bit.
   return (1ULL << (MostSignificantSetBitIndex(GET_CURRENT_FRAME()) + 1)) - 1;
-#elif SANITIZER_RISCV64
-  return (1ULL << 38) - 1;
-# elif SANITIZER_MIPS64
+#    elif SANITIZER_MIPS64
   return (1ULL << 40) - 1;  // 0x000000ffffffffffUL;
-# elif defined(__s390x__)
+#    elif defined(__s390x__)
   return (1ULL << 53) - 1;  // 0x001fffffffffffffUL;
-#elif defined(__sparc__)
+#    elif defined(__sparc__)
   return ~(uptr)0;
-# else
+#    else
   return (1ULL << 47) - 1;  // 0x00007fffffffffffUL;
-# endif
-#else  // SANITIZER_WORDSIZE == 32
-# if defined(__s390__)
+#    endif
+#  else  // SANITIZER_WORDSIZE == 32
+#    if defined(__s390__)
   return (1ULL << 31) - 1;  // 0x7fffffff;
-# else
+#    else
   return (1ULL << 32) - 1;  // 0xffffffff;
-# endif
-#endif  // SANITIZER_WORDSIZE
+#    endif
+#  endif  // SANITIZER_WORDSIZE
 }
 
 uptr GetMaxUserVirtualAddress() {
   uptr addr = GetMaxVirtualAddress();
-#if SANITIZER_WORDSIZE == 32 && !defined(__s390__)
+#  if SANITIZER_WORDSIZE == 32 && !defined(__s390__)
   if (!common_flags()->full_address_space)
     addr -= GetKernelAreaSize();
   CHECK_LT(reinterpret_cast<uptr>(&addr), addr);
-#endif
+#  endif
   return addr;
 }
 
-#if !SANITIZER_ANDROID
+#  if !SANITIZER_ANDROID || defined(__aarch64__)
 uptr GetPageSize() {
-#if SANITIZER_LINUX && (defined(__x86_64__) || defined(__i386__)) && \
-    defined(EXEC_PAGESIZE)
+#    if SANITIZER_LINUX && (defined(__x86_64__) || defined(__i386__)) && \
+        defined(EXEC_PAGESIZE)
   return EXEC_PAGESIZE;
-#elif SANITIZER_FREEBSD || SANITIZER_NETBSD
-// Use sysctl as sysconf can trigger interceptors internally.
+#    elif SANITIZER_FREEBSD || SANITIZER_NETBSD
+  // Use sysctl as sysconf can trigger interceptors internally.
   int pz = 0;
   uptr pzl = sizeof(pz);
   int mib[2] = {CTL_HW, HW_PAGESIZE};
   int rv = internal_sysctl(mib, 2, &pz, &pzl, nullptr, 0);
   CHECK_EQ(rv, 0);
   return (uptr)pz;
-#elif SANITIZER_USE_GETAUXVAL
+#    elif SANITIZER_USE_GETAUXVAL
   return getauxval(AT_PAGESZ);
-#else
+#    else
   return sysconf(_SC_PAGESIZE);  // EXEC_PAGESIZE may not be trustworthy.
-#endif
+#    endif
 }
-#endif // !SANITIZER_ANDROID
+#  endif
 
-uptr ReadBinaryName(/*out*/char *buf, uptr buf_len) {
-#if SANITIZER_SOLARIS
+uptr ReadBinaryName(/*out*/ char *buf, uptr buf_len) {
+#  if SANITIZER_SOLARIS
   const char *default_module_name = getexecname();
   CHECK_NE(default_module_name, NULL);
   return internal_snprintf(buf, buf_len, "%s", default_module_name);
-#else
-#if SANITIZER_FREEBSD || SANITIZER_NETBSD
-#if SANITIZER_FREEBSD
+#  else
+#    if SANITIZER_FREEBSD || SANITIZER_NETBSD
+#      if SANITIZER_FREEBSD
   const int Mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1};
-#else
+#      else
   const int Mib[4] = {CTL_KERN, KERN_PROC_ARGS, -1, KERN_PROC_PATHNAME};
-#endif
+#      endif
   const char *default_module_name = "kern.proc.pathname";
   uptr Size = buf_len;
   bool IsErr =
       (internal_sysctl(Mib, ARRAY_SIZE(Mib), buf, &Size, NULL, 0) != 0);
   int readlink_error = IsErr ? errno : 0;
   uptr module_name_len = Size;
-#else
+#    else
   const char *default_module_name = "/proc/self/exe";
-  uptr module_name_len = internal_readlink(
-      default_module_name, buf, buf_len);
+  uptr module_name_len = internal_readlink(default_module_name, buf, buf_len);
   int readlink_error;
   bool IsErr = internal_iserror(module_name_len, &readlink_error);
-#endif  // SANITIZER_SOLARIS
+#    endif
   if (IsErr) {
     // We can't read binary name for some reason, assume it's unknown.
-    Report("WARNING: reading executable name failed with errno %d, "
-           "some stack frames may not be symbolized\n", readlink_error);
-    module_name_len = internal_snprintf(buf, buf_len, "%s",
-                                        default_module_name);
+    Report(
+        "WARNING: reading executable name failed with errno %d, "
+        "some stack frames may not be symbolized\n",
+        readlink_error);
+    module_name_len =
+        internal_snprintf(buf, buf_len, "%s", default_module_name);
     CHECK_LT(module_name_len, buf_len);
   }
   return module_name_len;
-#endif
+#  endif
 }
 
 uptr ReadLongProcessName(/*out*/ char *buf, uptr buf_len) {
-#if SANITIZER_LINUX
+#  if SANITIZER_LINUX
   char *tmpbuf;
   uptr tmpsize;
   uptr tmplen;
@@ -1218,7 +1252,7 @@ uptr ReadLongProcessName(/*out*/ char *buf, uptr buf_len) {
     UnmapOrDie(tmpbuf, tmpsize);
     return internal_strlen(buf);
   }
-#endif
+#  endif
   return ReadBinaryName(buf, buf_len);
 }
 
@@ -1228,20 +1262,22 @@ bool LibraryNameIs(const char *full_name, const char *base_name) {
   // Strip path.
   while (*name != '\0') name++;
   while (name > full_name && *name != '/') name--;
-  if (*name == '/') name++;
+  if (*name == '/')
+    name++;
   uptr base_name_length = internal_strlen(base_name);
-  if (internal_strncmp(name, base_name, base_name_length)) return false;
+  if (internal_strncmp(name, base_name, base_name_length))
+    return false;
   return (name[base_name_length] == '-' || name[base_name_length] == '.');
 }
 
-#if !SANITIZER_ANDROID
+#  if !SANITIZER_ANDROID
 // Call cb for each region mapped by map.
 void ForEachMappedRegion(link_map *map, void (*cb)(const void *, uptr)) {
   CHECK_NE(map, nullptr);
-#if !SANITIZER_FREEBSD
+#    if !SANITIZER_FREEBSD
   typedef ElfW(Phdr) Elf_Phdr;
   typedef ElfW(Ehdr) Elf_Ehdr;
-#endif // !SANITIZER_FREEBSD
+#    endif  // !SANITIZER_FREEBSD
   char *base = (char *)map->l_addr;
   Elf_Ehdr *ehdr = (Elf_Ehdr *)base;
   char *phdrs = base + ehdr->e_phoff;
@@ -1273,10 +1309,10 @@ void ForEachMappedRegion(link_map *map, void (*cb)(const void *, uptr)) {
     }
   }
 }
-#endif
+#  endif
 
-#if SANITIZER_LINUX
-#if defined(__x86_64__)
+#  if SANITIZER_LINUX
+#    if defined(__x86_64__)
 // We cannot use glibc's clone wrapper, because it messes with the child
 // task's TLS. It writes the PID and TID of the child task to its thread
 // descriptor, but in our case the child task shares the thread descriptor with
@@ -1295,50 +1331,46 @@ uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
   register void *r8 __asm__("r8") = newtls;
   register int *r10 __asm__("r10") = child_tidptr;
   __asm__ __volatile__(
-                       /* %rax = syscall(%rax = SYSCALL(clone),
-                        *                %rdi = flags,
-                        *                %rsi = child_stack,
-                        *                %rdx = parent_tidptr,
-                        *                %r8  = new_tls,
-                        *                %r10 = child_tidptr)
-                        */
-                       "syscall\n"
-
-                       /* if (%rax != 0)
-                        *   return;
-                        */
-                       "testq  %%rax,%%rax\n"
-                       "jnz    1f\n"
-
-                       /* In the child. Terminate unwind chain. */
-                       // XXX: We should also terminate the CFI unwind chain
-                       // here. Unfortunately clang 3.2 doesn't support the
-                       // necessary CFI directives, so we skip that part.
-                       "xorq   %%rbp,%%rbp\n"
-
-                       /* Call "fn(arg)". */
-                       "popq   %%rax\n"
-                       "popq   %%rdi\n"
-                       "call   *%%rax\n"
-
-                       /* Call _exit(%rax). */
-                       "movq   %%rax,%%rdi\n"
-                       "movq   %2,%%rax\n"
-                       "syscall\n"
-
-                       /* Return to parent. */
-                     "1:\n"
-                       : "=a" (res)
-                       : "a"(SYSCALL(clone)), "i"(SYSCALL(exit)),
-                         "S"(child_stack),
-                         "D"(flags),
-                         "d"(parent_tidptr),
-                         "r"(r8),
-                         "r"(r10)
-                       : "memory", "r11", "rcx");
+      /* %rax = syscall(%rax = SYSCALL(clone),
+       *                %rdi = flags,
+       *                %rsi = child_stack,
+       *                %rdx = parent_tidptr,
+       *                %r8  = new_tls,
+       *                %r10 = child_tidptr)
+       */
+      "syscall\n"
+
+      /* if (%rax != 0)
+       *   return;
+       */
+      "testq  %%rax,%%rax\n"
+      "jnz    1f\n"
+
+      /* In the child. Terminate unwind chain. */
+      // XXX: We should also terminate the CFI unwind chain
+      // here. Unfortunately clang 3.2 doesn't support the
+      // necessary CFI directives, so we skip that part.
+      "xorq   %%rbp,%%rbp\n"
+
+      /* Call "fn(arg)". */
+      "popq   %%rax\n"
+      "popq   %%rdi\n"
+      "call   *%%rax\n"
+
+      /* Call _exit(%rax). */
+      "movq   %%rax,%%rdi\n"
+      "movq   %2,%%rax\n"
+      "syscall\n"
+
+      /* Return to parent. */
+      "1:\n"
+      : "=a"(res)
+      : "a"(SYSCALL(clone)), "i"(SYSCALL(exit)), "S"(child_stack), "D"(flags),
+        "d"(parent_tidptr), "r"(r8), "r"(r10)
+      : "memory", "r11", "rcx");
   return res;
 }
-#elif defined(__mips__)
+#    elif defined(__mips__)
 uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
                     int *parent_tidptr, void *newtls, int *child_tidptr) {
   long long res;
@@ -1353,68 +1385,63 @@ uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
   // We don't have proper CFI directives here because it requires alot of code
   // for very marginal benefits.
   __asm__ __volatile__(
-                       /* $v0 = syscall($v0 = __NR_clone,
-                        * $a0 = flags,
-                        * $a1 = child_stack,
-                        * $a2 = parent_tidptr,
-                        * $a3 = new_tls,
-                        * $a4 = child_tidptr)
-                        */
-                       ".cprestore 16;\n"
-                       "move $4,%1;\n"
-                       "move $5,%2;\n"
-                       "move $6,%3;\n"
-                       "move $7,%4;\n"
-                       /* Store the fifth argument on stack
-                        * if we are using 32-bit abi.
-                        */
-#if SANITIZER_WORDSIZE == 32
-                       "lw %5,16($29);\n"
-#else
-                       "move $8,%5;\n"
-#endif
-                       "li $2,%6;\n"
-                       "syscall;\n"
-
-                       /* if ($v0 != 0)
-                        * return;
-                        */
-                       "bnez $2,1f;\n"
-
-                       /* Call "fn(arg)". */
-#if SANITIZER_WORDSIZE == 32
-#ifdef __BIG_ENDIAN__
-                       "lw $25,4($29);\n"
-                       "lw $4,12($29);\n"
-#else
-                       "lw $25,0($29);\n"
-                       "lw $4,8($29);\n"
-#endif
-#else
-                       "ld $25,0($29);\n"
-                       "ld $4,8($29);\n"
-#endif
-                       "jal $25;\n"
-
-                       /* Call _exit($v0). */
-                       "move $4,$2;\n"
-                       "li $2,%7;\n"
-                       "syscall;\n"
-
-                       /* Return to parent. */
-                     "1:\n"
-                       : "=r" (res)
-                       : "r"(flags),
-                         "r"(child_stack),
-                         "r"(parent_tidptr),
-                         "r"(a3),
-                         "r"(a4),
-                         "i"(__NR_clone),
-                         "i"(__NR_exit)
-                       : "memory", "$29" );
+      /* $v0 = syscall($v0 = __NR_clone,
+       * $a0 = flags,
+       * $a1 = child_stack,
+       * $a2 = parent_tidptr,
+       * $a3 = new_tls,
+       * $a4 = child_tidptr)
+       */
+      ".cprestore 16;\n"
+      "move $4,%1;\n"
+      "move $5,%2;\n"
+      "move $6,%3;\n"
+      "move $7,%4;\n"
+  /* Store the fifth argument on stack
+   * if we are using 32-bit abi.
+   */
+#      if SANITIZER_WORDSIZE == 32
+      "lw %5,16($29);\n"
+#      else
+      "move $8,%5;\n"
+#      endif
+      "li $2,%6;\n"
+      "syscall;\n"
+
+      /* if ($v0 != 0)
+       * return;
+       */
+      "bnez $2,1f;\n"
+
+  /* Call "fn(arg)". */
+#      if SANITIZER_WORDSIZE == 32
+#        ifdef __BIG_ENDIAN__
+      "lw $25,4($29);\n"
+      "lw $4,12($29);\n"
+#        else
+      "lw $25,0($29);\n"
+      "lw $4,8($29);\n"
+#        endif
+#      else
+      "ld $25,0($29);\n"
+      "ld $4,8($29);\n"
+#      endif
+      "jal $25;\n"
+
+      /* Call _exit($v0). */
+      "move $4,$2;\n"
+      "li $2,%7;\n"
+      "syscall;\n"
+
+      /* Return to parent. */
+      "1:\n"
+      : "=r"(res)
+      : "r"(flags), "r"(child_stack), "r"(parent_tidptr), "r"(a3), "r"(a4),
+        "i"(__NR_clone), "i"(__NR_exit)
+      : "memory", "$29");
   return res;
 }
-#elif SANITIZER_RISCV64
+#    elif SANITIZER_RISCV64
 uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
                     int *parent_tidptr, void *newtls, int *child_tidptr) {
   if (!fn || !child_stack)
@@ -1455,7 +1482,7 @@ uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
       : "memory");
   return res;
 }
-#elif defined(__aarch64__)
+#    elif defined(__aarch64__)
 uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
                     int *parent_tidptr, void *newtls, int *child_tidptr) {
   register long long res __asm__("x0");
@@ -1466,47 +1493,45 @@ uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
   ((unsigned long long *)child_stack)[0] = (uptr)fn;
   ((unsigned long long *)child_stack)[1] = (uptr)arg;
 
-  register int (*__fn)(void *)  __asm__("x0") = fn;
+  register int (*__fn)(void *) __asm__("x0") = fn;
   register void *__stack __asm__("x1") = child_stack;
-  register int   __flags __asm__("x2") = flags;
-  register void *__arg   __asm__("x3") = arg;
-  register int  *__ptid  __asm__("x4") = parent_tidptr;
-  register void *__tls   __asm__("x5") = newtls;
-  register int  *__ctid  __asm__("x6") = child_tidptr;
+  register int __flags __asm__("x2") = flags;
+  register void *__arg __asm__("x3") = arg;
+  register int *__ptid __asm__("x4") = parent_tidptr;
+  register void *__tls __asm__("x5") = newtls;
+  register int *__ctid __asm__("x6") = child_tidptr;
 
   __asm__ __volatile__(
-                       "mov x0,x2\n" /* flags  */
-                       "mov x2,x4\n" /* ptid  */
-                       "mov x3,x5\n" /* tls  */
-                       "mov x4,x6\n" /* ctid  */
-                       "mov x8,%9\n" /* clone  */
-
-                       "svc 0x0\n"
-
-                       /* if (%r0 != 0)
-                        *   return %r0;
-                        */
-                       "cmp x0, #0\n"
-                       "bne 1f\n"
-
-                       /* In the child, now. Call "fn(arg)". */
-                       "ldp x1, x0, [sp], #16\n"
-                       "blr x1\n"
-
-                       /* Call _exit(%r0).  */
-                       "mov x8, %10\n"
-                       "svc 0x0\n"
-                     "1:\n"
-
-                       : "=r" (res)
-                       : "i"(-EINVAL),
-                         "r"(__fn), "r"(__stack), "r"(__flags), "r"(__arg),
-                         "r"(__ptid), "r"(__tls), "r"(__ctid),
-                         "i"(__NR_clone), "i"(__NR_exit)
-                       : "x30", "memory");
+      "mov x0,x2\n" /* flags  */
+      "mov x2,x4\n" /* ptid  */
+      "mov x3,x5\n" /* tls  */
+      "mov x4,x6\n" /* ctid  */
+      "mov x8,%9\n" /* clone  */
+
+      "svc 0x0\n"
+
+      /* if (%r0 != 0)
+       *   return %r0;
+       */
+      "cmp x0, #0\n"
+      "bne 1f\n"
+
+      /* In the child, now. Call "fn(arg)". */
+      "ldp x1, x0, [sp], #16\n"
+      "blr x1\n"
+
+      /* Call _exit(%r0).  */
+      "mov x8, %10\n"
+      "svc 0x0\n"
+      "1:\n"
+
+      : "=r"(res)
+      : "i"(-EINVAL), "r"(__fn), "r"(__stack), "r"(__flags), "r"(__arg),
+        "r"(__ptid), "r"(__tls), "r"(__ctid), "i"(__NR_clone), "i"(__NR_exit)
+      : "x30", "memory");
   return res;
 }
-#elif SANITIZER_LOONGARCH64
+#    elif SANITIZER_LOONGARCH64
 uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
                     int *parent_tidptr, void *newtls, int *child_tidptr) {
   if (!fn || !child_stack)
@@ -1544,119 +1569,110 @@ uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
       : "=r"(res)
       : "0"(__flags), "r"(__stack), "r"(__ptid), "r"(__ctid), "r"(__tls),
         "r"(__fn), "r"(__arg), "r"(nr_clone), "i"(__NR_exit)
-      : "memory", "$t0", "$t1", "$t2", "$t3", "$t4", "$t5", "$t6", "$t7", "$t8");
+      : "memory", "$t0", "$t1", "$t2", "$t3", "$t4", "$t5", "$t6", "$t7",
+        "$t8");
   return res;
 }
-#elif defined(__powerpc64__)
+#    elif defined(__powerpc64__)
 uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
-                   int *parent_tidptr, void *newtls, int *child_tidptr) {
+                    int *parent_tidptr, void *newtls, int *child_tidptr) {
   long long res;
 // Stack frame structure.
-#if SANITIZER_PPC64V1
-//   Back chain == 0        (SP + 112)
-// Frame (112 bytes):
-//   Parameter save area    (SP + 48), 8 doublewords
-//   TOC save area          (SP + 40)
-//   Link editor doubleword (SP + 32)
-//   Compiler doubleword    (SP + 24)
-//   LR save area           (SP + 16)
-//   CR save area           (SP + 8)
-//   Back chain             (SP + 0)
-# define FRAME_SIZE 112
-# define FRAME_TOC_SAVE_OFFSET 40
-#elif SANITIZER_PPC64V2
-//   Back chain == 0        (SP + 32)
-// Frame (32 bytes):
-//   TOC save area          (SP + 24)
-//   LR save area           (SP + 16)
-//   CR save area           (SP + 8)
-//   Back chain             (SP + 0)
-# define FRAME_SIZE 32
-# define FRAME_TOC_SAVE_OFFSET 24
-#else
-# error "Unsupported PPC64 ABI"
-#endif
+#      if SANITIZER_PPC64V1
+  //   Back chain == 0        (SP + 112)
+  // Frame (112 bytes):
+  //   Parameter save area    (SP + 48), 8 doublewords
+  //   TOC save area          (SP + 40)
+  //   Link editor doubleword (SP + 32)
+  //   Compiler doubleword    (SP + 24)
+  //   LR save area           (SP + 16)
+  //   CR save area           (SP + 8)
+  //   Back chain             (SP + 0)
+#        define FRAME_SIZE 112
+#        define FRAME_TOC_SAVE_OFFSET 40
+#      elif SANITIZER_PPC64V2
+  //   Back chain == 0        (SP + 32)
+  // Frame (32 bytes):
+  //   TOC save area          (SP + 24)
+  //   LR save area           (SP + 16)
+  //   CR save area           (SP + 8)
+  //   Back chain             (SP + 0)
+#        define FRAME_SIZE 32
+#        define FRAME_TOC_SAVE_OFFSET 24
+#      else
+#        error "Unsupported PPC64 ABI"
+#      endif
   if (!fn || !child_stack)
     return -EINVAL;
   CHECK_EQ(0, (uptr)child_stack % 16);
 
   register int (*__fn)(void *) __asm__("r3") = fn;
-  register void *__cstack      __asm__("r4") = child_stack;
-  register int __flags         __asm__("r5") = flags;
-  register void *__arg         __asm__("r6") = arg;
-  register int *__ptidptr      __asm__("r7") = parent_tidptr;
-  register void *__newtls      __asm__("r8") = newtls;
-  register int *__ctidptr      __asm__("r9") = child_tidptr;
-
- __asm__ __volatile__(
-           /* fn and arg are saved across the syscall */
-           "mr 28, %5\n\t"
-           "mr 27, %8\n\t"
-
-           /* syscall
-             r0 == __NR_clone
-             r3 == flags
-             r4 == child_stack
-             r5 == parent_tidptr
-             r6 == newtls
-             r7 == child_tidptr */
-           "mr 3, %7\n\t"
-           "mr 5, %9\n\t"
-           "mr 6, %10\n\t"
-           "mr 7, %11\n\t"
-           "li 0, %3\n\t"
-           "sc\n\t"
-
-           /* Test if syscall was successful */
-           "cmpdi  cr1, 3, 0\n\t"
-           "crandc cr1*4+eq, cr1*4+eq, cr0*4+so\n\t"
-           "bne-   cr1, 1f\n\t"
-
-           /* Set up stack frame */
-           "li    29, 0\n\t"
-           "stdu  29, -8(1)\n\t"
-           "stdu  1, -%12(1)\n\t"
-           /* Do the function call */
-           "std   2, %13(1)\n\t"
-#if SANITIZER_PPC64V1
-           "ld    0, 0(28)\n\t"
-           "ld    2, 8(28)\n\t"
-           "mtctr 0\n\t"
-#elif SANITIZER_PPC64V2
-           "mr    12, 28\n\t"
-           "mtctr 12\n\t"
-#else
-# error "Unsupported PPC64 ABI"
-#endif
-           "mr    3, 27\n\t"
-           "bctrl\n\t"
-           "ld    2, %13(1)\n\t"
-
-           /* Call _exit(r3) */
-           "li 0, %4\n\t"
-           "sc\n\t"
-
-           /* Return to parent */
-           "1:\n\t"
-           "mr %0, 3\n\t"
-             : "=r" (res)
-             : "0" (-1),
-               "i" (EINVAL),
-               "i" (__NR_clone),
-               "i" (__NR_exit),
-               "r" (__fn),
-               "r" (__cstack),
-               "r" (__flags),
-               "r" (__arg),
-               "r" (__ptidptr),
-               "r" (__newtls),
-               "r" (__ctidptr),
-               "i" (FRAME_SIZE),
-               "i" (FRAME_TOC_SAVE_OFFSET)
-             : "cr0", "cr1", "memory", "ctr", "r0", "r27", "r28", "r29");
+  register void *__cstack __asm__("r4") = child_stack;
+  register int __flags __asm__("r5") = flags;
+  register void *__arg __asm__("r6") = arg;
+  register int *__ptidptr __asm__("r7") = parent_tidptr;
+  register void *__newtls __asm__("r8") = newtls;
+  register int *__ctidptr __asm__("r9") = child_tidptr;
+
+  __asm__ __volatile__(
+      /* fn and arg are saved across the syscall */
+      "mr 28, %5\n\t"
+      "mr 27, %8\n\t"
+
+      /* syscall
+        r0 == __NR_clone
+        r3 == flags
+        r4 == child_stack
+        r5 == parent_tidptr
+        r6 == newtls
+        r7 == child_tidptr */
+      "mr 3, %7\n\t"
+      "mr 5, %9\n\t"
+      "mr 6, %10\n\t"
+      "mr 7, %11\n\t"
+      "li 0, %3\n\t"
+      "sc\n\t"
+
+      /* Test if syscall was successful */
+      "cmpdi  cr1, 3, 0\n\t"
+      "crandc cr1*4+eq, cr1*4+eq, cr0*4+so\n\t"
+      "bne-   cr1, 1f\n\t"
+
+      /* Set up stack frame */
+      "li    29, 0\n\t"
+      "stdu  29, -8(1)\n\t"
+      "stdu  1, -%12(1)\n\t"
+      /* Do the function call */
+      "std   2, %13(1)\n\t"
+#      if SANITIZER_PPC64V1
+      "ld    0, 0(28)\n\t"
+      "ld    2, 8(28)\n\t"
+      "mtctr 0\n\t"
+#      elif SANITIZER_PPC64V2
+      "mr    12, 28\n\t"
+      "mtctr 12\n\t"
+#      else
+#        error "Unsupported PPC64 ABI"
+#      endif
+      "mr    3, 27\n\t"
+      "bctrl\n\t"
+      "ld    2, %13(1)\n\t"
+
+      /* Call _exit(r3) */
+      "li 0, %4\n\t"
+      "sc\n\t"
+
+      /* Return to parent */
+      "1:\n\t"
+      "mr %0, 3\n\t"
+      : "=r"(res)
+      : "0"(-1), "i"(EINVAL), "i"(__NR_clone), "i"(__NR_exit), "r"(__fn),
+        "r"(__cstack), "r"(__flags), "r"(__arg), "r"(__ptidptr), "r"(__newtls),
+        "r"(__ctidptr), "i"(FRAME_SIZE), "i"(FRAME_TOC_SAVE_OFFSET)
+      : "cr0", "cr1", "memory", "ctr", "r0", "r27", "r28", "r29");
   return res;
 }
-#elif defined(__i386__)
+#    elif defined(__i386__)
 uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
                     int *parent_tidptr, void *newtls, int *child_tidptr) {
   int res;
@@ -1669,59 +1685,56 @@ uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
   ((unsigned int *)child_stack)[2] = (uptr)fn;
   ((unsigned int *)child_stack)[3] = (uptr)arg;
   __asm__ __volatile__(
-                       /* %eax = syscall(%eax = SYSCALL(clone),
-                        *                %ebx = flags,
-                        *                %ecx = child_stack,
-                        *                %edx = parent_tidptr,
-                        *                %esi  = new_tls,
-                        *                %edi = child_tidptr)
-                        */
-
-                        /* Obtain flags */
-                        "movl    (%%ecx), %%ebx\n"
-                        /* Do the system call */
-                        "pushl   %%ebx\n"
-                        "pushl   %%esi\n"
-                        "pushl   %%edi\n"
-                        /* Remember the flag value.  */
-                        "movl    %%ebx, (%%ecx)\n"
-                        "int     $0x80\n"
-                        "popl    %%edi\n"
-                        "popl    %%esi\n"
-                        "popl    %%ebx\n"
-
-                        /* if (%eax != 0)
-                         *   return;
-                         */
-
-                        "test    %%eax,%%eax\n"
-                        "jnz    1f\n"
-
-                        /* terminate the stack frame */
-                        "xorl   %%ebp,%%ebp\n"
-                        /* Call FN. */
-                        "call    *%%ebx\n"
-#ifdef PIC
-                        "call    here\n"
-                        "here:\n"
-                        "popl    %%ebx\n"
-                        "addl    $_GLOBAL_OFFSET_TABLE_+[.-here], %%ebx\n"
-#endif
-                        /* Call exit */
-                        "movl    %%eax, %%ebx\n"
-                        "movl    %2, %%eax\n"
-                        "int     $0x80\n"
-                        "1:\n"
-                       : "=a" (res)
-                       : "a"(SYSCALL(clone)), "i"(SYSCALL(exit)),
-                         "c"(child_stack),
-                         "d"(parent_tidptr),
-                         "S"(newtls),
-                         "D"(child_tidptr)
-                       : "memory");
+      /* %eax = syscall(%eax = SYSCALL(clone),
+       *                %ebx = flags,
+       *                %ecx = child_stack,
+       *                %edx = parent_tidptr,
+       *                %esi  = new_tls,
+       *                %edi = child_tidptr)
+       */
+
+      /* Obtain flags */
+      "movl    (%%ecx), %%ebx\n"
+      /* Do the system call */
+      "pushl   %%ebx\n"
+      "pushl   %%esi\n"
+      "pushl   %%edi\n"
+      /* Remember the flag value.  */
+      "movl    %%ebx, (%%ecx)\n"
+      "int     $0x80\n"
+      "popl    %%edi\n"
+      "popl    %%esi\n"
+      "popl    %%ebx\n"
+
+      /* if (%eax != 0)
+       *   return;
+       */
+
+      "test    %%eax,%%eax\n"
+      "jnz    1f\n"
+
+      /* terminate the stack frame */
+      "xorl   %%ebp,%%ebp\n"
+      /* Call FN. */
+      "call    *%%ebx\n"
+#      ifdef PIC
+      "call    here\n"
+      "here:\n"
+      "popl    %%ebx\n"
+      "addl    $_GLOBAL_OFFSET_TABLE_+[.-here], %%ebx\n"
+#      endif
+      /* Call exit */
+      "movl    %%eax, %%ebx\n"
+      "movl    %2, %%eax\n"
+      "int     $0x80\n"
+      "1:\n"
+      : "=a"(res)
+      : "a"(SYSCALL(clone)), "i"(SYSCALL(exit)), "c"(child_stack),
+        "d"(parent_tidptr), "S"(newtls), "D"(child_tidptr)
+      : "memory");
   return res;
 }
-#elif defined(__arm__)
+#    elif defined(__arm__)
 uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
                     int *parent_tidptr, void *newtls, int *child_tidptr) {
   unsigned int res;
@@ -1737,70 +1750,68 @@ uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
   register int *r4 __asm__("r4") = child_tidptr;
   register int r7 __asm__("r7") = __NR_clone;
 
-#if __ARM_ARCH > 4 || defined (__ARM_ARCH_4T__)
-# define ARCH_HAS_BX
-#endif
-#if __ARM_ARCH > 4
-# define ARCH_HAS_BLX
-#endif
+#      if __ARM_ARCH > 4 || defined(__ARM_ARCH_4T__)
+#        define ARCH_HAS_BX
+#      endif
+#      if __ARM_ARCH > 4
+#        define ARCH_HAS_BLX
+#      endif
 
-#ifdef ARCH_HAS_BX
-# ifdef ARCH_HAS_BLX
-#  define BLX(R) "blx "  #R "\n"
-# else
-#  define BLX(R) "mov lr, pc; bx " #R "\n"
-# endif
-#else
-# define BLX(R)  "mov lr, pc; mov pc," #R "\n"
-#endif
+#      ifdef ARCH_HAS_BX
+#        ifdef ARCH_HAS_BLX
+#          define BLX(R) "blx " #R "\n"
+#        else
+#          define BLX(R) "mov lr, pc; bx " #R "\n"
+#        endif
+#      else
+#        define BLX(R) "mov lr, pc; mov pc," #R "\n"
+#      endif
 
   __asm__ __volatile__(
-                       /* %r0 = syscall(%r7 = SYSCALL(clone),
-                        *               %r0 = flags,
-                        *               %r1 = child_stack,
-                        *               %r2 = parent_tidptr,
-                        *               %r3  = new_tls,
-                        *               %r4 = child_tidptr)
-                        */
-
-                       /* Do the system call */
-                       "swi 0x0\n"
-
-                       /* if (%r0 != 0)
-                        *   return %r0;
-                        */
-                       "cmp r0, #0\n"
-                       "bne 1f\n"
-
-                       /* In the child, now. Call "fn(arg)". */
-                       "ldr r0, [sp, #4]\n"
-                       "ldr ip, [sp], #8\n"
-                       BLX(ip)
-                       /* Call _exit(%r0). */
-                       "mov r7, %7\n"
-                       "swi 0x0\n"
-                       "1:\n"
-                       "mov %0, r0\n"
-                       : "=r"(res)
-                       : "r"(r0), "r"(r1), "r"(r2), "r"(r3), "r"(r4), "r"(r7),
-                         "i"(__NR_exit)
-                       : "memory");
+      /* %r0 = syscall(%r7 = SYSCALL(clone),
+       *               %r0 = flags,
+       *               %r1 = child_stack,
+       *               %r2 = parent_tidptr,
+       *               %r3  = new_tls,
+       *               %r4 = child_tidptr)
+       */
+
+      /* Do the system call */
+      "swi 0x0\n"
+
+      /* if (%r0 != 0)
+       *   return %r0;
+       */
+      "cmp r0, #0\n"
+      "bne 1f\n"
+
+      /* In the child, now. Call "fn(arg)". */
+      "ldr r0, [sp, #4]\n"
+      "ldr ip, [sp], #8\n" BLX(ip)
+      /* Call _exit(%r0). */
+      "mov r7, %7\n"
+      "swi 0x0\n"
+      "1:\n"
+      "mov %0, r0\n"
+      : "=r"(res)
+      : "r"(r0), "r"(r1), "r"(r2), "r"(r3), "r"(r4), "r"(r7), "i"(__NR_exit)
+      : "memory");
   return res;
 }
-#endif
-#endif  // SANITIZER_LINUX
+#    endif
+#  endif  // SANITIZER_LINUX
 
-#if SANITIZER_LINUX
+#  if SANITIZER_LINUX
 int internal_uname(struct utsname *buf) {
   return internal_syscall(SYSCALL(uname), buf);
 }
-#endif
+#  endif
 
-#if SANITIZER_ANDROID
-#if __ANDROID_API__ < 21
+#  if SANITIZER_ANDROID
+#    if __ANDROID_API__ < 21
 extern "C" __attribute__((weak)) int dl_iterate_phdr(
     int (*)(struct dl_phdr_info *, size_t, void *), void *);
-#endif
+#    endif
 
 static int dl_iterate_phdr_test_cb(struct dl_phdr_info *info, size_t size,
                                    void *data) {
@@ -1817,40 +1828,41 @@ static int dl_iterate_phdr_test_cb(struct dl_phdr_info *info, size_t size,
 static atomic_uint32_t android_api_level;
 
 static AndroidApiLevel AndroidDetectApiLevelStatic() {
-#if __ANDROID_API__ <= 19
+#    if __ANDROID_API__ <= 19
   return ANDROID_KITKAT;
-#elif __ANDROID_API__ <= 22
+#    elif __ANDROID_API__ <= 22
   return ANDROID_LOLLIPOP_MR1;
-#else
+#    else
   return ANDROID_POST_LOLLIPOP;
-#endif
+#    endif
 }
 
 static AndroidApiLevel AndroidDetectApiLevel() {
   if (!&dl_iterate_phdr)
-    return ANDROID_KITKAT; // K or lower
+    return ANDROID_KITKAT;  // K or lower
   bool base_name_seen = false;
   dl_iterate_phdr(dl_iterate_phdr_test_cb, &base_name_seen);
   if (base_name_seen)
-    return ANDROID_LOLLIPOP_MR1; // L MR1
+    return ANDROID_LOLLIPOP_MR1;  // L MR1
   return ANDROID_POST_LOLLIPOP;   // post-L
   // Plain L (API level 21) is completely broken wrt ASan and not very
   // interesting to detect.
 }
 
-extern "C" __attribute__((weak)) void* _DYNAMIC;
+extern "C" __attribute__((weak)) void *_DYNAMIC;
 
 AndroidApiLevel AndroidGetApiLevel() {
   AndroidApiLevel level =
       (AndroidApiLevel)atomic_load(&android_api_level, memory_order_relaxed);
-  if (level) return level;
+  if (level)
+    return level;
   level = &_DYNAMIC == nullptr ? AndroidDetectApiLevelStatic()
                                : AndroidDetectApiLevel();
   atomic_store(&android_api_level, level, memory_order_relaxed);
   return level;
 }
 
-#endif
+#  endif
 
 static HandleSignalMode GetHandleSignalModeImpl(int signum) {
   switch (signum) {
@@ -1877,28 +1889,28 @@ HandleSignalMode GetHandleSignalMode(int signum) {
   return result;
 }
 
-#if !SANITIZER_GO
+#  if !SANITIZER_GO
 void *internal_start_thread(void *(*func)(void *arg), void *arg) {
-  if (&real_pthread_create == 0)
+  if (&internal_pthread_create == 0)
     return nullptr;
   // Start the thread with signals blocked, otherwise it can steal user signals.
   ScopedBlockSignals block(nullptr);
   void *th;
-  real_pthread_create(&th, nullptr, func, arg);
+  internal_pthread_create(&th, nullptr, func, arg);
   return th;
 }
 
 void internal_join_thread(void *th) {
-  if (&real_pthread_join)
-    real_pthread_join(th, nullptr);
+  if (&internal_pthread_join)
+    internal_pthread_join(th, nullptr);
 }
-#else
+#  else
 void *internal_start_thread(void *(*func)(void *), void *arg) { return 0; }
 
 void internal_join_thread(void *th) {}
-#endif
+#  endif
 
-#if SANITIZER_LINUX && defined(__aarch64__)
+#  if SANITIZER_LINUX && defined(__aarch64__)
 // Android headers in the older NDK releases miss this definition.
 struct __sanitizer_esr_context {
   struct _aarch64_ctx head;
@@ -1910,7 +1922,8 @@ static bool Aarch64GetESR(ucontext_t *ucontext, u64 *esr) {
   u8 *aux = reinterpret_cast<u8 *>(ucontext->uc_mcontext.__reserved);
   while (true) {
     _aarch64_ctx *ctx = (_aarch64_ctx *)aux;
-    if (ctx->size == 0) break;
+    if (ctx->size == 0)
+      break;
     if (ctx->magic == kEsrMagic) {
       *esr = ((__sanitizer_esr_context *)ctx)->esr;
       return true;
@@ -1919,31 +1932,29 @@ static bool Aarch64GetESR(ucontext_t *ucontext, u64 *esr) {
   }
   return false;
 }
-#elif SANITIZER_FREEBSD && defined(__aarch64__)
+#  elif SANITIZER_FREEBSD && defined(__aarch64__)
 // FreeBSD doesn't provide ESR in the ucontext.
-static bool Aarch64GetESR(ucontext_t *ucontext, u64 *esr) {
-  return false;
-}
-#endif
+static bool Aarch64GetESR(ucontext_t *ucontext, u64 *esr) { return false; }
+#  endif
 
 using Context = ucontext_t;
 
 SignalContext::WriteFlag SignalContext::GetWriteFlag() const {
   Context *ucontext = (Context *)context;
-#if defined(__x86_64__) || defined(__i386__)
+#  if defined(__x86_64__) || defined(__i386__)
   static const uptr PF_WRITE = 1U << 1;
-#if SANITIZER_FREEBSD
+#    if SANITIZER_FREEBSD
   uptr err = ucontext->uc_mcontext.mc_err;
-#elif SANITIZER_NETBSD
+#    elif SANITIZER_NETBSD
   uptr err = ucontext->uc_mcontext.__gregs[_REG_ERR];
-#elif SANITIZER_SOLARIS && defined(__i386__)
+#    elif SANITIZER_SOLARIS && defined(__i386__)
   const int Err = 13;
   uptr err = ucontext->uc_mcontext.gregs[Err];
-#else
+#    else
   uptr err = ucontext->uc_mcontext.gregs[REG_ERR];
-#endif // SANITIZER_FREEBSD
+#    endif  // SANITIZER_FREEBSD
   return err & PF_WRITE ? Write : Read;
-#elif defined(__mips__)
+#  elif defined(__mips__)
   uint32_t *exception_source;
   uint32_t faulty_instruction;
   uint32_t op_code;
@@ -1959,12 +1970,12 @@ SignalContext::WriteFlag SignalContext::GetWriteFlag() const {
     case 0x29:  // sh
     case 0x2b:  // sw
     case 0x3f:  // sd
-#if __mips_isa_rev < 6
+#    if __mips_isa_rev < 6
     case 0x2c:  // sdl
     case 0x2d:  // sdr
     case 0x2a:  // swl
     case 0x2e:  // swr
-#endif
+#    endif
       return SignalContext::Write;
 
     case 0x20:  // lb
@@ -1974,14 +1985,14 @@ SignalContext::WriteFlag SignalContext::GetWriteFlag() const {
     case 0x23:  // lw
     case 0x27:  // lwu
     case 0x37:  // ld
-#if __mips_isa_rev < 6
+#    if __mips_isa_rev < 6
     case 0x1a:  // ldl
     case 0x1b:  // ldr
     case 0x22:  // lwl
     case 0x26:  // lwr
-#endif
+#    endif
       return SignalContext::Read;
-#if __mips_isa_rev == 6
+#    if __mips_isa_rev == 6
     case 0x3b:  // pcrel
       op_code = (faulty_instruction >> 19) & 0x3;
       switch (op_code) {
@@ -1989,50 +2000,51 @@ SignalContext::WriteFlag SignalContext::GetWriteFlag() const {
         case 0x2:  // lwupc
           return SignalContext::Read;
       }
-#endif
+#    endif
   }
   return SignalContext::Unknown;
-#elif defined(__arm__)
+#  elif defined(__arm__)
   static const uptr FSR_WRITE = 1U << 11;
   uptr fsr = ucontext->uc_mcontext.error_code;
   return fsr & FSR_WRITE ? Write : Read;
-#elif defined(__aarch64__)
+#  elif defined(__aarch64__)
   static const u64 ESR_ELx_WNR = 1U << 6;
   u64 esr;
-  if (!Aarch64GetESR(ucontext, &esr)) return Unknown;
+  if (!Aarch64GetESR(ucontext, &esr))
+    return Unknown;
   return esr & ESR_ELx_WNR ? Write : Read;
-#elif defined(__loongarch__)
+#  elif defined(__loongarch__)
   u32 flags = ucontext->uc_mcontext.__flags;
   if (flags & SC_ADDRERR_RD)
     return SignalContext::Read;
   if (flags & SC_ADDRERR_WR)
     return SignalContext::Write;
   return SignalContext::Unknown;
-#elif defined(__sparc__)
+#  elif defined(__sparc__)
   // Decode the instruction to determine the access type.
   // From OpenSolaris $SRC/uts/sun4/os/trap.c (get_accesstype).
-#if SANITIZER_SOLARIS
+#    if SANITIZER_SOLARIS
   uptr pc = ucontext->uc_mcontext.gregs[REG_PC];
-#else
+#    else
   // Historical BSDism here.
   struct sigcontext *scontext = (struct sigcontext *)context;
-#if defined(__arch64__)
+#      if defined(__arch64__)
   uptr pc = scontext->sigc_regs.tpc;
-#else
+#      else
   uptr pc = scontext->si_regs.pc;
-#endif
-#endif
+#      endif
+#    endif
   u32 instr = *(u32 *)pc;
-  return (instr >> 21) & 1 ? Write: Read;
-#elif defined(__riscv)
-#if SANITIZER_FREEBSD
+  return (instr >> 21) & 1 ? Write : Read;
+#  elif defined(__riscv)
+#    if SANITIZER_FREEBSD
   unsigned long pc = ucontext->uc_mcontext.mc_gpregs.gp_sepc;
-#else
+#    else
   unsigned long pc = ucontext->uc_mcontext.__gregs[REG_PC];
-#endif
+#    endif
   unsigned faulty_instruction = *(uint16_t *)pc;
 
-#if defined(__riscv_compressed)
+#    if defined(__riscv_compressed)
   if ((faulty_instruction & 0x3) != 0x3) {  // it's a compressed instruction
     // set op_bits to the instruction bits [1, 0, 15, 14, 13]
     unsigned op_bits =
@@ -2040,38 +2052,38 @@ SignalContext::WriteFlag SignalContext::GetWriteFlag() const {
     unsigned rd = faulty_instruction & 0xF80;  // bits 7-11, inclusive
     switch (op_bits) {
       case 0b10'010:  // c.lwsp (rd != x0)
-#if __riscv_xlen == 64
+#      if __riscv_xlen == 64
       case 0b10'011:  // c.ldsp (rd != x0)
-#endif
+#      endif
         return rd ? SignalContext::Read : SignalContext::Unknown;
       case 0b00'010:  // c.lw
-#if __riscv_flen >= 32 && __riscv_xlen == 32
+#      if __riscv_flen >= 32 && __riscv_xlen == 32
       case 0b10'011:  // c.flwsp
-#endif
-#if __riscv_flen >= 32 || __riscv_xlen == 64
+#      endif
+#      if __riscv_flen >= 32 || __riscv_xlen == 64
       case 0b00'011:  // c.flw / c.ld
-#endif
-#if __riscv_flen == 64
+#      endif
+#      if __riscv_flen == 64
       case 0b00'001:  // c.fld
       case 0b10'001:  // c.fldsp
-#endif
+#      endif
         return SignalContext::Read;
       case 0b00'110:  // c.sw
       case 0b10'110:  // c.swsp
-#if __riscv_flen >= 32 || __riscv_xlen == 64
+#      if __riscv_flen >= 32 || __riscv_xlen == 64
       case 0b00'111:  // c.fsw / c.sd
       case 0b10'111:  // c.fswsp / c.sdsp
-#endif
-#if __riscv_flen == 64
+#      endif
+#      if __riscv_flen == 64
       case 0b00'101:  // c.fsd
       case 0b10'101:  // c.fsdsp
-#endif
+#      endif
         return SignalContext::Write;
       default:
         return SignalContext::Unknown;
     }
   }
-#endif
+#    endif
 
   unsigned opcode = faulty_instruction & 0x7f;         // lower 7 bits
   unsigned funct3 = (faulty_instruction >> 12) & 0x7;  // bits 12-14, inclusive
@@ -2081,9 +2093,9 @@ SignalContext::WriteFlag SignalContext::GetWriteFlag() const {
         case 0b000:  // lb
         case 0b001:  // lh
         case 0b010:  // lw
-#if __riscv_xlen == 64
+#    if __riscv_xlen == 64
         case 0b011:  // ld
-#endif
+#    endif
         case 0b100:  // lbu
         case 0b101:  // lhu
           return SignalContext::Read;
@@ -2095,20 +2107,20 @@ SignalContext::WriteFlag SignalContext::GetWriteFlag() const {
         case 0b000:  // sb
         case 0b001:  // sh
         case 0b010:  // sw
-#if __riscv_xlen == 64
+#    if __riscv_xlen == 64
         case 0b011:  // sd
-#endif
+#    endif
           return SignalContext::Write;
         default:
           return SignalContext::Unknown;
       }
-#if __riscv_flen >= 32
+#    if __riscv_flen >= 32
     case 0b0000111:  // floating-point loads
       switch (funct3) {
         case 0b010:  // flw
-#if __riscv_flen == 64
+#      if __riscv_flen == 64
         case 0b011:  // fld
-#endif
+#      endif
           return SignalContext::Read;
         default:
           return SignalContext::Unknown;
@@ -2116,21 +2128,21 @@ SignalContext::WriteFlag SignalContext::GetWriteFlag() const {
     case 0b0100111:  // floating-point stores
       switch (funct3) {
         case 0b010:  // fsw
-#if __riscv_flen == 64
+#      if __riscv_flen == 64
         case 0b011:  // fsd
-#endif
+#      endif
           return SignalContext::Write;
         default:
           return SignalContext::Unknown;
       }
-#endif
+#    endif
     default:
       return SignalContext::Unknown;
   }
-#else
+#  else
   (void)ucontext;
   return Unknown;  // FIXME: Implement.
-#endif
+#  endif
 }
 
 bool SignalContext::IsTrueFaultingAddress() const {
@@ -2139,129 +2151,288 @@ bool SignalContext::IsTrueFaultingAddress() const {
   return si->si_signo == SIGSEGV && si->si_code != 128;
 }
 
+UNUSED
+static const char *RegNumToRegName(int reg) {
+  switch (reg) {
+#  if SANITIZER_LINUX
+#    if defined(__x86_64__)
+    case REG_RAX:
+      return "rax";
+    case REG_RBX:
+      return "rbx";
+    case REG_RCX:
+      return "rcx";
+    case REG_RDX:
+      return "rdx";
+    case REG_RDI:
+      return "rdi";
+    case REG_RSI:
+      return "rsi";
+    case REG_RBP:
+      return "rbp";
+    case REG_RSP:
+      return "rsp";
+    case REG_R8:
+      return "r8";
+    case REG_R9:
+      return "r9";
+    case REG_R10:
+      return "r10";
+    case REG_R11:
+      return "r11";
+    case REG_R12:
+      return "r12";
+    case REG_R13:
+      return "r13";
+    case REG_R14:
+      return "r14";
+    case REG_R15:
+      return "r15";
+#    elif defined(__i386__)
+    case REG_EAX:
+      return "eax";
+    case REG_EBX:
+      return "ebx";
+    case REG_ECX:
+      return "ecx";
+    case REG_EDX:
+      return "edx";
+    case REG_EDI:
+      return "edi";
+    case REG_ESI:
+      return "esi";
+    case REG_EBP:
+      return "ebp";
+    case REG_ESP:
+      return "esp";
+#    endif
+#  endif
+    default:
+      return NULL;
+  }
+  return NULL;
+}
+
+#  if SANITIZER_LINUX
+UNUSED
+static void DumpSingleReg(ucontext_t *ctx, int RegNum) {
+  const char *RegName = RegNumToRegName(RegNum);
+#    if defined(__x86_64__)
+  Printf("%s%s = 0x%016llx  ", internal_strlen(RegName) == 2 ? " " : "",
+         RegName, ctx->uc_mcontext.gregs[RegNum]);
+#    elif defined(__i386__)
+  Printf("%s = 0x%08x  ", RegName, ctx->uc_mcontext.gregs[RegNum]);
+#    else
+  (void)RegName;
+#    endif
+}
+#  endif
+
 void SignalContext::DumpAllRegisters(void *context) {
-  // FIXME: Implement this.
+  ucontext_t *ucontext = (ucontext_t *)context;
+#  if SANITIZER_LINUX
+#    if defined(__x86_64__)
+  Report("Register values:\n");
+  DumpSingleReg(ucontext, REG_RAX);
+  DumpSingleReg(ucontext, REG_RBX);
+  DumpSingleReg(ucontext, REG_RCX);
+  DumpSingleReg(ucontext, REG_RDX);
+  Printf("\n");
+  DumpSingleReg(ucontext, REG_RDI);
+  DumpSingleReg(ucontext, REG_RSI);
+  DumpSingleReg(ucontext, REG_RBP);
+  DumpSingleReg(ucontext, REG_RSP);
+  Printf("\n");
+  DumpSingleReg(ucontext, REG_R8);
+  DumpSingleReg(ucontext, REG_R9);
+  DumpSingleReg(ucontext, REG_R10);
+  DumpSingleReg(ucontext, REG_R11);
+  Printf("\n");
+  DumpSingleReg(ucontext, REG_R12);
+  DumpSingleReg(ucontext, REG_R13);
+  DumpSingleReg(ucontext, REG_R14);
+  DumpSingleReg(ucontext, REG_R15);
+  Printf("\n");
+#    elif defined(__i386__)
+  // Duplication of this report print is caused by partial support
+  // of register values dumping. In case of unsupported yet architecture let's
+  // avoid printing 'Register values:' without actual values in the following
+  // output.
+  Report("Register values:\n");
+  DumpSingleReg(ucontext, REG_EAX);
+  DumpSingleReg(ucontext, REG_EBX);
+  DumpSingleReg(ucontext, REG_ECX);
+  DumpSingleReg(ucontext, REG_EDX);
+  Printf("\n");
+  DumpSingleReg(ucontext, REG_EDI);
+  DumpSingleReg(ucontext, REG_ESI);
+  DumpSingleReg(ucontext, REG_EBP);
+  DumpSingleReg(ucontext, REG_ESP);
+  Printf("\n");
+#    else
+  (void)ucontext;
+#    endif
+#  elif SANITIZER_FREEBSD
+#    if defined(__x86_64__)
+  Report("Register values:\n");
+  Printf("rax = 0x%016lx  ", ucontext->uc_mcontext.mc_rax);
+  Printf("rbx = 0x%016lx  ", ucontext->uc_mcontext.mc_rbx);
+  Printf("rcx = 0x%016lx  ", ucontext->uc_mcontext.mc_rcx);
+  Printf("rdx = 0x%016lx  ", ucontext->uc_mcontext.mc_rdx);
+  Printf("\n");
+  Printf("rdi = 0x%016lx  ", ucontext->uc_mcontext.mc_rdi);
+  Printf("rsi = 0x%016lx  ", ucontext->uc_mcontext.mc_rsi);
+  Printf("rbp = 0x%016lx  ", ucontext->uc_mcontext.mc_rbp);
+  Printf("rsp = 0x%016lx  ", ucontext->uc_mcontext.mc_rsp);
+  Printf("\n");
+  Printf(" r8 = 0x%016lx  ", ucontext->uc_mcontext.mc_r8);
+  Printf(" r9 = 0x%016lx  ", ucontext->uc_mcontext.mc_r9);
+  Printf("r10 = 0x%016lx  ", ucontext->uc_mcontext.mc_r10);
+  Printf("r11 = 0x%016lx  ", ucontext->uc_mcontext.mc_r11);
+  Printf("\n");
+  Printf("r12 = 0x%016lx  ", ucontext->uc_mcontext.mc_r12);
+  Printf("r13 = 0x%016lx  ", ucontext->uc_mcontext.mc_r13);
+  Printf("r14 = 0x%016lx  ", ucontext->uc_mcontext.mc_r14);
+  Printf("r15 = 0x%016lx  ", ucontext->uc_mcontext.mc_r15);
+  Printf("\n");
+#    elif defined(__i386__)
+  Report("Register values:\n");
+  Printf("eax = 0x%08x  ", ucontext->uc_mcontext.mc_eax);
+  Printf("ebx = 0x%08x  ", ucontext->uc_mcontext.mc_ebx);
+  Printf("ecx = 0x%08x  ", ucontext->uc_mcontext.mc_ecx);
+  Printf("edx = 0x%08x  ", ucontext->uc_mcontext.mc_edx);
+  Printf("\n");
+  Printf("edi = 0x%08x  ", ucontext->uc_mcontext.mc_edi);
+  Printf("esi = 0x%08x  ", ucontext->uc_mcontext.mc_esi);
+  Printf("ebp = 0x%08x  ", ucontext->uc_mcontext.mc_ebp);
+  Printf("esp = 0x%08x  ", ucontext->uc_mcontext.mc_esp);
+  Printf("\n");
+#    else
+  (void)ucontext;
+#    endif
+#  endif
+  // FIXME: Implement this for other OSes and architectures.
 }
 
 static void GetPcSpBp(void *context, uptr *pc, uptr *sp, uptr *bp) {
-#if SANITIZER_NETBSD
+#  if SANITIZER_NETBSD
   // This covers all NetBSD architectures
   ucontext_t *ucontext = (ucontext_t *)context;
   *pc = _UC_MACHINE_PC(ucontext);
   *bp = _UC_MACHINE_FP(ucontext);
   *sp = _UC_MACHINE_SP(ucontext);
-#elif defined(__arm__)
-  ucontext_t *ucontext = (ucontext_t*)context;
+#  elif defined(__arm__)
+  ucontext_t *ucontext = (ucontext_t *)context;
   *pc = ucontext->uc_mcontext.arm_pc;
   *bp = ucontext->uc_mcontext.arm_fp;
   *sp = ucontext->uc_mcontext.arm_sp;
-#elif defined(__aarch64__)
-# if SANITIZER_FREEBSD
-  ucontext_t *ucontext = (ucontext_t*)context;
+#  elif defined(__aarch64__)
+#    if SANITIZER_FREEBSD
+  ucontext_t *ucontext = (ucontext_t *)context;
   *pc = ucontext->uc_mcontext.mc_gpregs.gp_elr;
   *bp = ucontext->uc_mcontext.mc_gpregs.gp_x[29];
   *sp = ucontext->uc_mcontext.mc_gpregs.gp_sp;
-# else
-  ucontext_t *ucontext = (ucontext_t*)context;
+#    else
+  ucontext_t *ucontext = (ucontext_t *)context;
   *pc = ucontext->uc_mcontext.pc;
   *bp = ucontext->uc_mcontext.regs[29];
   *sp = ucontext->uc_mcontext.sp;
-# endif
-#elif defined(__hppa__)
-  ucontext_t *ucontext = (ucontext_t*)context;
+#    endif
+#  elif defined(__hppa__)
+  ucontext_t *ucontext = (ucontext_t *)context;
   *pc = ucontext->uc_mcontext.sc_iaoq[0];
   /* GCC uses %r3 whenever a frame pointer is needed.  */
   *bp = ucontext->uc_mcontext.sc_gr[3];
   *sp = ucontext->uc_mcontext.sc_gr[30];
-#elif defined(__x86_64__)
-# if SANITIZER_FREEBSD
-  ucontext_t *ucontext = (ucontext_t*)context;
+#  elif defined(__x86_64__)
+#    if SANITIZER_FREEBSD
+  ucontext_t *ucontext = (ucontext_t *)context;
   *pc = ucontext->uc_mcontext.mc_rip;
   *bp = ucontext->uc_mcontext.mc_rbp;
   *sp = ucontext->uc_mcontext.mc_rsp;
-# else
-  ucontext_t *ucontext = (ucontext_t*)context;
+#    else
+  ucontext_t *ucontext = (ucontext_t *)context;
   *pc = ucontext->uc_mcontext.gregs[REG_RIP];
   *bp = ucontext->uc_mcontext.gregs[REG_RBP];
   *sp = ucontext->uc_mcontext.gregs[REG_RSP];
-# endif
-#elif defined(__i386__)
-# if SANITIZER_FREEBSD
-  ucontext_t *ucontext = (ucontext_t*)context;
+#    endif
+#  elif defined(__i386__)
+#    if SANITIZER_FREEBSD
+  ucontext_t *ucontext = (ucontext_t *)context;
   *pc = ucontext->uc_mcontext.mc_eip;
   *bp = ucontext->uc_mcontext.mc_ebp;
   *sp = ucontext->uc_mcontext.mc_esp;
-# else
-  ucontext_t *ucontext = (ucontext_t*)context;
-# if SANITIZER_SOLARIS
+#    else
+  ucontext_t *ucontext = (ucontext_t *)context;
+#      if SANITIZER_SOLARIS
   /* Use the numeric values: the symbolic ones are undefined by llvm
      include/llvm/Support/Solaris.h.  */
-# ifndef REG_EIP
-#  define REG_EIP 14 // REG_PC
-# endif
-# ifndef REG_EBP
-#  define REG_EBP  6 // REG_FP
-# endif
-# ifndef REG_UESP
-#  define REG_UESP 17 // REG_SP
-# endif
-# endif
+#        ifndef REG_EIP
+#          define REG_EIP 14  // REG_PC
+#        endif
+#        ifndef REG_EBP
+#          define REG_EBP 6  // REG_FP
+#        endif
+#        ifndef REG_UESP
+#          define REG_UESP 17  // REG_SP
+#        endif
+#      endif
   *pc = ucontext->uc_mcontext.gregs[REG_EIP];
   *bp = ucontext->uc_mcontext.gregs[REG_EBP];
   *sp = ucontext->uc_mcontext.gregs[REG_UESP];
-# endif
-#elif defined(__powerpc__) || defined(__powerpc64__)
+#    endif
+#  elif defined(__powerpc__) || defined(__powerpc64__)
 #    if SANITIZER_FREEBSD
   ucontext_t *ucontext = (ucontext_t *)context;
   *pc = ucontext->uc_mcontext.mc_srr0;
   *sp = ucontext->uc_mcontext.mc_frame[1];
   *bp = ucontext->uc_mcontext.mc_frame[31];
 #    else
-  ucontext_t *ucontext = (ucontext_t*)context;
+  ucontext_t *ucontext = (ucontext_t *)context;
   *pc = ucontext->uc_mcontext.regs->nip;
   *sp = ucontext->uc_mcontext.regs->gpr[PT_R1];
   // The powerpc{,64}-linux ABIs do not specify r31 as the frame
   // pointer, but GCC always uses r31 when we need a frame pointer.
   *bp = ucontext->uc_mcontext.regs->gpr[PT_R31];
 #    endif
-#elif defined(__sparc__)
-#if defined(__arch64__) || defined(__sparcv9)
-#define STACK_BIAS 2047
-#else
-#define STACK_BIAS 0
-# endif
-# if SANITIZER_SOLARIS
+#  elif defined(__sparc__)
+#    if defined(__arch64__) || defined(__sparcv9)
+#      define STACK_BIAS 2047
+#    else
+#      define STACK_BIAS 0
+#    endif
+#    if SANITIZER_SOLARIS
   ucontext_t *ucontext = (ucontext_t *)context;
   *pc = ucontext->uc_mcontext.gregs[REG_PC];
   *sp = ucontext->uc_mcontext.gregs[REG_O6] + STACK_BIAS;
-#else
+#    else
   // Historical BSDism here.
   struct sigcontext *scontext = (struct sigcontext *)context;
-#if defined(__arch64__)
+#      if defined(__arch64__)
   *pc = scontext->sigc_regs.tpc;
   *sp = scontext->sigc_regs.u_regs[14] + STACK_BIAS;
-#else
+#      else
   *pc = scontext->si_regs.pc;
   *sp = scontext->si_regs.u_regs[14];
-#endif
-# endif
+#      endif
+#    endif
   *bp = (uptr)((uhwptr *)*sp)[14] + STACK_BIAS;
-#elif defined(__mips__)
-  ucontext_t *ucontext = (ucontext_t*)context;
+#  elif defined(__mips__)
+  ucontext_t *ucontext = (ucontext_t *)context;
   *pc = ucontext->uc_mcontext.pc;
   *bp = ucontext->uc_mcontext.gregs[30];
   *sp = ucontext->uc_mcontext.gregs[29];
-#elif defined(__s390__)
-  ucontext_t *ucontext = (ucontext_t*)context;
-# if defined(__s390x__)
+#  elif defined(__s390__)
+  ucontext_t *ucontext = (ucontext_t *)context;
+#    if defined(__s390x__)
   *pc = ucontext->uc_mcontext.psw.addr;
-# else
+#    else
   *pc = ucontext->uc_mcontext.psw.addr & 0x7fffffff;
-# endif
+#    endif
   *bp = ucontext->uc_mcontext.gregs[11];
   *sp = ucontext->uc_mcontext.gregs[15];
-#elif defined(__riscv)
-  ucontext_t *ucontext = (ucontext_t*)context;
+#  elif defined(__riscv)
+  ucontext_t *ucontext = (ucontext_t *)context;
 #    if SANITIZER_FREEBSD
   *pc = ucontext->uc_mcontext.mc_gpregs.gp_sepc;
   *bp = ucontext->uc_mcontext.mc_gpregs.gp_s[0];
@@ -2293,7 +2464,7 @@ void InitializePlatformEarly() {
 }
 
 void CheckASLR() {
-#if SANITIZER_NETBSD
+#  if SANITIZER_NETBSD
   int mib[3];
   int paxflags;
   uptr len = sizeof(paxflags);
@@ -2308,12 +2479,13 @@ void CheckASLR() {
   }
 
   if (UNLIKELY(paxflags & CTL_PROC_PAXFLAGS_ASLR)) {
-    Printf("This sanitizer is not compatible with enabled ASLR.\n"
-           "To disable ASLR, please run \"paxctl +a %s\" and try again.\n",
-           GetArgv()[0]);
+    Printf(
+        "This sanitizer is not compatible with enabled ASLR.\n"
+        "To disable ASLR, please run \"paxctl +a %s\" and try again.\n",
+        GetArgv()[0]);
     Die();
   }
-#elif SANITIZER_FREEBSD
+#  elif SANITIZER_FREEBSD
   int aslr_status;
   int r = internal_procctl(P_PID, 0, PROC_ASLR_STATUS, &aslr_status);
   if (UNLIKELY(r == -1)) {
@@ -2323,9 +2495,13 @@ void CheckASLR() {
     return;
   }
   if ((aslr_status & PROC_ASLR_ACTIVE) != 0) {
-    Printf("This sanitizer is not compatible with enabled ASLR "
-           "and binaries compiled with PIE\n");
-    Die();
+    VReport(1,
+            "This sanitizer is not compatible with enabled ASLR "
+            "and binaries compiled with PIE\n"
+            "ASLR will be disabled and the program re-executed.\n");
+    int aslr_ctl = PROC_ASLR_FORCE_DISABLE;
+    CHECK_NE(internal_procctl(P_PID, 0, PROC_ASLR_CTL, &aslr_ctl), -1);
+    ReExec();
   }
 #  elif SANITIZER_PPC64V2
   // Disable ASLR for Linux PPC64LE.
@@ -2345,7 +2521,7 @@ void CheckASLR() {
 }
 
 void CheckMPROTECT() {
-#if SANITIZER_NETBSD
+#  if SANITIZER_NETBSD
   int mib[3];
   int paxflags;
   uptr len = sizeof(paxflags);
@@ -2363,13 +2539,13 @@ void CheckMPROTECT() {
     Printf("This sanitizer is not compatible with enabled MPROTECT\n");
     Die();
   }
-#else
+#  else
   // Do nothing
-#endif
+#  endif
 }
 
 void CheckNoDeepBind(const char *filename, int flag) {
-#ifdef RTLD_DEEPBIND
+#  ifdef RTLD_DEEPBIND
   if (flag & RTLD_DEEPBIND) {
     Report(
         "You are trying to dlopen a %s shared library with RTLD_DEEPBIND flag"
@@ -2380,7 +2556,7 @@ void CheckNoDeepBind(const char *filename, int flag) {
         filename, filename);
     Die();
   }
-#endif
+#  endif
 }
 
 uptr FindAvailableMemoryRange(uptr size, uptr alignment, uptr left_padding,
@@ -2393,16 +2569,16 @@ uptr FindAvailableMemoryRange(uptr size, uptr alignment, uptr left_padding,
 bool GetRandom(void *buffer, uptr length, bool blocking) {
   if (!buffer || !length || length > 256)
     return false;
-#if SANITIZER_USE_GETENTROPY
+#  if SANITIZER_USE_GETENTROPY
   uptr rnd = getentropy(buffer, length);
   int rverrno = 0;
   if (internal_iserror(rnd, &rverrno) && rverrno == EFAULT)
     return false;
   else if (rnd == 0)
     return true;
-#endif // SANITIZER_USE_GETENTROPY
+#  endif  // SANITIZER_USE_GETENTROPY
 
-#if SANITIZER_USE_GETRANDOM
+#  if SANITIZER_USE_GETRANDOM
   static atomic_uint8_t skip_getrandom_syscall;
   if (!atomic_load_relaxed(&skip_getrandom_syscall)) {
     // Up to 256 bytes, getrandom will not be interrupted.
@@ -2414,7 +2590,7 @@ bool GetRandom(void *buffer, uptr length, bool blocking) {
     else if (res == length)
       return true;
   }
-#endif // SANITIZER_USE_GETRANDOM
+#  endif  // SANITIZER_USE_GETRANDOM
   // Up to 256 bytes, a read off /dev/urandom will not be interrupted.
   // blocking is moot here, O_NONBLOCK has no effect when opening /dev/urandom.
   uptr fd = internal_open("/dev/urandom", O_RDONLY);
@@ -2427,6 +2603,6 @@ bool GetRandom(void *buffer, uptr length, bool blocking) {
   return true;
 }
 
-} // namespace __sanitizer
+}  // namespace __sanitizer
 
 #endif
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_linux.h b/zig/lib/tsan/sanitizer_common/sanitizer_linux.h
index 7454369fa4..c30f032679 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_linux.h
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_linux.h
@@ -13,15 +13,15 @@
 #define SANITIZER_LINUX_H
 
 #include "sanitizer_platform.h"
-#if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD ||                \
+#if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD || \
     SANITIZER_SOLARIS
-#include "sanitizer_common.h"
-#include "sanitizer_internal_defs.h"
-#include "sanitizer_platform_limits_freebsd.h"
-#include "sanitizer_platform_limits_netbsd.h"
-#include "sanitizer_platform_limits_posix.h"
-#include "sanitizer_platform_limits_solaris.h"
-#include "sanitizer_posix.h"
+#  include "sanitizer_common.h"
+#  include "sanitizer_internal_defs.h"
+#  include "sanitizer_platform_limits_freebsd.h"
+#  include "sanitizer_platform_limits_netbsd.h"
+#  include "sanitizer_platform_limits_posix.h"
+#  include "sanitizer_platform_limits_solaris.h"
+#  include "sanitizer_posix.h"
 
 struct link_map;  // Opaque type returned by dlopen().
 struct utsname;
@@ -46,9 +46,9 @@ void ReadProcMaps(ProcSelfMapsBuff *proc_maps);
 
 // Syscall wrappers.
 uptr internal_getdents(fd_t fd, struct linux_dirent *dirp, unsigned int count);
-uptr internal_sigaltstack(const void* ss, void* oss);
+uptr internal_sigaltstack(const void *ss, void *oss);
 uptr internal_sigprocmask(int how, __sanitizer_sigset_t *set,
-    __sanitizer_sigset_t *oldset);
+                          __sanitizer_sigset_t *oldset);
 
 void SetSigProcMask(__sanitizer_sigset_t *set, __sanitizer_sigset_t *oldset);
 void BlockSignals(__sanitizer_sigset_t *oldset = nullptr);
@@ -65,10 +65,10 @@ struct ScopedBlockSignals {
 
 #  if SANITIZER_GLIBC
 uptr internal_clock_gettime(__sanitizer_clockid_t clk_id, void *tp);
-#endif
+#  endif
 
 // Linux-only syscalls.
-#if SANITIZER_LINUX
+#  if SANITIZER_LINUX
 uptr internal_prctl(int option, uptr arg2, uptr arg3, uptr arg4, uptr arg5);
 #    if defined(__x86_64__)
 uptr internal_arch_prctl(int option, uptr arg2);
@@ -83,15 +83,15 @@ void internal_sigdelset(__sanitizer_sigset_t *set, int signum);
         defined(__arm__) || SANITIZER_RISCV64 || SANITIZER_LOONGARCH64
 uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
                     int *parent_tidptr, void *newtls, int *child_tidptr);
-#endif
+#    endif
 int internal_uname(struct utsname *buf);
-#elif SANITIZER_FREEBSD
+#  elif SANITIZER_FREEBSD
 uptr internal_procctl(int type, int id, int cmd, void *data);
 void internal_sigdelset(__sanitizer_sigset_t *set, int signum);
-#elif SANITIZER_NETBSD
+#  elif SANITIZER_NETBSD
 void internal_sigdelset(__sanitizer_sigset_t *set, int signum);
 uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg);
-#endif  // SANITIZER_LINUX
+#  endif  // SANITIZER_LINUX
 
 // This class reads thread IDs from /proc/<pid>/task using only syscalls.
 class ThreadLister {
@@ -135,36 +135,60 @@ inline void ReleaseMemoryPagesToOSAndZeroFill(uptr beg, uptr end) {
   ReleaseMemoryPagesToOS(beg, end);
 }
 
-#if SANITIZER_ANDROID
-
-#if defined(__aarch64__)
-# define __get_tls() \
-    ({ void** __v; __asm__("mrs %0, tpidr_el0" : "=r"(__v)); __v; })
-#elif defined(__arm__)
-# define __get_tls() \
-    ({ void** __v; __asm__("mrc p15, 0, %0, c13, c0, 3" : "=r"(__v)); __v; })
-#elif defined(__mips__)
+#  if SANITIZER_ANDROID
+
+#    if defined(__aarch64__)
+#      define __get_tls()                           \
+        ({                                          \
+          void **__v;                               \
+          __asm__("mrs %0, tpidr_el0" : "=r"(__v)); \
+          __v;                                      \
+        })
+#    elif defined(__arm__)
+#      define __get_tls()                                    \
+        ({                                                   \
+          void **__v;                                        \
+          __asm__("mrc p15, 0, %0, c13, c0, 3" : "=r"(__v)); \
+          __v;                                               \
+        })
+#    elif defined(__mips__)
 // On mips32r1, this goes via a kernel illegal instruction trap that's
 // optimized for v1.
-# define __get_tls() \
-    ({ register void** __v asm("v1"); \
-       __asm__(".set    push\n" \
-               ".set    mips32r2\n" \
-               "rdhwr   %0,$29\n" \
-               ".set    pop\n" : "=r"(__v)); \
-       __v; })
-#elif defined (__riscv)
-# define __get_tls() \
-    ({ void** __v; __asm__("mv %0, tp" : "=r"(__v)); __v; })
-#elif defined(__i386__)
-# define __get_tls() \
-    ({ void** __v; __asm__("movl %%gs:0, %0" : "=r"(__v)); __v; })
-#elif defined(__x86_64__)
-# define __get_tls() \
-    ({ void** __v; __asm__("mov %%fs:0, %0" : "=r"(__v)); __v; })
-#else
-#error "Unsupported architecture."
-#endif
+#      define __get_tls()                \
+        ({                               \
+          register void **__v asm("v1"); \
+          __asm__(                       \
+              ".set    push\n"           \
+              ".set    mips32r2\n"       \
+              "rdhwr   %0,$29\n"         \
+              ".set    pop\n"            \
+              : "=r"(__v));              \
+          __v;                           \
+        })
+#    elif defined(__riscv)
+#      define __get_tls()                   \
+        ({                                  \
+          void **__v;                       \
+          __asm__("mv %0, tp" : "=r"(__v)); \
+          __v;                              \
+        })
+#    elif defined(__i386__)
+#      define __get_tls()                         \
+        ({                                        \
+          void **__v;                             \
+          __asm__("movl %%gs:0, %0" : "=r"(__v)); \
+          __v;                                    \
+        })
+#    elif defined(__x86_64__)
+#      define __get_tls()                        \
+        ({                                       \
+          void **__v;                            \
+          __asm__("mov %%fs:0, %0" : "=r"(__v)); \
+          __v;                                   \
+        })
+#    else
+#      error "Unsupported architecture."
+#    endif
 
 // The Android Bionic team has allocated a TLS slot for sanitizers starting
 // with Q, given that Android currently doesn't support ELF TLS. It is used to
@@ -175,7 +199,7 @@ ALWAYS_INLINE uptr *get_android_tls_ptr() {
   return reinterpret_cast<uptr *>(&__get_tls()[TLS_SLOT_SANITIZER]);
 }
 
-#endif  // SANITIZER_ANDROID
+#  endif  // SANITIZER_ANDROID
 
 }  // namespace __sanitizer
 
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_linux_libcdep.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_linux_libcdep.cpp
index 42013f4718..c3c717bbdb 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_linux_libcdep.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_linux_libcdep.cpp
@@ -16,89 +16,101 @@
 #if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD || \
     SANITIZER_SOLARIS
 
-#include "sanitizer_allocator_internal.h"
-#include "sanitizer_atomic.h"
-#include "sanitizer_common.h"
-#include "sanitizer_file.h"
-#include "sanitizer_flags.h"
-#include "sanitizer_freebsd.h"
-#include "sanitizer_getauxval.h"
-#include "sanitizer_glibc_version.h"
-#include "sanitizer_linux.h"
-#include "sanitizer_placement_new.h"
-#include "sanitizer_procmaps.h"
-#include "sanitizer_solaris.h"
-
-#if SANITIZER_NETBSD
-#define _RTLD_SOURCE  // for __lwp_gettcb_fast() / __lwp_getprivate_fast()
-#endif
+#  include "sanitizer_allocator_internal.h"
+#  include "sanitizer_atomic.h"
+#  include "sanitizer_common.h"
+#  include "sanitizer_file.h"
+#  include "sanitizer_flags.h"
+#  include "sanitizer_getauxval.h"
+#  include "sanitizer_glibc_version.h"
+#  include "sanitizer_linux.h"
+#  include "sanitizer_placement_new.h"
+#  include "sanitizer_procmaps.h"
+#  include "sanitizer_solaris.h"
+
+#  if SANITIZER_NETBSD
+#    define _RTLD_SOURCE  // for __lwp_gettcb_fast() / __lwp_getprivate_fast()
+#  endif
 
-#include <dlfcn.h>  // for dlsym()
-#include <link.h>
-#include <pthread.h>
-#include <signal.h>
-#include <sys/mman.h>
-#include <sys/resource.h>
-#include <syslog.h>
+#  include <dlfcn.h>  // for dlsym()
+#  include <link.h>
+#  include <pthread.h>
+#  include <signal.h>
+#  include <sys/mman.h>
+#  include <sys/resource.h>
+#  include <syslog.h>
 
-#if !defined(ElfW)
-#define ElfW(type) Elf_##type
-#endif
+#  if !defined(ElfW)
+#    define ElfW(type) Elf_##type
+#  endif
 
-#if SANITIZER_FREEBSD
-#include <pthread_np.h>
-#include <osreldate.h>
-#include <sys/sysctl.h>
-#define pthread_getattr_np pthread_attr_get_np
+#  if SANITIZER_FREEBSD
+#    include <pthread_np.h>
+#    include <sys/auxv.h>
+#    include <sys/sysctl.h>
+#    define pthread_getattr_np pthread_attr_get_np
 // The MAP_NORESERVE define has been removed in FreeBSD 11.x, and even before
 // that, it was never implemented. So just define it to zero.
-#undef MAP_NORESERVE
-#define MAP_NORESERVE 0
-#endif
+#    undef MAP_NORESERVE
+#    define MAP_NORESERVE 0
+extern const Elf_Auxinfo *__elf_aux_vector;
+extern "C" int __sys_sigaction(int signum, const struct sigaction *act,
+                               struct sigaction *oldact);
+#  endif
 
-#if SANITIZER_NETBSD
-#include <sys/sysctl.h>
-#include <sys/tls.h>
-#include <lwp.h>
-#endif
+#  if SANITIZER_NETBSD
+#    include <lwp.h>
+#    include <sys/sysctl.h>
+#    include <sys/tls.h>
+#  endif
 
-#if SANITIZER_SOLARIS
-#include <stddef.h>
-#include <stdlib.h>
-#include <thread.h>
-#endif
+#  if SANITIZER_SOLARIS
+#    include <stddef.h>
+#    include <stdlib.h>
+#    include <thread.h>
+#  endif
 
-#if SANITIZER_ANDROID
-#include <android/api-level.h>
-#if !defined(CPU_COUNT) && !defined(__aarch64__)
-#include <dirent.h>
-#include <fcntl.h>
+#  if SANITIZER_ANDROID
+#    include <android/api-level.h>
+#    if !defined(CPU_COUNT) && !defined(__aarch64__)
+#      include <dirent.h>
+#      include <fcntl.h>
 struct __sanitizer::linux_dirent {
-  long           d_ino;
-  off_t          d_off;
+  long d_ino;
+  off_t d_off;
   unsigned short d_reclen;
-  char           d_name[];
+  char d_name[];
 };
-#endif
-#endif
+#    endif
+#  endif
 
-#if !SANITIZER_ANDROID
-#include <elf.h>
-#include <unistd.h>
-#endif
+#  if !SANITIZER_ANDROID
+#    include <elf.h>
+#    include <unistd.h>
+#  endif
 
 namespace __sanitizer {
 
-SANITIZER_WEAK_ATTRIBUTE int
-real_sigaction(int signum, const void *act, void *oldact);
+SANITIZER_WEAK_ATTRIBUTE int real_sigaction(int signum, const void *act,
+                                            void *oldact);
 
 int internal_sigaction(int signum, const void *act, void *oldact) {
-#if !SANITIZER_GO
+#  if SANITIZER_FREEBSD
+  // On FreeBSD, call the sigaction syscall directly (part of libsys in FreeBSD
+  // 15) since the libc version goes via a global interposing table. Due to
+  // library initialization order the table can be relocated after the call to
+  // InitializeDeadlySignals() which then crashes when dereferencing the
+  // uninitialized pointer in libc.
+  return __sys_sigaction(signum, (const struct sigaction *)act,
+                         (struct sigaction *)oldact);
+#  else
+#    if !SANITIZER_GO
   if (&real_sigaction)
     return real_sigaction(signum, act, oldact);
-#endif
+#    endif
   return sigaction(signum, (const struct sigaction *)act,
                    (struct sigaction *)oldact);
+#  endif
 }
 
 void GetThreadStackTopAndBottom(bool at_initialization, uptr *stack_top,
@@ -111,7 +123,7 @@ void GetThreadStackTopAndBottom(bool at_initialization, uptr *stack_top,
     CHECK_EQ(getrlimit(RLIMIT_STACK, &rl), 0);
 
     // Find the mapping that contains a stack variable.
-    MemoryMappingLayout proc_maps(/*cache_enabled*/true);
+    MemoryMappingLayout proc_maps(/*cache_enabled*/ true);
     if (proc_maps.Error()) {
       *stack_top = *stack_bottom = 0;
       return;
@@ -119,7 +131,8 @@ void GetThreadStackTopAndBottom(bool at_initialization, uptr *stack_top,
     MemoryMappedSegment segment;
     uptr prev_end = 0;
     while (proc_maps.Next(&segment)) {
-      if ((uptr)&rl < segment.end) break;
+      if ((uptr)&rl < segment.end)
+        break;
       prev_end = segment.end;
     }
     CHECK((uptr)&rl >= segment.start && (uptr)&rl < segment.end);
@@ -127,7 +140,8 @@ void GetThreadStackTopAndBottom(bool at_initialization, uptr *stack_top,
     // Get stacksize from rlimit, but clip it so that it does not overlap
     // with other mappings.
     uptr stacksize = rl.rlim_cur;
-    if (stacksize > segment.end - prev_end) stacksize = segment.end - prev_end;
+    if (stacksize > segment.end - prev_end)
+      stacksize = segment.end - prev_end;
     // When running with unlimited stack size, we still want to set some limit.
     // The unlimited stack size is caused by 'ulimit -s unlimited'.
     // Also, for some reason, GNU make spawns subprocesses with unlimited stack.
@@ -135,43 +149,56 @@ void GetThreadStackTopAndBottom(bool at_initialization, uptr *stack_top,
       stacksize = kMaxThreadStackSize;
     *stack_top = segment.end;
     *stack_bottom = segment.end - stacksize;
+
+    uptr maxAddr = GetMaxUserVirtualAddress();
+    // Edge case: the stack mapping on some systems may be off-by-one e.g.,
+    //     fffffffdf000-1000000000000 rw-p 00000000 00:00 0 [stack]
+    // instead of:
+    //     fffffffdf000- ffffffffffff
+    // The out-of-range stack_top can result in an invalid shadow address
+    // calculation, since those usually assume the parameters are in range.
+    if (*stack_top == maxAddr + 1)
+      *stack_top = maxAddr;
+    else
+      CHECK_LE(*stack_top, maxAddr);
+
     return;
   }
   uptr stacksize = 0;
   void *stackaddr = nullptr;
-#if SANITIZER_SOLARIS
+#  if SANITIZER_SOLARIS
   stack_t ss;
   CHECK_EQ(thr_stksegment(&ss), 0);
   stacksize = ss.ss_size;
   stackaddr = (char *)ss.ss_sp - stacksize;
-#else  // !SANITIZER_SOLARIS
+#  else   // !SANITIZER_SOLARIS
   pthread_attr_t attr;
   pthread_attr_init(&attr);
   CHECK_EQ(pthread_getattr_np(pthread_self(), &attr), 0);
   internal_pthread_attr_getstack(&attr, &stackaddr, &stacksize);
   pthread_attr_destroy(&attr);
-#endif  // SANITIZER_SOLARIS
+#  endif  // SANITIZER_SOLARIS
 
   *stack_top = (uptr)stackaddr + stacksize;
   *stack_bottom = (uptr)stackaddr;
 }
 
-#if !SANITIZER_GO
+#  if !SANITIZER_GO
 bool SetEnv(const char *name, const char *value) {
   void *f = dlsym(RTLD_NEXT, "setenv");
   if (!f)
     return false;
-  typedef int(*setenv_ft)(const char *name, const char *value, int overwrite);
+  typedef int (*setenv_ft)(const char *name, const char *value, int overwrite);
   setenv_ft setenv_f;
   CHECK_EQ(sizeof(setenv_f), sizeof(f));
   internal_memcpy(&setenv_f, &f, sizeof(f));
   return setenv_f(name, value, 1) == 0;
 }
-#endif
+#  endif
 
 __attribute__((unused)) static bool GetLibcVersion(int *major, int *minor,
                                                    int *patch) {
-#ifdef _CS_GNU_LIBC_VERSION
+#  ifdef _CS_GNU_LIBC_VERSION
   char buf[64];
   uptr len = confstr(_CS_GNU_LIBC_VERSION, buf, sizeof(buf));
   if (len >= sizeof(buf))
@@ -185,9 +212,9 @@ __attribute__((unused)) static bool GetLibcVersion(int *major, int *minor,
   *minor = (*p == '.') ? internal_simple_strtoll(p + 1, &p, 10) : 0;
   *patch = (*p == '.') ? internal_simple_strtoll(p + 1, &p, 10) : 0;
   return true;
-#else
+#  else
   return false;
-#endif
+#  endif
 }
 
 // True if we can use dlpi_tls_data. glibc before 2.25 may leave NULL (BZ
@@ -198,42 +225,42 @@ __attribute__((unused)) static bool GetLibcVersion(int *major, int *minor,
 // https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=254774
 __attribute__((unused)) static int g_use_dlpi_tls_data;
 
-#if SANITIZER_GLIBC && !SANITIZER_GO
+#  if SANITIZER_GLIBC && !SANITIZER_GO
 __attribute__((unused)) static size_t g_tls_size;
 void InitTlsSize() {
   int major, minor, patch;
   g_use_dlpi_tls_data =
       GetLibcVersion(&major, &minor, &patch) && major == 2 && minor >= 25;
 
-#if defined(__aarch64__) || defined(__x86_64__) || defined(__powerpc64__) || \
-    defined(__loongarch__)
+#    if defined(__aarch64__) || defined(__x86_64__) || \
+        defined(__powerpc64__) || defined(__loongarch__)
   void *get_tls_static_info = dlsym(RTLD_NEXT, "_dl_get_tls_static_info");
   size_t tls_align;
   ((void (*)(size_t *, size_t *))get_tls_static_info)(&g_tls_size, &tls_align);
-#endif
+#    endif
 }
-#else
-void InitTlsSize() { }
-#endif  // SANITIZER_GLIBC && !SANITIZER_GO
+#  else
+void InitTlsSize() {}
+#  endif  // SANITIZER_GLIBC && !SANITIZER_GO
 
 // On glibc x86_64, ThreadDescriptorSize() needs to be precise due to the usage
 // of g_tls_size. On other targets, ThreadDescriptorSize() is only used by lsan
 // to get the pointer to thread-specific data keys in the thread control block.
-#if (SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_SOLARIS) && \
-    !SANITIZER_ANDROID && !SANITIZER_GO
+#  if (SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_SOLARIS) && \
+      !SANITIZER_ANDROID && !SANITIZER_GO
 // sizeof(struct pthread) from glibc.
 static atomic_uintptr_t thread_descriptor_size;
 
 static uptr ThreadDescriptorSizeFallback() {
   uptr val = 0;
-#if defined(__x86_64__) || defined(__i386__) || defined(__arm__)
+#    if defined(__x86_64__) || defined(__i386__) || defined(__arm__)
   int major;
   int minor;
   int patch;
   if (GetLibcVersion(&major, &minor, &patch) && major == 2) {
     /* sizeof(struct pthread) values from various glibc versions.  */
     if (SANITIZER_X32)
-      val = 1728; // Assume only one particular version for x32.
+      val = 1728;  // Assume only one particular version for x32.
     // For ARM sizeof(struct pthread) changed in Glibc 2.23.
     else if (SANITIZER_ARM)
       val = minor <= 22 ? 1120 : 1216;
@@ -256,19 +283,19 @@ static uptr ThreadDescriptorSizeFallback() {
     else  // minor == 32
       val = FIRST_32_SECOND_64(1344, 2496);
   }
-#elif defined(__s390__) || defined(__sparc__)
+#    elif defined(__s390__) || defined(__sparc__)
   // The size of a prefix of TCB including pthread::{specific_1stblock,specific}
   // suffices. Just return offsetof(struct pthread, specific_used), which hasn't
   // changed since 2007-05. Technically this applies to i386/x86_64 as well but
   // we call _dl_get_tls_static_info and need the precise size of struct
   // pthread.
   return FIRST_32_SECOND_64(524, 1552);
-#elif defined(__mips__)
+#    elif defined(__mips__)
   // TODO(sagarthakur): add more values as per different glibc versions.
   val = FIRST_32_SECOND_64(1152, 1776);
-#elif SANITIZER_LOONGARCH64
-  val = 1856; // from glibc 2.36
-#elif SANITIZER_RISCV64
+#    elif SANITIZER_LOONGARCH64
+  val = 1856;  // from glibc 2.36
+#    elif SANITIZER_RISCV64
   int major;
   int minor;
   int patch;
@@ -283,12 +310,12 @@ static uptr ThreadDescriptorSizeFallback() {
       val = 1936;  // tested against glibc 2.32
   }
 
-#elif defined(__aarch64__)
+#    elif defined(__aarch64__)
   // The sizeof (struct pthread) is the same from GLIBC 2.17 to 2.22.
   val = 1776;
-#elif defined(__powerpc64__)
-  val = 1776; // from glibc.ppc64le 2.20-8.fc21
-#endif
+#    elif defined(__powerpc64__)
+  val = 1776;  // from glibc.ppc64le 2.20-8.fc21
+#    endif
   return val;
 }
 
@@ -307,26 +334,26 @@ uptr ThreadDescriptorSize() {
   return val;
 }
 
-#if defined(__mips__) || defined(__powerpc64__) || SANITIZER_RISCV64 || \
-    SANITIZER_LOONGARCH64
+#    if defined(__mips__) || defined(__powerpc64__) || SANITIZER_RISCV64 || \
+        SANITIZER_LOONGARCH64
 // TlsPreTcbSize includes size of struct pthread_descr and size of tcb
 // head structure. It lies before the static tls blocks.
 static uptr TlsPreTcbSize() {
-#if defined(__mips__)
-  const uptr kTcbHead = 16; // sizeof (tcbhead_t)
-#elif defined(__powerpc64__)
-  const uptr kTcbHead = 88; // sizeof (tcbhead_t)
-#elif SANITIZER_RISCV64
+#      if defined(__mips__)
   const uptr kTcbHead = 16;  // sizeof (tcbhead_t)
-#elif SANITIZER_LOONGARCH64
+#      elif defined(__powerpc64__)
+  const uptr kTcbHead = 88;  // sizeof (tcbhead_t)
+#      elif SANITIZER_RISCV64
   const uptr kTcbHead = 16;  // sizeof (tcbhead_t)
-#endif
+#      elif SANITIZER_LOONGARCH64
+  const uptr kTcbHead = 16;  // sizeof (tcbhead_t)
+#      endif
   const uptr kTlsAlign = 16;
   const uptr kTlsPreTcbSize =
       RoundUpTo(ThreadDescriptorSize() + kTcbHead, kTlsAlign);
   return kTlsPreTcbSize;
 }
-#endif
+#    endif
 
 namespace {
 struct TlsBlock {
@@ -336,7 +363,7 @@ struct TlsBlock {
 };
 }  // namespace
 
-#ifdef __s390__
+#    ifdef __s390__
 extern "C" uptr __tls_get_offset(void *arg);
 
 static uptr TlsGetOffset(uptr ti_module, uptr ti_offset) {
@@ -354,16 +381,16 @@ static uptr TlsGetOffset(uptr ti_module, uptr ti_offset) {
       : "memory", "cc", "0", "1", "3", "4", "5", "14");
   return r2;
 }
-#else
+#    else
 extern "C" void *__tls_get_addr(size_t *);
-#endif
+#    endif
 
 static size_t main_tls_modid;
 
 static int CollectStaticTlsBlocks(struct dl_phdr_info *info, size_t size,
                                   void *data) {
   size_t tls_modid;
-#if SANITIZER_SOLARIS
+#    if SANITIZER_SOLARIS
   // dlpi_tls_modid is only available since Solaris 11.4 SRU 10.  Use
   // dlinfo(RTLD_DI_LINKMAP) instead which works on all of Solaris 11.3,
   // 11.4, and Illumos.  The tlsmodid of the executable was changed to 1 in
@@ -376,27 +403,26 @@ static int CollectStaticTlsBlocks(struct dl_phdr_info *info, size_t size,
   Rt_map *map;
   dlinfo(RTLD_SELF, RTLD_DI_LINKMAP, &map);
   tls_modid = map->rt_tlsmodid;
-#else
+#    else
   main_tls_modid = 1;
   tls_modid = info->dlpi_tls_modid;
-#endif
+#    endif
 
   if (tls_modid < main_tls_modid)
     return 0;
   uptr begin;
-#if !SANITIZER_SOLARIS
+#    if !SANITIZER_SOLARIS
   begin = (uptr)info->dlpi_tls_data;
-#endif
+#    endif
   if (!g_use_dlpi_tls_data) {
     // Call __tls_get_addr as a fallback. This forces TLS allocation on glibc
     // and FreeBSD.
-#ifdef __s390__
-    begin = (uptr)__builtin_thread_pointer() +
-            TlsGetOffset(tls_modid, 0);
-#else
+#    ifdef __s390__
+    begin = (uptr)__builtin_thread_pointer() + TlsGetOffset(tls_modid, 0);
+#    else
     size_t mod_and_off[2] = {tls_modid, 0};
     begin = (uptr)__tls_get_addr(mod_and_off);
-#endif
+#    endif
   }
   for (unsigned i = 0; i != info->dlpi_phnum; ++i)
     if (info->dlpi_phdr[i].p_type == PT_TLS) {
@@ -439,23 +465,21 @@ __attribute__((unused)) static void GetStaticTlsBoundary(uptr *addr, uptr *size,
   *addr = ranges[l].begin;
   *size = ranges[r - 1].end - ranges[l].begin;
 }
-#endif  // (x86_64 || i386 || mips || ...) && (SANITIZER_FREEBSD ||
-        // SANITIZER_LINUX) && !SANITIZER_ANDROID && !SANITIZER_GO
+#  endif  // (x86_64 || i386 || mips || ...) && (SANITIZER_FREEBSD ||
+          // SANITIZER_LINUX) && !SANITIZER_ANDROID && !SANITIZER_GO
 
-#if SANITIZER_NETBSD
-static struct tls_tcb * ThreadSelfTlsTcb() {
+#  if SANITIZER_NETBSD
+static struct tls_tcb *ThreadSelfTlsTcb() {
   struct tls_tcb *tcb = nullptr;
-#ifdef __HAVE___LWP_GETTCB_FAST
+#    ifdef __HAVE___LWP_GETTCB_FAST
   tcb = (struct tls_tcb *)__lwp_gettcb_fast();
-#elif defined(__HAVE___LWP_GETPRIVATE_FAST)
+#    elif defined(__HAVE___LWP_GETPRIVATE_FAST)
   tcb = (struct tls_tcb *)__lwp_getprivate_fast();
-#endif
+#    endif
   return tcb;
 }
 
-uptr ThreadSelf() {
-  return (uptr)ThreadSelfTlsTcb()->tcb_pthread;
-}
+uptr ThreadSelf() { return (uptr)ThreadSelfTlsTcb()->tcb_pthread; }
 
 int GetSizeFromHdr(struct dl_phdr_info *info, size_t size, void *data) {
   const Elf_Phdr *hdr = info->dlpi_phdr;
@@ -463,23 +487,23 @@ int GetSizeFromHdr(struct dl_phdr_info *info, size_t size, void *data) {
 
   for (; hdr != last_hdr; ++hdr) {
     if (hdr->p_type == PT_TLS && info->dlpi_tls_modid == 1) {
-      *(uptr*)data = hdr->p_memsz;
+      *(uptr *)data = hdr->p_memsz;
       break;
     }
   }
   return 0;
 }
-#endif  // SANITIZER_NETBSD
+#  endif  // SANITIZER_NETBSD
 
-#if SANITIZER_ANDROID
+#  if SANITIZER_ANDROID
 // Bionic provides this API since S.
 extern "C" SANITIZER_WEAK_ATTRIBUTE void __libc_get_static_tls_bounds(void **,
                                                                       void **);
-#endif
+#  endif
 
-#if !SANITIZER_GO
+#  if !SANITIZER_GO
 static void GetTls(uptr *addr, uptr *size) {
-#if SANITIZER_ANDROID
+#    if SANITIZER_ANDROID
   if (&__libc_get_static_tls_bounds) {
     void *start_addr;
     void *end_addr;
@@ -491,48 +515,48 @@ static void GetTls(uptr *addr, uptr *size) {
     *addr = 0;
     *size = 0;
   }
-#elif SANITIZER_GLIBC && defined(__x86_64__)
+#    elif SANITIZER_GLIBC && defined(__x86_64__)
   // For aarch64 and x86-64, use an O(1) approach which requires relatively
   // precise ThreadDescriptorSize. g_tls_size was initialized in InitTlsSize.
-#  if SANITIZER_X32
+#      if SANITIZER_X32
   asm("mov %%fs:8,%0" : "=r"(*addr));
-#  else
+#      else
   asm("mov %%fs:16,%0" : "=r"(*addr));
-#  endif
+#      endif
   *size = g_tls_size;
   *addr -= *size;
   *addr += ThreadDescriptorSize();
-#elif SANITIZER_GLIBC && defined(__aarch64__)
+#    elif SANITIZER_GLIBC && defined(__aarch64__)
   *addr = reinterpret_cast<uptr>(__builtin_thread_pointer()) -
           ThreadDescriptorSize();
   *size = g_tls_size + ThreadDescriptorSize();
-#elif SANITIZER_GLIBC && defined(__loongarch__)
-#  ifdef __clang__
+#    elif SANITIZER_GLIBC && defined(__loongarch__)
+#      ifdef __clang__
   *addr = reinterpret_cast<uptr>(__builtin_thread_pointer()) -
           ThreadDescriptorSize();
-#  else
+#      else
   asm("or %0,$tp,$zero" : "=r"(*addr));
   *addr -= ThreadDescriptorSize();
-#  endif
+#      endif
   *size = g_tls_size + ThreadDescriptorSize();
-#elif SANITIZER_GLIBC && defined(__powerpc64__)
+#    elif SANITIZER_GLIBC && defined(__powerpc64__)
   // Workaround for glibc<2.25(?). 2.27 is known to not need this.
   uptr tp;
   asm("addi %0,13,-0x7000" : "=r"(tp));
   const uptr pre_tcb_size = TlsPreTcbSize();
   *addr = tp - pre_tcb_size;
   *size = g_tls_size + pre_tcb_size;
-#elif SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_SOLARIS
+#    elif SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_SOLARIS
   uptr align;
   GetStaticTlsBoundary(addr, size, &align);
-#if defined(__x86_64__) || defined(__i386__) || defined(__s390__) || \
-    defined(__sparc__)
+#      if defined(__x86_64__) || defined(__i386__) || defined(__s390__) || \
+          defined(__sparc__)
   if (SANITIZER_GLIBC) {
-#if defined(__x86_64__) || defined(__i386__)
+#        if defined(__x86_64__) || defined(__i386__)
     align = Max<uptr>(align, 64);
-#else
+#        else
     align = Max<uptr>(align, 16);
-#endif
+#        endif
   }
   const uptr tp = RoundUpTo(*addr + *size, align);
 
@@ -551,26 +575,26 @@ static void GetTls(uptr *addr, uptr *size) {
   // because the number of bytes after pthread::specific is larger.
   *addr = tp - RoundUpTo(*size, align);
   *size = tp - *addr + ThreadDescriptorSize();
-#else
+#      else
   if (SANITIZER_GLIBC)
     *size += 1664;
   else if (SANITIZER_FREEBSD)
     *size += 128;  // RTLD_STATIC_TLS_EXTRA
-#if defined(__mips__) || defined(__powerpc64__) || SANITIZER_RISCV64
+#        if defined(__mips__) || defined(__powerpc64__) || SANITIZER_RISCV64
   const uptr pre_tcb_size = TlsPreTcbSize();
   *addr -= pre_tcb_size;
   *size += pre_tcb_size;
-#else
+#        else
   // arm and aarch64 reserve two words at TP, so this underestimates the range.
   // However, this is sufficient for the purpose of finding the pointers to
   // thread-specific data keys.
   const uptr tcb_size = ThreadDescriptorSize();
   *addr -= tcb_size;
   *size += tcb_size;
-#endif
-#endif
-#elif SANITIZER_NETBSD
-  struct tls_tcb * const tcb = ThreadSelfTlsTcb();
+#        endif
+#      endif
+#    elif SANITIZER_NETBSD
+  struct tls_tcb *const tcb = ThreadSelfTlsTcb();
   *addr = 0;
   *size = 0;
   if (tcb != 0) {
@@ -583,31 +607,31 @@ static void GetTls(uptr *addr, uptr *size) {
       *addr = (uptr)tcb->tcb_dtv[1];
     }
   }
-#else
-#error "Unknown OS"
-#endif
+#    else
+#      error "Unknown OS"
+#    endif
 }
-#endif
+#  endif
 
-#if !SANITIZER_GO
+#  if !SANITIZER_GO
 uptr GetTlsSize() {
-#if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD || \
-    SANITIZER_SOLARIS
+#    if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD || \
+        SANITIZER_SOLARIS
   uptr addr, size;
   GetTls(&addr, &size);
   return size;
-#else
+#    else
   return 0;
-#endif
+#    endif
 }
-#endif
+#  endif
 
 void GetThreadStackAndTls(bool main, uptr *stk_addr, uptr *stk_size,
                           uptr *tls_addr, uptr *tls_size) {
-#if SANITIZER_GO
+#  if SANITIZER_GO
   // Stub implementation for Go.
   *stk_addr = *stk_size = *tls_addr = *tls_size = 0;
-#else
+#  else
   GetTls(tls_addr, tls_size);
 
   uptr stack_top, stack_bottom;
@@ -623,16 +647,12 @@ void GetThreadStackAndTls(bool main, uptr *stk_addr, uptr *stk_size,
       *stk_size = *tls_addr - *stk_addr;
     }
   }
-#endif
+#  endif
 }
 
-#if !SANITIZER_FREEBSD
+#  if !SANITIZER_FREEBSD
 typedef ElfW(Phdr) Elf_Phdr;
-#elif SANITIZER_WORDSIZE == 32 && __FreeBSD_version <= 902001  // v9.2
-#define Elf_Phdr XElf32_Phdr
-#define dl_phdr_info xdl_phdr_info
-#define dl_iterate_phdr(c, b) xdl_iterate_phdr((c), (b))
-#endif  // !SANITIZER_FREEBSD
+#  endif
 
 struct DlIteratePhdrData {
   InternalMmapVectorNoCtor<LoadedModule> *modules;
@@ -652,8 +672,7 @@ static int AddModuleSegments(const char *module_name, dl_phdr_info *info,
       uptr cur_end = cur_beg + phdr->p_memsz;
       bool executable = phdr->p_flags & PF_X;
       bool writable = phdr->p_flags & PF_W;
-      cur_module.addAddressRange(cur_beg, cur_end, executable,
-                                 writable);
+      cur_module.addAddressRange(cur_beg, cur_end, executable, writable);
     } else if (phdr->p_type == PT_NOTE) {
 #  ifdef NT_GNU_BUILD_ID
       uptr off = 0;
@@ -698,33 +717,30 @@ static int dl_iterate_phdr_cb(dl_phdr_info *info, size_t size, void *arg) {
     return AddModuleSegments(module_name.data(), info, data->modules);
   }
 
-  if (info->dlpi_name) {
-    InternalScopedString module_name;
-    module_name.append("%s", info->dlpi_name);
-    return AddModuleSegments(module_name.data(), info, data->modules);
-  }
+  if (info->dlpi_name)
+    return AddModuleSegments(info->dlpi_name, info, data->modules);
 
   return 0;
 }
 
-#if SANITIZER_ANDROID && __ANDROID_API__ < 21
+#  if SANITIZER_ANDROID && __ANDROID_API__ < 21
 extern "C" __attribute__((weak)) int dl_iterate_phdr(
     int (*)(struct dl_phdr_info *, size_t, void *), void *);
-#endif
+#  endif
 
 static bool requiresProcmaps() {
-#if SANITIZER_ANDROID && __ANDROID_API__ <= 22
+#  if SANITIZER_ANDROID && __ANDROID_API__ <= 22
   // Fall back to /proc/maps if dl_iterate_phdr is unavailable or broken.
   // The runtime check allows the same library to work with
   // both K and L (and future) Android releases.
   return AndroidGetApiLevel() <= ANDROID_LOLLIPOP_MR1;
-#else
+#  else
   return false;
-#endif
+#  endif
 }
 
 static void procmapsInit(InternalMmapVectorNoCtor<LoadedModule> *modules) {
-  MemoryMappingLayout memory_mapping(/*cache_enabled*/true);
+  MemoryMappingLayout memory_mapping(/*cache_enabled*/ true);
   memory_mapping.DumpListOfModules(modules);
 }
 
@@ -776,22 +792,19 @@ uptr GetRSS() {
   // We need the second number which is RSS in pages.
   char *pos = buf;
   // Skip the first number.
-  while (*pos >= '0' && *pos <= '9')
-    pos++;
+  while (*pos >= '0' && *pos <= '9') pos++;
   // Skip whitespaces.
-  while (!(*pos >= '0' && *pos <= '9') && *pos != 0)
-    pos++;
+  while (!(*pos >= '0' && *pos <= '9') && *pos != 0) pos++;
   // Read the number.
   uptr rss = 0;
-  while (*pos >= '0' && *pos <= '9')
-    rss = rss * 10 + *pos++ - '0';
+  while (*pos >= '0' && *pos <= '9') rss = rss * 10 + *pos++ - '0';
   return rss * GetPageSizeCached();
 }
 
 // sysconf(_SC_NPROCESSORS_{CONF,ONLN}) cannot be used on most platforms as
 // they allocate memory.
 u32 GetNumberOfCPUs() {
-#if SANITIZER_FREEBSD || SANITIZER_NETBSD
+#  if SANITIZER_FREEBSD || SANITIZER_NETBSD
   u32 ncpu;
   int req[2];
   uptr len = sizeof(ncpu);
@@ -799,7 +812,7 @@ u32 GetNumberOfCPUs() {
   req[1] = HW_NCPU;
   CHECK_EQ(internal_sysctl(req, 2, &ncpu, &len, NULL, 0), 0);
   return ncpu;
-#elif SANITIZER_ANDROID && !defined(CPU_COUNT) && !defined(__aarch64__)
+#  elif SANITIZER_ANDROID && !defined(CPU_COUNT) && !defined(__aarch64__)
   // Fall back to /sys/devices/system/cpu on Android when cpu_set_t doesn't
   // exist in sched.h. That is the case for toolchains generated with older
   // NDKs.
@@ -827,26 +840,26 @@ u32 GetNumberOfCPUs() {
       break;
     if (entry->d_ino != 0 && *d_type == DT_DIR) {
       if (entry->d_name[0] == 'c' && entry->d_name[1] == 'p' &&
-          entry->d_name[2] == 'u' &&
-          entry->d_name[3] >= '0' && entry->d_name[3] <= '9')
+          entry->d_name[2] == 'u' && entry->d_name[3] >= '0' &&
+          entry->d_name[3] <= '9')
         n_cpus++;
     }
     entry = (struct linux_dirent *)(((u8 *)entry) + entry->d_reclen);
   }
   internal_close(fd);
   return n_cpus;
-#elif SANITIZER_SOLARIS
+#  elif SANITIZER_SOLARIS
   return sysconf(_SC_NPROCESSORS_ONLN);
-#else
+#  else
   cpu_set_t CPUs;
   CHECK_EQ(sched_getaffinity(0, sizeof(cpu_set_t), &CPUs), 0);
   return CPU_COUNT(&CPUs);
-#endif
+#  endif
 }
 
-#if SANITIZER_LINUX
+#  if SANITIZER_LINUX
 
-#if SANITIZER_ANDROID
+#    if SANITIZER_ANDROID
 static atomic_uint8_t android_log_initialized;
 
 void AndroidLogInit() {
@@ -858,13 +871,15 @@ static bool ShouldLogAfterPrintf() {
   return atomic_load(&android_log_initialized, memory_order_acquire);
 }
 
-extern "C" SANITIZER_WEAK_ATTRIBUTE
-int async_safe_write_log(int pri, const char* tag, const char* msg);
-extern "C" SANITIZER_WEAK_ATTRIBUTE
-int __android_log_write(int prio, const char* tag, const char* msg);
+extern "C" SANITIZER_WEAK_ATTRIBUTE int async_safe_write_log(int pri,
+                                                             const char *tag,
+                                                             const char *msg);
+extern "C" SANITIZER_WEAK_ATTRIBUTE int __android_log_write(int prio,
+                                                            const char *tag,
+                                                            const char *msg);
 
 // ANDROID_LOG_INFO is 4, but can't be resolved at runtime.
-#define SANITIZER_ANDROID_LOG_INFO 4
+#      define SANITIZER_ANDROID_LOG_INFO 4
 
 // async_safe_write_log is a new public version of __libc_write_log that is
 // used behind syslog. It is preferable to syslog as it will not do any dynamic
@@ -883,14 +898,14 @@ void WriteOneLineToSyslog(const char *s) {
   }
 }
 
-extern "C" SANITIZER_WEAK_ATTRIBUTE
-void android_set_abort_message(const char *);
+extern "C" SANITIZER_WEAK_ATTRIBUTE void android_set_abort_message(
+    const char *);
 
 void SetAbortMessage(const char *str) {
   if (&android_set_abort_message)
     android_set_abort_message(str);
 }
-#else
+#    else
 void AndroidLogInit() {}
 
 static bool ShouldLogAfterPrintf() { return true; }
@@ -898,16 +913,16 @@ static bool ShouldLogAfterPrintf() { return true; }
 void WriteOneLineToSyslog(const char *s) { syslog(LOG_INFO, "%s", s); }
 
 void SetAbortMessage(const char *str) {}
-#endif  // SANITIZER_ANDROID
+#    endif  // SANITIZER_ANDROID
 
 void LogMessageOnPrintf(const char *str) {
   if (common_flags()->log_to_syslog && ShouldLogAfterPrintf())
     WriteToSyslog(str);
 }
 
-#endif  // SANITIZER_LINUX
+#  endif  // SANITIZER_LINUX
 
-#if SANITIZER_GLIBC && !SANITIZER_GO
+#  if SANITIZER_GLIBC && !SANITIZER_GO
 // glibc crashes when using clock_gettime from a preinit_array function as the
 // vDSO function pointers haven't been initialized yet. __progname is
 // initialized after the vDSO function pointers, so if it exists, is not null
@@ -918,8 +933,8 @@ inline bool CanUseVDSO() { return &__progname && __progname && *__progname; }
 // MonotonicNanoTime is a timing function that can leverage the vDSO by calling
 // clock_gettime. real_clock_gettime only exists if clock_gettime is
 // intercepted, so define it weakly and use it if available.
-extern "C" SANITIZER_WEAK_ATTRIBUTE
-int real_clock_gettime(u32 clk_id, void *tp);
+extern "C" SANITIZER_WEAK_ATTRIBUTE int real_clock_gettime(u32 clk_id,
+                                                           void *tp);
 u64 MonotonicNanoTime() {
   timespec ts;
   if (CanUseVDSO()) {
@@ -932,19 +947,26 @@ u64 MonotonicNanoTime() {
   }
   return (u64)ts.tv_sec * (1000ULL * 1000 * 1000) + ts.tv_nsec;
 }
-#else
+#  else
 // Non-glibc & Go always use the regular function.
 u64 MonotonicNanoTime() {
   timespec ts;
   clock_gettime(CLOCK_MONOTONIC, &ts);
   return (u64)ts.tv_sec * (1000ULL * 1000 * 1000) + ts.tv_nsec;
 }
-#endif  // SANITIZER_GLIBC && !SANITIZER_GO
+#  endif  // SANITIZER_GLIBC && !SANITIZER_GO
 
 void ReExec() {
   const char *pathname = "/proc/self/exe";
 
-#if SANITIZER_NETBSD
+#  if SANITIZER_FREEBSD
+  for (const auto *aux = __elf_aux_vector; aux->a_type != AT_NULL; aux++) {
+    if (aux->a_type == AT_EXECPATH) {
+      pathname = static_cast<const char *>(aux->a_un.a_ptr);
+      break;
+    }
+  }
+#  elif SANITIZER_NETBSD
   static const int name[] = {
       CTL_KERN,
       KERN_PROC_ARGS,
@@ -957,14 +979,14 @@ void ReExec() {
   len = sizeof(path);
   if (internal_sysctl(name, ARRAY_SIZE(name), path, &len, NULL, 0) != -1)
     pathname = path;
-#elif SANITIZER_SOLARIS
+#  elif SANITIZER_SOLARIS
   pathname = getexecname();
   CHECK_NE(pathname, NULL);
-#elif SANITIZER_USE_GETAUXVAL
+#  elif SANITIZER_USE_GETAUXVAL
   // Calling execve with /proc/self/exe sets that as $EXEC_ORIGIN. Binaries that
   // rely on that will fail to load shared libraries. Query AT_EXECFN instead.
   pathname = reinterpret_cast<const char *>(getauxval(AT_EXECFN));
-#endif
+#  endif
 
   uptr rv = internal_execve(pathname, GetArgv(), GetEnviron());
   int rverrno;
@@ -986,9 +1008,8 @@ void UnmapFromTo(uptr from, uptr to) {
 }
 
 uptr MapDynamicShadow(uptr shadow_size_bytes, uptr shadow_scale,
-                      uptr min_shadow_base_alignment,
-                      UNUSED uptr &high_mem_end) {
-  const uptr granularity = GetMmapGranularity();
+                      uptr min_shadow_base_alignment, UNUSED uptr &high_mem_end,
+                      uptr granularity) {
   const uptr alignment =
       Max<uptr>(granularity << shadow_scale, 1ULL << min_shadow_base_alignment);
   const uptr left_padding =
@@ -1016,14 +1037,14 @@ static uptr MmapSharedNoReserve(uptr addr, uptr size) {
 
 static uptr MremapCreateAlias(uptr base_addr, uptr alias_addr,
                               uptr alias_size) {
-#if SANITIZER_LINUX
+#  if SANITIZER_LINUX
   return internal_mremap(reinterpret_cast<void *>(base_addr), 0, alias_size,
                          MREMAP_MAYMOVE | MREMAP_FIXED,
                          reinterpret_cast<void *>(alias_addr));
-#else
+#  else
   CHECK(false && "mremap is not supported outside of Linux");
   return 0;
-#endif
+#  endif
 }
 
 static void CreateAliases(uptr start_addr, uptr alias_size, uptr num_aliases) {
@@ -1068,12 +1089,12 @@ uptr MapDynamicShadowAndAliases(uptr shadow_size, uptr alias_size,
 }
 
 void InitializePlatformCommonFlags(CommonFlags *cf) {
-#if SANITIZER_ANDROID
+#  if SANITIZER_ANDROID
   if (&__libc_get_static_tls_bounds == nullptr)
     cf->detect_leaks = false;
-#endif
+#  endif
 }
 
-} // namespace __sanitizer
+}  // namespace __sanitizer
 
 #endif
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_linux_s390.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_linux_s390.cpp
index 74db831b0a..8523b540f2 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_linux_s390.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_linux_s390.cpp
@@ -15,14 +15,14 @@
 
 #if SANITIZER_LINUX && SANITIZER_S390
 
-#include <dlfcn.h>
-#include <errno.h>
-#include <sys/syscall.h>
-#include <sys/utsname.h>
-#include <unistd.h>
+#  include <dlfcn.h>
+#  include <errno.h>
+#  include <sys/syscall.h>
+#  include <sys/utsname.h>
+#  include <unistd.h>
 
-#include "sanitizer_libc.h"
-#include "sanitizer_linux.h"
+#  include "sanitizer_libc.h"
+#  include "sanitizer_linux.h"
 
 namespace __sanitizer {
 
@@ -37,22 +37,19 @@ uptr internal_mmap(void *addr, uptr length, int prot, int flags, int fd,
     unsigned long fd;
     unsigned long offset;
   } params = {
-    (unsigned long)addr,
-    (unsigned long)length,
-    (unsigned long)prot,
-    (unsigned long)flags,
-    (unsigned long)fd,
-# ifdef __s390x__
-    (unsigned long)offset,
-# else
+      (unsigned long)addr,   (unsigned long)length, (unsigned long)prot,
+      (unsigned long)flags,  (unsigned long)fd,
+#  ifdef __s390x__
+      (unsigned long)offset,
+#  else
     (unsigned long)(offset / 4096),
-# endif
+#  endif
   };
-# ifdef __s390x__
+#  ifdef __s390x__
   return syscall(__NR_mmap, &params);
-# else
+#  else
   return syscall(__NR_mmap2, &params);
-# endif
+#  endif
 }
 
 uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
@@ -63,58 +60,54 @@ uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
   }
   CHECK_EQ(0, (uptr)child_stack % 16);
   // Minimum frame size.
-#ifdef __s390x__
+#  ifdef __s390x__
   child_stack = (char *)child_stack - 160;
-#else
+#  else
   child_stack = (char *)child_stack - 96;
-#endif
+#  endif
   // Terminate unwind chain.
   ((unsigned long *)child_stack)[0] = 0;
   // And pass parameters.
   ((unsigned long *)child_stack)[1] = (uptr)fn;
   ((unsigned long *)child_stack)[2] = (uptr)arg;
   register uptr res __asm__("r2");
-  register void *__cstack      __asm__("r2") = child_stack;
-  register long __flags        __asm__("r3") = flags;
-  register int * __ptidptr     __asm__("r4") = parent_tidptr;
-  register int * __ctidptr     __asm__("r5") = child_tidptr;
-  register void * __newtls     __asm__("r6") = newtls;
+  register void *__cstack __asm__("r2") = child_stack;
+  register long __flags __asm__("r3") = flags;
+  register int *__ptidptr __asm__("r4") = parent_tidptr;
+  register int *__ctidptr __asm__("r5") = child_tidptr;
+  register void *__newtls __asm__("r6") = newtls;
 
   __asm__ __volatile__(
-                       /* Clone. */
-                       "svc    %1\n"
-
-                       /* if (%r2 != 0)
-                        *   return;
-                        */
-#ifdef __s390x__
-                       "cghi   %%r2, 0\n"
-#else
-                       "chi    %%r2, 0\n"
-#endif
-                       "jne    1f\n"
-
-                       /* Call "fn(arg)". */
-#ifdef __s390x__
-                       "lmg    %%r1, %%r2, 8(%%r15)\n"
-#else
-                       "lm     %%r1, %%r2, 4(%%r15)\n"
-#endif
-                       "basr   %%r14, %%r1\n"
-
-                       /* Call _exit(%r2). */
-                       "svc %2\n"
-
-                       /* Return to parent. */
-                     "1:\n"
-                       : "=r" (res)
-                       : "i"(__NR_clone), "i"(__NR_exit),
-                         "r"(__cstack),
-                         "r"(__flags),
-                         "r"(__ptidptr),
-                         "r"(__ctidptr),
-                         "r"(__newtls)
-                       : "memory", "cc");
+      /* Clone. */
+      "svc    %1\n"
+
+  /* if (%r2 != 0)
+   *   return;
+   */
+#  ifdef __s390x__
+      "cghi   %%r2, 0\n"
+#  else
+      "chi    %%r2, 0\n"
+#  endif
+      "jne    1f\n"
+
+  /* Call "fn(arg)". */
+#  ifdef __s390x__
+      "lmg    %%r1, %%r2, 8(%%r15)\n"
+#  else
+      "lm     %%r1, %%r2, 4(%%r15)\n"
+#  endif
+      "basr   %%r14, %%r1\n"
+
+      /* Call _exit(%r2). */
+      "svc %2\n"
+
+      /* Return to parent. */
+      "1:\n"
+      : "=r"(res)
+      : "i"(__NR_clone), "i"(__NR_exit), "r"(__cstack), "r"(__flags),
+        "r"(__ptidptr), "r"(__ctidptr), "r"(__newtls)
+      : "memory", "cc");
   if (res >= (uptr)-4095) {
     errno = -res;
     return -1;
@@ -122,7 +115,7 @@ uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
   return res;
 }
 
-#if SANITIZER_S390_64
+#  if SANITIZER_S390_64
 static bool FixedCVE_2016_2143() {
   // Try to determine if the running kernel has a fix for CVE-2016-2143,
   // return false if in doubt (better safe than sorry).  Distros may want to
@@ -137,20 +130,20 @@ static bool FixedCVE_2016_2143() {
   // At least first 2 should be matched.
   if (ptr[0] != '.')
     return false;
-  minor = internal_simple_strtoll(ptr+1, &ptr, 10);
+  minor = internal_simple_strtoll(ptr + 1, &ptr, 10);
   // Third is optional.
   if (ptr[0] == '.')
-    patch = internal_simple_strtoll(ptr+1, &ptr, 10);
+    patch = internal_simple_strtoll(ptr + 1, &ptr, 10);
   if (major < 3) {
     if (major == 2 && minor == 6 && patch == 32 && ptr[0] == '-' &&
         internal_strstr(ptr, ".el6")) {
       // Check RHEL6
-      int r1 = internal_simple_strtoll(ptr+1, &ptr, 10);
-      if (r1 >= 657) // 2.6.32-657.el6 or later
+      int r1 = internal_simple_strtoll(ptr + 1, &ptr, 10);
+      if (r1 >= 657)  // 2.6.32-657.el6 or later
         return true;
       if (r1 == 642 && ptr[0] == '.') {
-        int r2 = internal_simple_strtoll(ptr+1, &ptr, 10);
-        if (r2 >= 9) // 2.6.32-642.9.1.el6 or later
+        int r2 = internal_simple_strtoll(ptr + 1, &ptr, 10);
+        if (r2 >= 9)  // 2.6.32-642.9.1.el6 or later
           return true;
       }
     }
@@ -166,12 +159,12 @@ static bool FixedCVE_2016_2143() {
     if (minor == 10 && patch == 0 && ptr[0] == '-' &&
         internal_strstr(ptr, ".el7")) {
       // Check RHEL7
-      int r1 = internal_simple_strtoll(ptr+1, &ptr, 10);
-      if (r1 >= 426) // 3.10.0-426.el7 or later
+      int r1 = internal_simple_strtoll(ptr + 1, &ptr, 10);
+      if (r1 >= 426)  // 3.10.0-426.el7 or later
         return true;
       if (r1 == 327 && ptr[0] == '.') {
-        int r2 = internal_simple_strtoll(ptr+1, &ptr, 10);
-        if (r2 >= 27) // 3.10.0-327.27.1.el7 or later
+        int r2 = internal_simple_strtoll(ptr + 1, &ptr, 10);
+        if (r2 >= 27)  // 3.10.0-327.27.1.el7 or later
           return true;
       }
     }
@@ -187,8 +180,8 @@ static bool FixedCVE_2016_2143() {
     if (minor == 4 && patch == 0 && ptr[0] == '-' &&
         internal_strstr(buf.version, "Ubuntu")) {
       // Check Ubuntu 16.04
-      int r1 = internal_simple_strtoll(ptr+1, &ptr, 10);
-      if (r1 >= 13) // 4.4.0-13 or later
+      int r1 = internal_simple_strtoll(ptr + 1, &ptr, 10);
+      if (r1 >= 13)  // 4.4.0-13 or later
         return true;
     }
     // Otherwise, OK if 4.5+.
@@ -211,18 +204,19 @@ void AvoidCVE_2016_2143() {
   if (GetEnv("SANITIZER_IGNORE_CVE_2016_2143"))
     return;
   Report(
-    "ERROR: Your kernel seems to be vulnerable to CVE-2016-2143.  Using ASan,\n"
-    "MSan, TSan, DFSan or LSan with such kernel can and will crash your\n"
-    "machine, or worse.\n"
-    "\n"
-    "If you are certain your kernel is not vulnerable (you have compiled it\n"
-    "yourself, or are using an unrecognized distribution kernel), you can\n"
-    "override this safety check by exporting SANITIZER_IGNORE_CVE_2016_2143\n"
-    "with any value.\n");
+      "ERROR: Your kernel seems to be vulnerable to CVE-2016-2143.  Using "
+      "ASan,\n"
+      "MSan, TSan, DFSan or LSan with such kernel can and will crash your\n"
+      "machine, or worse.\n"
+      "\n"
+      "If you are certain your kernel is not vulnerable (you have compiled it\n"
+      "yourself, or are using an unrecognized distribution kernel), you can\n"
+      "override this safety check by exporting SANITIZER_IGNORE_CVE_2016_2143\n"
+      "with any value.\n");
   Die();
 }
-#endif
+#  endif
 
-} // namespace __sanitizer
+}  // namespace __sanitizer
 
-#endif // SANITIZER_LINUX && SANITIZER_S390
+#endif  // SANITIZER_LINUX && SANITIZER_S390
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_mac.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_mac.cpp
index 24e3d11125..8ebe37d649 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_mac.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_mac.cpp
@@ -1188,8 +1188,8 @@ uptr GetMaxVirtualAddress() {
 }
 
 uptr MapDynamicShadow(uptr shadow_size_bytes, uptr shadow_scale,
-                      uptr min_shadow_base_alignment, uptr &high_mem_end) {
-  const uptr granularity = GetMmapGranularity();
+                      uptr min_shadow_base_alignment, uptr &high_mem_end,
+                      uptr granularity) {
   const uptr alignment =
       Max<uptr>(granularity << shadow_scale, 1ULL << min_shadow_base_alignment);
   const uptr left_padding =
@@ -1372,8 +1372,8 @@ void DumpProcessMap() {
   for (uptr i = 0; i < modules.size(); ++i) {
     char uuid_str[128];
     FormatUUID(uuid_str, sizeof(uuid_str), modules[i].uuid());
-    Printf("0x%zx-0x%zx %s (%s) %s\n", modules[i].base_address(),
-           modules[i].max_address(), modules[i].full_name(),
+    Printf("%p-%p %s (%s) %s\n", (void *)modules[i].base_address(),
+           (void *)modules[i].max_address(), modules[i].full_name(),
            ModuleArchToString(modules[i].arch()), uuid_str);
   }
   Printf("End of module map.\n");
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_mallinfo.h b/zig/lib/tsan/sanitizer_common/sanitizer_mallinfo.h
index 4e58c02df8..1c07e68e55 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_mallinfo.h
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_mallinfo.h
@@ -31,6 +31,10 @@ struct __sanitizer_struct_mallinfo {
   int v[10];
 };
 
+struct __sanitizer_struct_mallinfo2 {
+  uptr v[10];
+};
+
 #endif
 
 }  // namespace __sanitizer
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_malloc_mac.inc b/zig/lib/tsan/sanitizer_common/sanitizer_malloc_mac.inc
index fe76b3f8aa..6343eb284a 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_malloc_mac.inc
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_malloc_mac.inc
@@ -123,7 +123,7 @@ INTERCEPTOR(void, malloc_set_zone_name, malloc_zone_t *zone, const char *name) {
   COMMON_MALLOC_ENTER();
   InternalScopedString new_name;
   if (name && zone->introspect == sanitizer_zone.introspect) {
-    new_name.append(COMMON_MALLOC_ZONE_NAME "-%s", name);
+    new_name.AppendF(COMMON_MALLOC_ZONE_NAME "-%s", name);
     name = new_name.data();
   }
 
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_mutex.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_mutex.cpp
index 40fe566612..97085e895a 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_mutex.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_mutex.cpp
@@ -212,8 +212,10 @@ struct InternalDeadlockDetector {
     return initialized > 0;
   }
 };
-
-static THREADLOCAL InternalDeadlockDetector deadlock_detector;
+// This variable is used by the __tls_get_addr interceptor, so cannot use the
+// global-dynamic TLS model, as that would result in crashes.
+__attribute__((tls_model("initial-exec"))) static THREADLOCAL
+    InternalDeadlockDetector deadlock_detector;
 
 void CheckedMutex::LockImpl(uptr pc) { deadlock_detector.Lock(type_, pc); }
 
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_placement_new.h b/zig/lib/tsan/sanitizer_common/sanitizer_placement_new.h
index 1ceb8b9092..c9b917b453 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_placement_new.h
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_placement_new.h
@@ -17,8 +17,6 @@
 
 #include "sanitizer_internal_defs.h"
 
-inline void *operator new(__sanitizer::operator_new_size_type sz, void *p) {
-  return p;
-}
+inline void *operator new(__sanitizer::usize sz, void *p) { return p; }
 
 #endif  // SANITIZER_PLACEMENT_NEW_H
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_platform.h b/zig/lib/tsan/sanitizer_common/sanitizer_platform.h
index 764996e573..57966403c9 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_platform.h
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_platform.h
@@ -260,6 +260,17 @@
 #  define SANITIZER_ARM64 0
 #endif
 
+#if SANITIZER_WINDOWS64 && SANITIZER_ARM64
+#  define SANITIZER_WINDOWS_ARM64 1
+#  define SANITIZER_WINDOWS_x64 0
+#elif SANITIZER_WINDOWS64 && !SANITIZER_ARM64
+#  define SANITIZER_WINDOWS_ARM64 0
+#  define SANITIZER_WINDOWS_x64 1
+#else
+#  define SANITIZER_WINDOWS_ARM64 0
+#  define SANITIZER_WINDOWS_x64 0
+#endif
+
 #if SANITIZER_SOLARIS && SANITIZER_WORDSIZE == 32
 #  define SANITIZER_SOLARIS32 1
 #else
@@ -284,7 +295,8 @@
 // For such platforms build this code with -DSANITIZER_CAN_USE_ALLOCATOR64=0 or
 // change the definition of SANITIZER_CAN_USE_ALLOCATOR64 here.
 #ifndef SANITIZER_CAN_USE_ALLOCATOR64
-#  if SANITIZER_RISCV64 || SANITIZER_IOS
+#  if (SANITIZER_RISCV64 && !SANITIZER_FUCHSIA && !SANITIZER_LINUX) || \
+      SANITIZER_IOS || SANITIZER_DRIVERKIT
 #    define SANITIZER_CAN_USE_ALLOCATOR64 0
 #  elif defined(__mips64) || defined(__hexagon__)
 #    define SANITIZER_CAN_USE_ALLOCATOR64 0
@@ -303,7 +315,15 @@
 #    define SANITIZER_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 40)
 #  endif
 #elif SANITIZER_RISCV64
-#  define SANITIZER_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 38)
+// FIXME: Rather than hardcoding the VMA here, we should rely on
+// GetMaxUserVirtualAddress(). This will require some refactoring though since
+// many places either hardcode some value or SANITIZER_MMAP_RANGE_SIZE is
+// assumed to be some constant integer.
+#  if SANITIZER_FUCHSIA
+#    define SANITIZER_MMAP_RANGE_SIZE (1ULL << 38)
+#  else
+#    define SANITIZER_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 56)
+#  endif
 #elif defined(__aarch64__)
 #  if SANITIZER_APPLE
 #    if SANITIZER_OSX || SANITIZER_IOSSIM
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_platform_interceptors.h b/zig/lib/tsan/sanitizer_common/sanitizer_platform_interceptors.h
index c740778b62..7d7ed9bc07 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_platform_interceptors.h
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_platform_interceptors.h
@@ -191,7 +191,8 @@
 
 #define SANITIZER_INTERCEPT_PREADV \
   (SI_FREEBSD || SI_NETBSD || SI_LINUX_NOT_ANDROID)
-#define SANITIZER_INTERCEPT_PWRITEV SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_PWRITEV \
+  (SI_FREEBSD || SI_NETBSD || SI_LINUX_NOT_ANDROID)
 #define SANITIZER_INTERCEPT_PREADV64 SI_GLIBC
 #define SANITIZER_INTERCEPT_PWRITEV64 SI_GLIBC
 
@@ -301,7 +302,8 @@
 #define SANITIZER_INTERCEPT_CANONICALIZE_FILE_NAME (SI_GLIBC || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_CONFSTR \
   (SI_FREEBSD || SI_NETBSD || SI_MAC || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
-#define SANITIZER_INTERCEPT_SCHED_GETAFFINITY SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_SCHED_GETAFFINITY \
+  (SI_LINUX_NOT_ANDROID || SI_FREEBSD)
 #define SANITIZER_INTERCEPT_SCHED_GETPARAM SI_LINUX_NOT_ANDROID || SI_SOLARIS
 #define SANITIZER_INTERCEPT_STRERROR SI_POSIX
 #define SANITIZER_INTERCEPT_STRERROR_R SI_POSIX
@@ -462,7 +464,7 @@
   (SI_LINUX || SI_MAC || SI_WINDOWS || SI_FREEBSD || SI_NETBSD || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_RECV_RECVFROM SI_POSIX
 #define SANITIZER_INTERCEPT_SEND_SENDTO SI_POSIX
-#define SANITIZER_INTERCEPT_EVENTFD_READ_WRITE SI_LINUX
+#define SANITIZER_INTERCEPT_EVENTFD_READ_WRITE (SI_LINUX || SI_FREEBSD)
 
 #define SI_STAT_LINUX (SI_LINUX && __GLIBC_PREREQ(2, 33))
 #define SANITIZER_INTERCEPT_STAT                                        \
@@ -575,12 +577,12 @@
 #define SANITIZER_INTERCEPT_SL_INIT (SI_FREEBSD || SI_NETBSD)
 
 #define SANITIZER_INTERCEPT_GETRANDOM \
-  ((SI_LINUX && __GLIBC_PREREQ(2, 25)) || SI_FREEBSD)
+  ((SI_LINUX && __GLIBC_PREREQ(2, 25)) || SI_FREEBSD || SI_SOLARIS)
 #define SANITIZER_INTERCEPT___CXA_ATEXIT SI_NETBSD
 #define SANITIZER_INTERCEPT_ATEXIT SI_NETBSD
 #define SANITIZER_INTERCEPT_PTHREAD_ATFORK SI_NETBSD
 #define SANITIZER_INTERCEPT_GETENTROPY \
-  ((SI_LINUX && __GLIBC_PREREQ(2, 25)) || SI_FREEBSD)
+  ((SI_LINUX && __GLIBC_PREREQ(2, 25)) || SI_FREEBSD || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_QSORT \
   (SI_POSIX && !SI_IOSSIM && !SI_WATCHOS && !SI_TVOS && !SI_ANDROID)
 #define SANITIZER_INTERCEPT_QSORT_R SI_GLIBC
@@ -594,9 +596,11 @@
 #define SANITIZER_INTERCEPT___XUNAME SI_FREEBSD
 #define SANITIZER_INTERCEPT_FLOPEN SI_FREEBSD
 #define SANITIZER_INTERCEPT_PROCCTL SI_FREEBSD
-#define SANITIZER_INTERCEPT_HEXDUMP SI_FREEBSD
 #define SANITIZER_INTERCEPT_ARGP_PARSE SI_GLIBC
 #define SANITIZER_INTERCEPT_CPUSET_GETAFFINITY SI_FREEBSD
+// FIXME: also available from musl 1.2.5
+#define SANITIZER_INTERCEPT_PREADV2 (SI_LINUX && __GLIBC_PREREQ(2, 26))
+#define SANITIZER_INTERCEPT_PWRITEV2 (SI_LINUX && __GLIBC_PREREQ(2, 26))
 
 // This macro gives a way for downstream users to override the above
 // interceptor macros irrespective of the platform they are on. They have
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_platform_limits_freebsd.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_platform_limits_freebsd.cpp
index 38f968d533..4940062eea 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_platform_limits_freebsd.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_platform_limits_freebsd.cpp
@@ -475,6 +475,8 @@ CHECK_TYPE_SIZE(nfds_t);
 CHECK_TYPE_SIZE(sigset_t);
 
 COMPILER_CHECK(sizeof(__sanitizer_sigaction) == sizeof(struct sigaction));
+COMPILER_CHECK(sizeof(__sanitizer_siginfo) == sizeof(siginfo_t));
+CHECK_SIZE_AND_OFFSET(siginfo_t, si_value);
 // Can't write checks for sa_handler and sa_sigaction due to them being
 // preprocessor macros.
 CHECK_STRUCT_SIZE_AND_OFFSET(sigaction, sa_mask);
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_platform_limits_freebsd.h b/zig/lib/tsan/sanitizer_common/sanitizer_platform_limits_freebsd.h
index b119f05900..8ce73f206f 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_platform_limits_freebsd.h
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_platform_limits_freebsd.h
@@ -301,11 +301,29 @@ struct __sanitizer_sigset_t {
 
 typedef __sanitizer_sigset_t __sanitizer_kernel_sigset_t;
 
+union __sanitizer_sigval {
+  int sival_int;
+  void *sival_ptr;
+};
+
 struct __sanitizer_siginfo {
-  // The size is determined by looking at sizeof of real siginfo_t on linux.
-  u64 opaque[128 / sizeof(u64)];
+  int si_signo;
+  int si_errno;
+  int si_code;
+  pid_t si_pid;
+  u32 si_uid;
+  int si_status;
+  void *si_addr;
+  union __sanitizer_sigval si_value;
+#  if SANITIZER_WORDSIZE == 64
+  char data[40];
+#  else
+  char data[32];
+#  endif
 };
 
+typedef __sanitizer_siginfo __sanitizer_siginfo_t;
+
 using __sanitizer_sighandler_ptr = void (*)(int sig);
 using __sanitizer_sigactionhandler_ptr = void (*)(int sig,
                                                   __sanitizer_siginfo *siginfo,
@@ -726,6 +744,8 @@ struct __sanitizer_cpuset {
 
 typedef struct __sanitizer_cpuset __sanitizer_cpuset_t;
 extern unsigned struct_cpuset_sz;
+
+typedef unsigned long long __sanitizer_eventfd_t;
 }  // namespace __sanitizer
 
 #  define CHECK_TYPE_SIZE(TYPE) \
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_platform_limits_openbsd.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_platform_limits_openbsd.cpp
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_platform_limits_openbsd.h b/zig/lib/tsan/sanitizer_common/sanitizer_platform_limits_openbsd.h
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_platform_limits_posix.h b/zig/lib/tsan/sanitizer_common/sanitizer_platform_limits_posix.h
index 58244c9944..34bfef1f7e 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_platform_limits_posix.h
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_platform_limits_posix.h
@@ -523,6 +523,7 @@ typedef long __sanitizer_clock_t;
 
 #if SANITIZER_LINUX
 typedef int __sanitizer_clockid_t;
+typedef unsigned long long __sanitizer_eventfd_t;
 #endif
 
 #if SANITIZER_LINUX
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_posix.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_posix.cpp
index 8d2c5b2cef..7d7d575431 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_posix.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_posix.cpp
@@ -54,12 +54,12 @@ void *MmapOrDie(uptr size, const char *mem_type, bool raw_report) {
   return (void *)res;
 }
 
-void UnmapOrDie(void *addr, uptr size) {
+void UnmapOrDie(void *addr, uptr size, bool raw_report) {
   if (!addr || !size) return;
   uptr res = internal_munmap(addr, size);
   int reserrno;
   if (UNLIKELY(internal_iserror(res, &reserrno)))
-    ReportMunmapFailureAndDie(addr, size, reserrno);
+    ReportMunmapFailureAndDie(addr, size, reserrno, raw_report);
   DecreaseTotalMmap(size);
 }
 
@@ -85,8 +85,8 @@ void *MmapAlignedOrDieOnFatalError(uptr size, uptr alignment,
   CHECK(IsPowerOfTwo(size));
   CHECK(IsPowerOfTwo(alignment));
   uptr map_size = size + alignment;
-  // mmap maps entire pages and rounds up map_size needs to be a an integral 
-  // number of pages. 
+  // mmap maps entire pages and rounds up map_size needs to be a an integral
+  // number of pages.
   // We need to be aware of this size for calculating end and for unmapping
   // fragments before and after the alignment region.
   map_size = RoundUpTo(map_size, GetPageSizeCached());
@@ -130,8 +130,8 @@ static void *MmapFixedImpl(uptr fixed_addr, uptr size, bool tolerate_enomem,
     if (tolerate_enomem && reserrno == ENOMEM)
       return nullptr;
     char mem_type[40];
-    internal_snprintf(mem_type, sizeof(mem_type), "memory at address 0x%zx",
-                      fixed_addr);
+    internal_snprintf(mem_type, sizeof(mem_type), "memory at address %p",
+                      (void *)fixed_addr);
     ReportMmapFailureAndDie(size, mem_type, "allocate", reserrno);
   }
   IncreaseTotalMmap(size);
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_posix.h b/zig/lib/tsan/sanitizer_common/sanitizer_posix.h
index c5811dffea..14617e4771 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_posix.h
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_posix.h
@@ -74,21 +74,21 @@ int internal_sysctlbyname(const char *sname, void *oldp, uptr *oldlenp,
 // These functions call appropriate pthread_ functions directly, bypassing
 // the interceptor. They are weak and may not be present in some tools.
 SANITIZER_WEAK_ATTRIBUTE
-int real_pthread_create(void *th, void *attr, void *(*callback)(void *),
-                        void *param);
+int internal_pthread_create(void *th, void *attr, void *(*callback)(void *),
+                            void *param);
 SANITIZER_WEAK_ATTRIBUTE
-int real_pthread_join(void *th, void **ret);
-
-#define DEFINE_REAL_PTHREAD_FUNCTIONS                                          \
-  namespace __sanitizer {                                                      \
-  int real_pthread_create(void *th, void *attr, void *(*callback)(void *),     \
-                          void *param) {                                       \
-    return REAL(pthread_create)(th, attr, callback, param);                    \
-  }                                                                            \
-  int real_pthread_join(void *th, void **ret) {                                \
-    return REAL(pthread_join(th, ret));                                        \
-  }                                                                            \
-  }  // namespace __sanitizer
+int internal_pthread_join(void *th, void **ret);
+
+#  define DEFINE_INTERNAL_PTHREAD_FUNCTIONS                               \
+    namespace __sanitizer {                                               \
+    int internal_pthread_create(void *th, void *attr,                     \
+                                void *(*callback)(void *), void *param) { \
+      return REAL(pthread_create)(th, attr, callback, param);             \
+    }                                                                     \
+    int internal_pthread_join(void *th, void **ret) {                     \
+      return REAL(pthread_join(th, ret));                                 \
+    }                                                                     \
+    }  // namespace __sanitizer
 
 int internal_pthread_attr_getstack(void *attr, void **addr, uptr *size);
 
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_posix_libcdep.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_posix_libcdep.cpp
index e88e654eec..9ffb36f812 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_posix_libcdep.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_posix_libcdep.cpp
@@ -91,12 +91,12 @@ static rlim_t getlim(int res) {
 
 static void setlim(int res, rlim_t lim) {
   struct rlimit rlim;
-  if (getrlimit(res, const_cast<struct rlimit *>(&rlim))) {
+  if (getrlimit(res, &rlim)) {
     Report("ERROR: %s getrlimit() failed %d\n", SanitizerToolName, errno);
     Die();
   }
   rlim.rlim_cur = lim;
-  if (setrlimit(res, const_cast<struct rlimit *>(&rlim))) {
+  if (setrlimit(res, &rlim)) {
     Report("ERROR: %s setrlimit() failed %d\n", SanitizerToolName, errno);
     Die();
   }
@@ -104,7 +104,27 @@ static void setlim(int res, rlim_t lim) {
 
 void DisableCoreDumperIfNecessary() {
   if (common_flags()->disable_coredump) {
-    setlim(RLIMIT_CORE, 0);
+    rlimit rlim;
+    CHECK_EQ(0, getrlimit(RLIMIT_CORE, &rlim));
+    // On Linux, if the kernel.core_pattern sysctl starts with a '|' (i.e. it
+    // is being piped to a coredump handler such as systemd-coredumpd), the
+    // kernel ignores RLIMIT_CORE (since we aren't creating a file in the file
+    // system) except for the magic value of 1, which disables coredumps when
+    // piping. 1 byte is too small for any kind of valid core dump, so it
+    // also disables coredumps if kernel.core_pattern creates files directly.
+    // While most piped coredump handlers do respect the crashing processes'
+    // RLIMIT_CORE, this is notable not the case for Debian's systemd-coredump
+    // due to a local patch that changes sysctl.d/50-coredump.conf to ignore
+    // the specified limit and instead use RLIM_INFINITY.
+    //
+    // The alternative to using RLIMIT_CORE=1 would be to use prctl() with the
+    // PR_SET_DUMPABLE flag, however that also prevents ptrace(), so makes it
+    // impossible to attach a debugger.
+    //
+    // Note: we use rlim_max in the Min() call here since that is the upper
+    // limit for what can be set without getting an EINVAL error.
+    rlim.rlim_cur = Min<rlim_t>(SANITIZER_LINUX ? 1 : 0, rlim.rlim_max);
+    CHECK_EQ(0, setrlimit(RLIMIT_CORE, &rlim));
   }
 }
 
@@ -307,9 +327,10 @@ static bool MmapFixed(uptr fixed_addr, uptr size, int additional_flags,
                 MAP_PRIVATE | MAP_FIXED | additional_flags | MAP_ANON, name);
   int reserrno;
   if (internal_iserror(p, &reserrno)) {
-    Report("ERROR: %s failed to "
-           "allocate 0x%zx (%zd) bytes at address %zx (errno: %d)\n",
-           SanitizerToolName, size, size, fixed_addr, reserrno);
+    Report(
+        "ERROR: %s failed to "
+        "allocate 0x%zx (%zd) bytes at address %p (errno: %d)\n",
+        SanitizerToolName, size, size, (void *)fixed_addr, reserrno);
     return false;
   }
   IncreaseTotalMmap(size);
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_printf.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_printf.cpp
index 3a9e366d2d..24511720bd 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_printf.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_printf.cpp
@@ -54,7 +54,7 @@ static int AppendNumber(char **buff, const char *buff_end, u64 absolute_value,
   uptr num_buffer[kMaxLen];
   int pos = 0;
   do {
-    RAW_CHECK_MSG((uptr)pos < kMaxLen, "AppendNumber buffer overflow");
+    RAW_CHECK_MSG((uptr)pos < kMaxLen, "AppendNumber buffer overflow",);
     num_buffer[pos++] = absolute_value % base;
     absolute_value /= base;
   } while (absolute_value > 0);
@@ -337,7 +337,14 @@ int internal_snprintf(char *buffer, uptr length, const char *format, ...) {
   return needed_length;
 }
 
-void InternalScopedString::append(const char *format, ...) {
+void InternalScopedString::Append(const char *str) {
+  uptr prev_len = length();
+  uptr str_len = internal_strlen(str);
+  buffer_.resize(prev_len + str_len + 1);
+  internal_memcpy(buffer_.data() + prev_len, str, str_len + 1);
+}
+
+void InternalScopedString::AppendF(const char *format, ...) {
   uptr prev_len = length();
 
   while (true) {
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_procmaps_bsd.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_procmaps_bsd.cpp
index 36a82c4ac9..ee3fd5b0a8 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_procmaps_bsd.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_procmaps_bsd.cpp
@@ -13,9 +13,6 @@
 #include "sanitizer_platform.h"
 #if SANITIZER_FREEBSD || SANITIZER_NETBSD
 #include "sanitizer_common.h"
-#if SANITIZER_FREEBSD
-#include "sanitizer_freebsd.h"
-#endif
 #include "sanitizer_procmaps.h"
 
 // clang-format off
@@ -29,29 +26,35 @@
 
 #include <limits.h>
 
-// Fix 'kinfo_vmentry' definition on FreeBSD prior v9.2 in 32-bit mode.
-#if SANITIZER_FREEBSD && (SANITIZER_WORDSIZE == 32)
-#include <osreldate.h>
-#if __FreeBSD_version <= 902001 // v9.2
-#define kinfo_vmentry xkinfo_vmentry
-#endif
-#endif
-
 namespace __sanitizer {
 
 #if SANITIZER_FREEBSD
 void GetMemoryProfile(fill_profile_f cb, uptr *stats) {
-  const int Mib[] = {
-    CTL_KERN,
-    KERN_PROC,
-    KERN_PROC_PID,
-    getpid()
-  }; 
-
-  struct kinfo_proc InfoProc;
-  uptr Len = sizeof(InfoProc);
-  CHECK_EQ(internal_sysctl(Mib, ARRAY_SIZE(Mib), nullptr, (uptr *)&InfoProc, &Len, 0), 0);
-  cb(0, InfoProc.ki_rssize * GetPageSizeCached(), false, stats);
+  const int Mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, getpid()};
+
+  struct kinfo_proc *InfoProc;
+  uptr Len = sizeof(*InfoProc);
+  uptr Size = Len;
+  InfoProc = (struct kinfo_proc *)MmapOrDie(Size, "GetMemoryProfile()");
+  CHECK_EQ(
+      internal_sysctl(Mib, ARRAY_SIZE(Mib), nullptr, (uptr *)InfoProc, &Len, 0),
+      0);
+  cb(0, InfoProc->ki_rssize * GetPageSizeCached(), false, stats);
+  UnmapOrDie(InfoProc, Size, true);
+}
+#elif SANITIZER_NETBSD
+void GetMemoryProfile(fill_profile_f cb, uptr *stats) {
+  struct kinfo_proc2 *InfoProc;
+  uptr Len = sizeof(*InfoProc);
+  uptr Size = Len;
+  const int Mib[] = {CTL_KERN, KERN_PROC2, KERN_PROC_PID,
+                     getpid(), (int)Size,  1};
+  InfoProc = (struct kinfo_proc2 *)MmapOrDie(Size, "GetMemoryProfile()");
+  CHECK_EQ(
+      internal_sysctl(Mib, ARRAY_SIZE(Mib), nullptr, (uptr *)InfoProc, &Len, 0),
+      0);
+  cb(0, InfoProc->p_vm_rssize * GetPageSizeCached(), false, stats);
+  UnmapOrDie(InfoProc, Size, true);
 }
 #endif
 
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_procmaps_common.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_procmaps_common.cpp
index a7805ad1b0..7214a2b9ea 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_procmaps_common.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_procmaps_common.cpp
@@ -145,7 +145,7 @@ void MemoryMappingLayout::DumpListOfModules(
   }
 }
 
-#if SANITIZER_LINUX || SANITIZER_ANDROID || SANITIZER_SOLARIS || SANITIZER_NETBSD
+#if SANITIZER_LINUX || SANITIZER_ANDROID || SANITIZER_SOLARIS
 void GetMemoryProfile(fill_profile_f cb, uptr *stats) {
   char *smaps = nullptr;
   uptr smaps_cap = 0;
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_ptrauth.h b/zig/lib/tsan/sanitizer_common/sanitizer_ptrauth.h
index 5200354694..265a9925a1 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_ptrauth.h
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_ptrauth.h
@@ -9,31 +9,33 @@
 #ifndef SANITIZER_PTRAUTH_H
 #define SANITIZER_PTRAUTH_H
 
-#if __has_feature(ptrauth_calls)
-#include <ptrauth.h>
+#if __has_feature(ptrauth_intrinsics)
+#  include <ptrauth.h>
 #elif defined(__ARM_FEATURE_PAC_DEFAULT) && !defined(__APPLE__)
-inline unsigned long ptrauth_strip(void* __value, unsigned int __key) {
-  // On the stack the link register is protected with Pointer
-  // Authentication Code when compiled with -mbranch-protection.
-  // Let's stripping the PAC unconditionally because xpaclri is in
-  // the NOP space so will do nothing when it is not enabled or not available.
-  unsigned long ret;
-  asm volatile(
-      "mov x30, %1\n\t"
-      "hint #7\n\t"  // xpaclri
-      "mov %0, x30\n\t"
-      : "=r"(ret)
-      : "r"(__value)
-      : "x30");
-  return ret;
-}
-#define ptrauth_auth_data(__value, __old_key, __old_data) __value
-#define ptrauth_string_discriminator(__string) ((int)0)
+// On the stack the link register is protected with Pointer
+// Authentication Code when compiled with -mbranch-protection.
+// Let's stripping the PAC unconditionally because xpaclri is in
+// the NOP space so will do nothing when it is not enabled or not available.
+#  define ptrauth_strip(__value, __key) \
+    ({                                  \
+      __typeof(__value) ret;            \
+      asm volatile(                     \
+          "mov x30, %1\n\t"             \
+          "hint #7\n\t"                 \
+          "mov %0, x30\n\t"             \
+          "mov x30, xzr\n\t"            \
+          : "=r"(ret)                   \
+          : "r"(__value)                \
+          : "x30");                     \
+      ret;                              \
+    })
+#  define ptrauth_auth_data(__value, __old_key, __old_data) __value
+#  define ptrauth_string_discriminator(__string) ((int)0)
 #else
 // Copied from <ptrauth.h>
-#define ptrauth_strip(__value, __key) __value
-#define ptrauth_auth_data(__value, __old_key, __old_data) __value
-#define ptrauth_string_discriminator(__string) ((int)0)
+#  define ptrauth_strip(__value, __key) __value
+#  define ptrauth_auth_data(__value, __old_key, __old_data) __value
+#  define ptrauth_string_discriminator(__string) ((int)0)
 #endif
 
 #define STRIP_PAC_PC(pc) ((uptr)ptrauth_strip(pc, 0))
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_redefine_builtins.h b/zig/lib/tsan/sanitizer_common/sanitizer_redefine_builtins.h
index 6649ff5844..d24b179ef3 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_redefine_builtins.h
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_redefine_builtins.h
@@ -11,16 +11,19 @@
 //
 //===----------------------------------------------------------------------===//
 #ifndef SANITIZER_COMMON_NO_REDEFINE_BUILTINS
-#ifndef SANITIZER_REDEFINE_BUILTINS_H
-#define SANITIZER_REDEFINE_BUILTINS_H
+#  ifndef SANITIZER_REDEFINE_BUILTINS_H
+#    define SANITIZER_REDEFINE_BUILTINS_H
 
 // The asm hack only works with GCC and Clang.
-#if !defined(_WIN32)
+#    if !defined(_WIN32)
 
 asm("memcpy = __sanitizer_internal_memcpy");
 asm("memmove = __sanitizer_internal_memmove");
 asm("memset = __sanitizer_internal_memset");
 
+#      if defined(__cplusplus) && \
+          !defined(SANITIZER_COMMON_REDEFINE_BUILTINS_IN_STD)
+
 // The builtins should not be redefined in source files that make use of C++
 // standard libraries, in particular where C++STL headers with inline functions
 // are used. The redefinition in such cases would lead to ODR violations.
@@ -46,7 +49,8 @@ using unordered_set = Define_SANITIZER_COMMON_NO_REDEFINE_BUILTINS_in_cpp_file;
 using vector = Define_SANITIZER_COMMON_NO_REDEFINE_BUILTINS_in_cpp_file;
 }  // namespace std
 
-#endif  // !_WIN32
+#      endif  // __cpluplus
+#    endif    // !_WIN32
 
-#endif  // SANITIZER_REDEFINE_BUILTINS_H
-#endif  // SANITIZER_COMMON_NO_REDEFINE_BUILTINS
+#  endif  // SANITIZER_REDEFINE_BUILTINS_H
+#endif    // SANITIZER_COMMON_NO_REDEFINE_BUILTINS
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_ring_buffer.h b/zig/lib/tsan/sanitizer_common/sanitizer_ring_buffer.h
index f22e40cac2..6222a958b1 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_ring_buffer.h
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_ring_buffer.h
@@ -47,7 +47,9 @@ class RingBuffer {
   void push(T t) {
     *next_ = t;
     next_--;
-    // The condition below works only if sizeof(T) is divisible by sizeof(T*).
+    static_assert((sizeof(T) % sizeof(T *)) == 0,
+                  "The condition below works only if sizeof(T) is divisible by "
+                  "sizeof(T*).");
     if (next_ <= reinterpret_cast<T*>(&next_))
       next_ = last_;
   }
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_stack_store.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_stack_store.cpp
index 148470943b..c11df0ddfd 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_stack_store.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_stack_store.cpp
@@ -44,6 +44,9 @@ StackStore::Id StackStore::Store(const StackTrace &trace, uptr *pack) {
   uptr idx = 0;
   *pack = 0;
   uptr *stack_trace = Alloc(h.size + 1, &idx, pack);
+  // No more space.
+  if (stack_trace == nullptr)
+    return 0;
   *stack_trace = h.ToUptr();
   internal_memcpy(stack_trace + 1, trace.trace, h.size * sizeof(uptr));
   *pack += blocks_[GetBlockIdx(idx)].Stored(h.size + 1);
@@ -76,8 +79,10 @@ uptr *StackStore::Alloc(uptr count, uptr *idx, uptr *pack) {
     uptr block_idx = GetBlockIdx(start);
     uptr last_idx = GetBlockIdx(start + count - 1);
     if (LIKELY(block_idx == last_idx)) {
-      // Fits into the a single block.
-      CHECK_LT(block_idx, ARRAY_SIZE(blocks_));
+      // Fits into a single block.
+      // No more available blocks.  Indicate inability to allocate more memory.
+      if (block_idx >= ARRAY_SIZE(blocks_))
+        return nullptr;
       *idx = start;
       return blocks_[block_idx].GetOrCreate(this) + GetInBlockIdx(start);
     }
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_stackdepot.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_stackdepot.cpp
index a746d46219..3776e8c970 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_stackdepot.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_stackdepot.cpp
@@ -215,16 +215,16 @@ StackTrace StackDepotGet(u32 id) {
   return theDepot.Get(id);
 }
 
-void StackDepotLockAll() {
-  theDepot.LockAll();
+void StackDepotLockBeforeFork() {
+  theDepot.LockBeforeFork();
   compress_thread.LockAndStop();
   stackStore.LockAll();
 }
 
-void StackDepotUnlockAll() {
+void StackDepotUnlockAfterFork(bool fork_child) {
   stackStore.UnlockAll();
   compress_thread.Unlock();
-  theDepot.UnlockAll();
+  theDepot.UnlockAfterFork(fork_child);
 }
 
 void StackDepotPrintAll() {
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_stackdepot.h b/zig/lib/tsan/sanitizer_common/sanitizer_stackdepot.h
index cca6fd5346..82cf7578d0 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_stackdepot.h
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_stackdepot.h
@@ -39,8 +39,8 @@ StackDepotHandle StackDepotPut_WithHandle(StackTrace stack);
 // Retrieves a stored stack trace by the id.
 StackTrace StackDepotGet(u32 id);
 
-void StackDepotLockAll();
-void StackDepotUnlockAll();
+void StackDepotLockBeforeFork();
+void StackDepotUnlockAfterFork(bool fork_child);
 void StackDepotPrintAll();
 void StackDepotStopBackgroundThread();
 
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_stackdepotbase.h b/zig/lib/tsan/sanitizer_common/sanitizer_stackdepotbase.h
index 96d1ddc87f..279bc5de3b 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_stackdepotbase.h
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_stackdepotbase.h
@@ -52,8 +52,8 @@ class StackDepotBase {
     };
   }
 
-  void LockAll();
-  void UnlockAll();
+  void LockBeforeFork();
+  void UnlockAfterFork(bool fork_child);
   void PrintAll();
 
   void TestOnlyUnmap() {
@@ -160,18 +160,33 @@ StackDepotBase<Node, kReservedBits, kTabSizeLog>::Get(u32 id) {
 }
 
 template <class Node, int kReservedBits, int kTabSizeLog>
-void StackDepotBase<Node, kReservedBits, kTabSizeLog>::LockAll() {
-  for (int i = 0; i < kTabSize; ++i) {
-    lock(&tab[i]);
-  }
+void StackDepotBase<Node, kReservedBits, kTabSizeLog>::LockBeforeFork() {
+  // Do not lock hash table. It's very expensive, but it's not rely needed. The
+  // parent process will neither lock nor unlock. Child process risks to be
+  // deadlocked on already locked buckets. To avoid deadlock we will unlock
+  // every locked buckets in `UnlockAfterFork`. This may affect consistency of
+  // the hash table, but the only issue is a few items inserted by parent
+  // process will be not found by child, and the child may insert them again,
+  // wasting some space in `stackStore`.
+
+  // We still need to lock nodes.
+  nodes.Lock();
 }
 
 template <class Node, int kReservedBits, int kTabSizeLog>
-void StackDepotBase<Node, kReservedBits, kTabSizeLog>::UnlockAll() {
+void StackDepotBase<Node, kReservedBits, kTabSizeLog>::UnlockAfterFork(
+    bool fork_child) {
+  nodes.Unlock();
+
+  // Only unlock in child process to avoid deadlock. See `LockBeforeFork`.
+  if (!fork_child)
+    return;
+
   for (int i = 0; i < kTabSize; ++i) {
     atomic_uint32_t *p = &tab[i];
     uptr s = atomic_load(p, memory_order_relaxed);
-    unlock(p, s & kUnlockMask);
+    if (s & kLockMask)
+      unlock(p, s & kUnlockMask);
   }
 }
 
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_stacktrace_libcdep.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_stacktrace_libcdep.cpp
index 47983ee7ec..1a0e00d5d5 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_stacktrace_libcdep.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_stacktrace_libcdep.cpp
@@ -29,42 +29,43 @@ class StackTraceTextPrinter {
         frame_delimiter_(frame_delimiter),
         output_(output),
         dedup_token_(dedup_token),
-        symbolize_(RenderNeedsSymbolization(stack_trace_fmt)) {}
+        symbolize_(StackTracePrinter::GetOrInit()->RenderNeedsSymbolization(
+            stack_trace_fmt)) {}
 
   bool ProcessAddressFrames(uptr pc) {
-    SymbolizedStack *frames = symbolize_
-                                  ? Symbolizer::GetOrInit()->SymbolizePC(pc)
-                                  : SymbolizedStack::New(pc);
+    SymbolizedStackHolder symbolized_stack(
+        symbolize_ ? Symbolizer::GetOrInit()->SymbolizePC(pc)
+                   : SymbolizedStack::New(pc));
+    const SymbolizedStack *frames = symbolized_stack.get();
     if (!frames)
       return false;
 
-    for (SymbolizedStack *cur = frames; cur; cur = cur->next) {
+    for (const SymbolizedStack *cur = frames; cur; cur = cur->next) {
       uptr prev_len = output_->length();
-      RenderFrame(output_, stack_trace_fmt_, frame_num_++, cur->info.address,
-                  symbolize_ ? &cur->info : nullptr,
-                  common_flags()->symbolize_vs_style,
-                  common_flags()->strip_path_prefix);
+      StackTracePrinter::GetOrInit()->RenderFrame(
+          output_, stack_trace_fmt_, frame_num_++, cur->info.address,
+          symbolize_ ? &cur->info : nullptr, common_flags()->symbolize_vs_style,
+          common_flags()->strip_path_prefix);
 
       if (prev_len != output_->length())
-        output_->append("%c", frame_delimiter_);
+        output_->AppendF("%c", frame_delimiter_);
 
       ExtendDedupToken(cur);
     }
-    frames->ClearAll();
     return true;
   }
 
  private:
   // Extend the dedup token by appending a new frame.
-  void ExtendDedupToken(SymbolizedStack *stack) {
+  void ExtendDedupToken(const SymbolizedStack *stack) {
     if (!dedup_token_)
       return;
 
     if (dedup_frames_-- > 0) {
       if (dedup_token_->length())
-        dedup_token_->append("--");
-      if (stack->info.function != nullptr)
-        dedup_token_->append("%s", stack->info.function);
+        dedup_token_->Append("--");
+      if (stack->info.function)
+        dedup_token_->Append(stack->info.function);
     }
   }
 
@@ -98,7 +99,7 @@ void StackTrace::PrintTo(InternalScopedString *output) const {
                                 output, &dedup_token);
 
   if (trace == nullptr || size == 0) {
-    output->append("    <empty stack>\n\n");
+    output->Append("    <empty stack>\n\n");
     return;
   }
 
@@ -110,11 +111,11 @@ void StackTrace::PrintTo(InternalScopedString *output) const {
   }
 
   // Always add a trailing empty line after stack trace.
-  output->append("\n");
+  output->Append("\n");
 
   // Append deduplication token, if non-empty.
   if (dedup_token.length())
-    output->append("DEDUP_TOKEN: %s\n", dedup_token.data());
+    output->AppendF("DEDUP_TOKEN: %s\n", dedup_token.data());
 }
 
 uptr StackTrace::PrintTo(char *out_buf, uptr out_buf_size) const {
@@ -197,7 +198,7 @@ void __sanitizer_symbolize_pc(uptr pc, const char *fmt, char *out_buf,
   StackTraceTextPrinter printer(fmt, '\0', &output, nullptr);
   if (!printer.ProcessAddressFrames(pc)) {
     output.clear();
-    output.append("<can't symbolize>");
+    output.Append("<can't symbolize>");
   }
   CopyStringToBuffer(output, out_buf, out_buf_size);
 }
@@ -210,7 +211,8 @@ void __sanitizer_symbolize_global(uptr data_addr, const char *fmt,
   DataInfo DI;
   if (!Symbolizer::GetOrInit()->SymbolizeData(data_addr, &DI)) return;
   InternalScopedString data_desc;
-  RenderData(&data_desc, fmt, &DI, common_flags()->strip_path_prefix);
+  StackTracePrinter::GetOrInit()->RenderData(&data_desc, fmt, &DI,
+                                             common_flags()->strip_path_prefix);
   internal_strncpy(out_buf, data_desc.data(), out_buf_size);
   out_buf[out_buf_size - 1] = 0;
 }
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_stacktrace_printer.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_stacktrace_printer.cpp
index 45c480d225..5631d132da 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_stacktrace_printer.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_stacktrace_printer.cpp
@@ -12,13 +12,28 @@
 
 #include "sanitizer_stacktrace_printer.h"
 
+#include "sanitizer_common.h"
 #include "sanitizer_file.h"
 #include "sanitizer_flags.h"
 #include "sanitizer_fuchsia.h"
+#include "sanitizer_symbolizer_markup.h"
 
 namespace __sanitizer {
 
-const char *StripFunctionName(const char *function) {
+StackTracePrinter *StackTracePrinter::GetOrInit() {
+  static StackTracePrinter *stacktrace_printer;
+  static StaticSpinMutex init_mu;
+  SpinMutexLock l(&init_mu);
+  if (stacktrace_printer)
+    return stacktrace_printer;
+
+  stacktrace_printer = StackTracePrinter::NewStackTracePrinter();
+
+  CHECK(stacktrace_printer);
+  return stacktrace_printer;
+}
+
+const char *StackTracePrinter::StripFunctionName(const char *function) {
   if (!common_flags()->demangle)
     return function;
   if (!function)
@@ -47,6 +62,13 @@ const char *StripFunctionName(const char *function) {
 // sanitizer_symbolizer_markup.cpp implements these differently.
 #if !SANITIZER_SYMBOLIZER_MARKUP
 
+StackTracePrinter *StackTracePrinter::NewStackTracePrinter() {
+  if (common_flags()->enable_symbolizer_markup)
+    return new (GetGlobalLowLevelAllocator()) MarkupStackTracePrinter();
+
+  return new (GetGlobalLowLevelAllocator()) FormattedStackTracePrinter();
+}
+
 static const char *DemangleFunctionName(const char *function) {
   if (!common_flags()->demangle)
     return function;
@@ -130,20 +152,23 @@ static void MaybeBuildIdToBuffer(const AddressInfo &info, bool PrefixSpace,
                                  InternalScopedString *buffer) {
   if (info.uuid_size) {
     if (PrefixSpace)
-      buffer->append(" ");
-    buffer->append("(BuildId: ");
+      buffer->Append(" ");
+    buffer->Append("(BuildId: ");
     for (uptr i = 0; i < info.uuid_size; ++i) {
-      buffer->append("%02x", info.uuid[i]);
+      buffer->AppendF("%02x", info.uuid[i]);
     }
-    buffer->append(")");
+    buffer->Append(")");
   }
 }
 
 static const char kDefaultFormat[] = "    #%n %p %F %L";
 
-void RenderFrame(InternalScopedString *buffer, const char *format, int frame_no,
-                 uptr address, const AddressInfo *info, bool vs_style,
-                 const char *strip_path_prefix) {
+void FormattedStackTracePrinter::RenderFrame(InternalScopedString *buffer,
+                                             const char *format, int frame_no,
+                                             uptr address,
+                                             const AddressInfo *info,
+                                             bool vs_style,
+                                             const char *strip_path_prefix) {
   // info will be null in the case where symbolization is not needed for the
   // given format. This ensures that the code below will get a hard failure
   // rather than print incorrect information in case RenderNeedsSymbolization
@@ -154,56 +179,56 @@ void RenderFrame(InternalScopedString *buffer, const char *format, int frame_no,
     format = kDefaultFormat;
   for (const char *p = format; *p != '\0'; p++) {
     if (*p != '%') {
-      buffer->append("%c", *p);
+      buffer->AppendF("%c", *p);
       continue;
     }
     p++;
     switch (*p) {
     case '%':
-      buffer->append("%%");
+      buffer->Append("%");
       break;
     // Frame number and all fields of AddressInfo structure.
     case 'n':
-      buffer->append("%u", frame_no);
+      buffer->AppendF("%u", frame_no);
       break;
     case 'p':
-      buffer->append("0x%zx", address);
+      buffer->AppendF("%p", (void *)address);
       break;
     case 'm':
-      buffer->append("%s", StripPathPrefix(info->module, strip_path_prefix));
+      buffer->AppendF("%s", StripPathPrefix(info->module, strip_path_prefix));
       break;
     case 'o':
-      buffer->append("0x%zx", info->module_offset);
+      buffer->AppendF("0x%zx", info->module_offset);
       break;
     case 'b':
       MaybeBuildIdToBuffer(*info, /*PrefixSpace=*/false, buffer);
       break;
     case 'f':
-      buffer->append("%s",
-                     DemangleFunctionName(StripFunctionName(info->function)));
+      buffer->AppendF("%s",
+                      DemangleFunctionName(StripFunctionName(info->function)));
       break;
     case 'q':
-      buffer->append("0x%zx", info->function_offset != AddressInfo::kUnknown
-                                  ? info->function_offset
-                                  : 0x0);
+      buffer->AppendF("0x%zx", info->function_offset != AddressInfo::kUnknown
+                                   ? info->function_offset
+                                   : 0x0);
       break;
     case 's':
-      buffer->append("%s", StripPathPrefix(info->file, strip_path_prefix));
+      buffer->AppendF("%s", StripPathPrefix(info->file, strip_path_prefix));
       break;
     case 'l':
-      buffer->append("%d", info->line);
+      buffer->AppendF("%d", info->line);
       break;
     case 'c':
-      buffer->append("%d", info->column);
+      buffer->AppendF("%d", info->column);
       break;
     // Smarter special cases.
     case 'F':
       // Function name and offset, if file is unknown.
       if (info->function) {
-        buffer->append("in %s",
-                       DemangleFunctionName(StripFunctionName(info->function)));
+        buffer->AppendF(
+            "in %s", DemangleFunctionName(StripFunctionName(info->function)));
         if (!info->file && info->function_offset != AddressInfo::kUnknown)
-          buffer->append("+0x%zx", info->function_offset);
+          buffer->AppendF("+0x%zx", info->function_offset);
       }
       break;
     case 'S':
@@ -224,7 +249,7 @@ void RenderFrame(InternalScopedString *buffer, const char *format, int frame_no,
         MaybeBuildIdToBuffer(*info, /*PrefixSpace=*/true, buffer);
 #endif
       } else {
-        buffer->append("(<unknown module>)");
+        buffer->Append("(<unknown module>)");
       }
       break;
     case 'M':
@@ -239,18 +264,18 @@ void RenderFrame(InternalScopedString *buffer, const char *format, int frame_no,
         MaybeBuildIdToBuffer(*info, /*PrefixSpace=*/true, buffer);
 #endif
       } else {
-        buffer->append("(%p)", (void *)address);
+        buffer->AppendF("(%p)", (void *)address);
       }
       break;
     default:
       Report("Unsupported specifier in stack frame format: %c (%p)!\n", *p,
-             (void *)p);
+             (const void *)p);
       Die();
     }
   }
 }
 
-bool RenderNeedsSymbolization(const char *format) {
+bool FormattedStackTracePrinter::RenderNeedsSymbolization(const char *format) {
   if (0 == internal_strcmp(format, "DEFAULT"))
     format = kDefaultFormat;
   for (const char *p = format; *p != '\0'; p++) {
@@ -273,30 +298,32 @@ bool RenderNeedsSymbolization(const char *format) {
   return false;
 }
 
-void RenderData(InternalScopedString *buffer, const char *format,
-                const DataInfo *DI, const char *strip_path_prefix) {
+void FormattedStackTracePrinter::RenderData(InternalScopedString *buffer,
+                                            const char *format,
+                                            const DataInfo *DI,
+                                            const char *strip_path_prefix) {
   for (const char *p = format; *p != '\0'; p++) {
     if (*p != '%') {
-      buffer->append("%c", *p);
+      buffer->AppendF("%c", *p);
       continue;
     }
     p++;
     switch (*p) {
       case '%':
-        buffer->append("%%");
+        buffer->Append("%");
         break;
       case 's':
-        buffer->append("%s", StripPathPrefix(DI->file, strip_path_prefix));
+        buffer->AppendF("%s", StripPathPrefix(DI->file, strip_path_prefix));
         break;
       case 'l':
-        buffer->append("%zu", DI->line);
+        buffer->AppendF("%zu", DI->line);
         break;
       case 'g':
-        buffer->append("%s", DI->name);
+        buffer->AppendF("%s", DI->name);
         break;
       default:
         Report("Unsupported specifier in stack frame format: %c (%p)!\n", *p,
-               (void *)p);
+               (const void *)p);
         Die();
     }
   }
@@ -304,33 +331,35 @@ void RenderData(InternalScopedString *buffer, const char *format,
 
 #endif  // !SANITIZER_SYMBOLIZER_MARKUP
 
-void RenderSourceLocation(InternalScopedString *buffer, const char *file,
-                          int line, int column, bool vs_style,
-                          const char *strip_path_prefix) {
+void StackTracePrinter::RenderSourceLocation(InternalScopedString *buffer,
+                                             const char *file, int line,
+                                             int column, bool vs_style,
+                                             const char *strip_path_prefix) {
   if (vs_style && line > 0) {
-    buffer->append("%s(%d", StripPathPrefix(file, strip_path_prefix), line);
+    buffer->AppendF("%s(%d", StripPathPrefix(file, strip_path_prefix), line);
     if (column > 0)
-      buffer->append(",%d", column);
-    buffer->append(")");
+      buffer->AppendF(",%d", column);
+    buffer->Append(")");
     return;
   }
 
-  buffer->append("%s", StripPathPrefix(file, strip_path_prefix));
+  buffer->AppendF("%s", StripPathPrefix(file, strip_path_prefix));
   if (line > 0) {
-    buffer->append(":%d", line);
+    buffer->AppendF(":%d", line);
     if (column > 0)
-      buffer->append(":%d", column);
+      buffer->AppendF(":%d", column);
   }
 }
 
-void RenderModuleLocation(InternalScopedString *buffer, const char *module,
-                          uptr offset, ModuleArch arch,
-                          const char *strip_path_prefix) {
-  buffer->append("(%s", StripPathPrefix(module, strip_path_prefix));
+void StackTracePrinter::RenderModuleLocation(InternalScopedString *buffer,
+                                             const char *module, uptr offset,
+                                             ModuleArch arch,
+                                             const char *strip_path_prefix) {
+  buffer->AppendF("(%s", StripPathPrefix(module, strip_path_prefix));
   if (arch != kModuleArchUnknown) {
-    buffer->append(":%s", ModuleArchToString(arch));
+    buffer->AppendF(":%s", ModuleArchToString(arch));
   }
-  buffer->append("+0x%zx)", offset);
+  buffer->AppendF("+0x%zx)", offset);
 }
 
 } // namespace __sanitizer
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_stacktrace_printer.h b/zig/lib/tsan/sanitizer_common/sanitizer_stacktrace_printer.h
index bf2755a2e8..e39cb89157 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_stacktrace_printer.h
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_stacktrace_printer.h
@@ -13,61 +13,102 @@
 #define SANITIZER_STACKTRACE_PRINTER_H
 
 #include "sanitizer_common.h"
+#include "sanitizer_internal_defs.h"
 #include "sanitizer_symbolizer.h"
 
 namespace __sanitizer {
 
-// Strip interceptor prefixes from function name.
-const char *StripFunctionName(const char *function);
-
-// Render the contents of "info" structure, which represents the contents of
-// stack frame "frame_no" and appends it to the "buffer". "format" is a
-// string with placeholders, which is copied to the output with
-// placeholders substituted with the contents of "info". For example,
-// format string
-//   "  frame %n: function %F at %S"
-// will be turned into
-//   "  frame 10: function foo::bar() at my/file.cc:10"
-// You may additionally pass "strip_path_prefix" to strip prefixes of paths to
-// source files and modules.
-// Here's the full list of available placeholders:
-//   %% - represents a '%' character;
-//   %n - frame number (copy of frame_no);
-//   %p - PC in hex format;
-//   %m - path to module (binary or shared object);
-//   %o - offset in the module in hex format;
-//   %f - function name;
-//   %q - offset in the function in hex format (*if available*);
-//   %s - path to source file;
-//   %l - line in the source file;
-//   %c - column in the source file;
-//   %F - if function is known to be <foo>, prints "in <foo>", possibly
-//        followed by the offset in this function, but only if source file
-//        is unknown;
-//   %S - prints file/line/column information;
-//   %L - prints location information: file/line/column, if it is known, or
-//        module+offset if it is known, or (<unknown module>) string.
-//   %M - prints module basename and offset, if it is known, or PC.
-void RenderFrame(InternalScopedString *buffer, const char *format, int frame_no,
-                 uptr address, const AddressInfo *info, bool vs_style,
-                 const char *strip_path_prefix = "");
-
-bool RenderNeedsSymbolization(const char *format);
-
-void RenderSourceLocation(InternalScopedString *buffer, const char *file,
-                          int line, int column, bool vs_style,
-                          const char *strip_path_prefix);
-
-void RenderModuleLocation(InternalScopedString *buffer, const char *module,
-                          uptr offset, ModuleArch arch,
-                          const char *strip_path_prefix);
-
-// Same as RenderFrame, but for data section (global variables).
-// Accepts %s, %l from above.
-// Also accepts:
-//   %g - name of the global variable.
-void RenderData(InternalScopedString *buffer, const char *format,
-                const DataInfo *DI, const char *strip_path_prefix = "");
+// StacktracePrinter is an interface that is implemented by
+// classes that can perform rendering of the different parts
+// of a stacktrace.
+class StackTracePrinter {
+ public:
+  static StackTracePrinter *GetOrInit();
+
+  // Strip interceptor prefixes from function name.
+  const char *StripFunctionName(const char *function);
+
+  virtual void RenderFrame(InternalScopedString *buffer, const char *format,
+                           int frame_no, uptr address, const AddressInfo *info,
+                           bool vs_style, const char *strip_path_prefix = "") {
+    // Should be pure virtual, but we can't depend on __cxa_pure_virtual.
+    UNIMPLEMENTED();
+  }
+
+  virtual bool RenderNeedsSymbolization(const char *format) {
+    // Should be pure virtual, but we can't depend on __cxa_pure_virtual.
+    UNIMPLEMENTED();
+  }
+
+  void RenderSourceLocation(InternalScopedString *buffer, const char *file,
+                            int line, int column, bool vs_style,
+                            const char *strip_path_prefix);
+
+  void RenderModuleLocation(InternalScopedString *buffer, const char *module,
+                            uptr offset, ModuleArch arch,
+                            const char *strip_path_prefix);
+  virtual void RenderData(InternalScopedString *buffer, const char *format,
+                          const DataInfo *DI,
+                          const char *strip_path_prefix = "") {
+    // Should be pure virtual, but we can't depend on __cxa_pure_virtual.
+    UNIMPLEMENTED();
+  }
+
+ private:
+  // To be called from StackTracePrinter::GetOrInit
+  static StackTracePrinter *NewStackTracePrinter();
+
+ protected:
+  ~StackTracePrinter() {}
+};
+
+class FormattedStackTracePrinter : public StackTracePrinter {
+ public:
+  // Render the contents of "info" structure, which represents the contents of
+  // stack frame "frame_no" and appends it to the "buffer". "format" is a
+  // string with placeholders, which is copied to the output with
+  // placeholders substituted with the contents of "info". For example,
+  // format string
+  //   "  frame %n: function %F at %S"
+  // will be turned into
+  //   "  frame 10: function foo::bar() at my/file.cc:10"
+  // You may additionally pass "strip_path_prefix" to strip prefixes of paths to
+  // source files and modules.
+  // Here's the full list of available placeholders:
+  //   %% - represents a '%' character;
+  //   %n - frame number (copy of frame_no);
+  //   %p - PC in hex format;
+  //   %m - path to module (binary or shared object);
+  //   %o - offset in the module in hex format;
+  //   %f - function name;
+  //   %q - offset in the function in hex format (*if available*);
+  //   %s - path to source file;
+  //   %l - line in the source file;
+  //   %c - column in the source file;
+  //   %F - if function is known to be <foo>, prints "in <foo>", possibly
+  //        followed by the offset in this function, but only if source file
+  //        is unknown;
+  //   %S - prints file/line/column information;
+  //   %L - prints location information: file/line/column, if it is known, or
+  //        module+offset if it is known, or (<unknown module>) string.
+  //   %M - prints module basename and offset, if it is known, or PC.
+  void RenderFrame(InternalScopedString *buffer, const char *format,
+                   int frame_no, uptr address, const AddressInfo *info,
+                   bool vs_style, const char *strip_path_prefix = "") override;
+
+  bool RenderNeedsSymbolization(const char *format) override;
+
+  // Same as RenderFrame, but for data section (global variables).
+  // Accepts %s, %l from above.
+  // Also accepts:
+  //   %g - name of the global variable.
+  void RenderData(InternalScopedString *buffer, const char *format,
+                  const DataInfo *DI,
+                  const char *strip_path_prefix = "") override;
+
+ protected:
+  ~FormattedStackTracePrinter() {}
+};
 
 }  // namespace __sanitizer
 
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_stacktrace_sparc.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_stacktrace_sparc.cpp
index a2000798a3..74f435287a 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_stacktrace_sparc.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_stacktrace_sparc.cpp
@@ -58,17 +58,16 @@ void BufferedStackTrace::UnwindFast(uptr pc, uptr bp, uptr stack_top,
   // Avoid infinite loop when frame == frame[0] by using frame > prev_frame.
   while (IsValidFrame(bp, stack_top, bottom) && IsAligned(bp, sizeof(uhwptr)) &&
          size < max_depth) {
-    uhwptr pc1 = ((uhwptr *)bp)[15];
+    // %o7 contains the address of the call instruction and not the
+    // return address, so we need to compensate.
+    uhwptr pc1 = GetNextInstructionPc(((uhwptr *)bp)[15]);
     // Let's assume that any pointer in the 0th page is invalid and
     // stop unwinding here.  If we're adding support for a platform
     // where this isn't true, we need to reconsider this check.
     if (pc1 < kPageSize)
       break;
-    if (pc1 != pc) {
-      // %o7 contains the address of the call instruction and not the
-      // return address, so we need to compensate.
-      trace_buffer[size++] = GetNextInstructionPc((uptr)pc1);
-    }
+    if (pc1 != pc)
+      trace_buffer[size++] = pc1;
     bottom = bp;
     bp = (uptr)((uhwptr *)bp)[14] + STACK_BIAS;
   }
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cpp
index 13b90ce9bf..526a71c398 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cpp
@@ -257,8 +257,8 @@ static void TracerThreadDieCallback() {
 static void TracerThreadSignalHandler(int signum, __sanitizer_siginfo *siginfo,
                                       void *uctx) {
   SignalContext ctx(siginfo, uctx);
-  Printf("Tracer caught signal %d: addr=0x%zx pc=0x%zx sp=0x%zx\n", signum,
-         ctx.addr, ctx.pc, ctx.sp);
+  Printf("Tracer caught signal %d: addr=%p pc=%p sp=%p\n", signum,
+         (void *)ctx.addr, (void *)ctx.pc, (void *)ctx.sp);
   ThreadSuspender *inst = thread_suspender_instance;
   if (inst) {
     if (signum == SIGABRT)
@@ -565,7 +565,7 @@ PtraceRegistersStatus SuspendedThreadsListLinux::GetRegistersAndSP(
   constexpr uptr uptr_sz = sizeof(uptr);
   int pterrno;
 #ifdef ARCH_IOVEC_FOR_GETREGSET
-  auto append = [&](uptr regset) {
+  auto AppendF = [&](uptr regset) {
     uptr size = buffer->size();
     // NT_X86_XSTATE requires 64bit alignment.
     uptr size_up = RoundUpTo(size, 8 / uptr_sz);
@@ -596,11 +596,11 @@ PtraceRegistersStatus SuspendedThreadsListLinux::GetRegistersAndSP(
   };
 
   buffer->clear();
-  bool fail = !append(NT_PRSTATUS);
+  bool fail = !AppendF(NT_PRSTATUS);
   if (!fail) {
     // Accept the first available and do not report errors.
     for (uptr regs : kExtraRegs)
-      if (regs && append(regs))
+      if (regs && AppendF(regs))
         break;
   }
 #else
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_stoptheworld_netbsd_libcdep.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_stoptheworld_netbsd_libcdep.cpp
index 701db72619..58a0cfdbf9 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_stoptheworld_netbsd_libcdep.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_stoptheworld_netbsd_libcdep.cpp
@@ -158,8 +158,8 @@ static void TracerThreadDieCallback() {
 static void TracerThreadSignalHandler(int signum, __sanitizer_siginfo *siginfo,
                                       void *uctx) {
   SignalContext ctx(siginfo, uctx);
-  Printf("Tracer caught signal %d: addr=0x%zx pc=0x%zx sp=0x%zx\n", signum,
-         ctx.addr, ctx.pc, ctx.sp);
+  Printf("Tracer caught signal %d: addr=%p pc=%p sp=%p\n", signum,
+         (void *)ctx.addr, (void *)ctx.pc, (void *)ctx.sp);
   ThreadSuspender *inst = thread_suspender_instance;
   if (inst) {
     if (signum == SIGABRT)
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_suppressions.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_suppressions.cpp
index f3818526ba..62ebbb38fe 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_suppressions.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_suppressions.cpp
@@ -86,7 +86,7 @@ void SuppressionContext::ParseFromFile(const char *filename) {
   }
 
   Parse(file_contents);
-  UnmapOrDie(file_contents, contents_size);
+  UnmapOrDie(file_contents, buffer_size);
 }
 
 bool SuppressionContext::Match(const char *str, const char *type,
@@ -138,7 +138,10 @@ void SuppressionContext::Parse(const char *str) {
         }
       }
       if (type == suppression_types_num_) {
-        Printf("%s: failed to parse suppressions\n", SanitizerToolName);
+        Printf("%s: failed to parse suppressions.\n", SanitizerToolName);
+        Printf("Supported suppression types are:\n");
+        for (type = 0; type < suppression_types_num_; type++)
+          Printf("- %s\n", suppression_types_[type]);
         Die();
       }
       Suppression s;
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer.cpp
index d3cffaa6ee..519f768f89 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer.cpp
@@ -10,6 +10,8 @@
 // run-time libraries.
 //===----------------------------------------------------------------------===//
 
+#include <errno.h>
+
 #include "sanitizer_allocator_internal.h"
 #include "sanitizer_common.h"
 #include "sanitizer_internal_defs.h"
@@ -128,7 +130,7 @@ Symbolizer::Symbolizer(IntrusiveList<SymbolizerTool> tools)
       start_hook_(0), end_hook_(0) {}
 
 Symbolizer::SymbolizerScope::SymbolizerScope(const Symbolizer *sym)
-    : sym_(sym) {
+    : sym_(sym), errno_(errno) {
   if (sym_->start_hook_)
     sym_->start_hook_();
 }
@@ -136,6 +138,7 @@ Symbolizer::SymbolizerScope::SymbolizerScope(const Symbolizer *sym)
 Symbolizer::SymbolizerScope::~SymbolizerScope() {
   if (sym_->end_hook_)
     sym_->end_hook_();
+  errno = errno_;
 }
 
 }  // namespace __sanitizer
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer.h b/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer.h
index bad4761e34..16ef2f2fd7 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer.h
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer.h
@@ -64,6 +64,26 @@ struct SymbolizedStack {
   SymbolizedStack();
 };
 
+class SymbolizedStackHolder {
+  SymbolizedStack *Stack;
+
+  void clear() {
+    if (Stack)
+      Stack->ClearAll();
+  }
+
+ public:
+  explicit SymbolizedStackHolder(SymbolizedStack *Stack = nullptr)
+      : Stack(Stack) {}
+  ~SymbolizedStackHolder() { clear(); }
+  void reset(SymbolizedStack *S = nullptr) {
+    if (Stack != S)
+      clear();
+    Stack = S;
+  }
+  const SymbolizedStack *get() const { return Stack; }
+};
+
 // For now, DataInfo is used to describe global variable.
 struct DataInfo {
   // Owns all the string members. Storage for them is
@@ -136,7 +156,7 @@ class Symbolizer final {
 
   // Release internal caches (if any).
   void Flush();
-  // Attempts to demangle the provided C++ mangled name.
+  // Attempts to demangle the provided C++ mangled name. Never returns nullptr.
   const char *Demangle(const char *name);
 
   // Allow user to install hooks that would be called before/after Symbolizer
@@ -154,6 +174,8 @@ class Symbolizer final {
 
   void InvalidateModuleList();
 
+  const ListOfModules &GetRefreshedListOfModules();
+
  private:
   // GetModuleNameAndOffsetForPC has to return a string to the caller.
   // Since the corresponding module might get unloaded later, we should create
@@ -187,7 +209,7 @@ class Symbolizer final {
   // If stale, need to reload the modules before looking up addresses.
   bool modules_fresh_;
 
-  // Platform-specific default demangler, must not return nullptr.
+  // Platform-specific default demangler, returns nullptr on failure.
   const char *PlatformDemangle(const char *name);
 
   static Symbolizer *symbolizer_;
@@ -212,6 +234,7 @@ class Symbolizer final {
     ~SymbolizerScope();
    private:
     const Symbolizer *sym_;
+    int errno_;  // Backup errno in case symbolizer change the value.
   };
 };
 
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_internal.h b/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_internal.h
index 3ec4d80105..2345aee985 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_internal.h
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_internal.h
@@ -160,6 +160,15 @@ void ParseSymbolizePCOutput(const char *str, SymbolizedStack *res);
 // Used by LLVMSymbolizer and InternalSymbolizer.
 void ParseSymbolizeDataOutput(const char *str, DataInfo *info);
 
+// Parses repeated strings in the following format:
+//   <function_name>
+//   <var_name>
+//   <file_name>:<line_number>[:<column_number>]
+//   [<frame_offset>|??] [<size>|??] [<tag_offset>|??]
+// Used by LLVMSymbolizer and InternalSymbolizer.
+void ParseSymbolizeFrameOutput(const char *str,
+                               InternalMmapVector<LocalInfo> *locals);
+
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_SYMBOLIZER_INTERNAL_H
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_libbacktrace.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_libbacktrace.cpp
index cc02c77bcc..d78dab9348 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_libbacktrace.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_libbacktrace.cpp
@@ -199,7 +199,7 @@ static char *DemangleAlloc(const char *name, bool always_alloc) {
 #endif
   if (always_alloc)
     return internal_strdup(name);
-  return 0;
+  return nullptr;
 }
 
 const char *LibbacktraceSymbolizer::Demangle(const char *name) {
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_libcdep.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_libcdep.cpp
index a6f82ced20..74458028ae 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_libcdep.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_libcdep.cpp
@@ -117,7 +117,7 @@ bool Symbolizer::SymbolizeData(uptr addr, DataInfo *info) {
       return true;
     }
   }
-  return true;
+  return false;
 }
 
 bool Symbolizer::SymbolizeFrame(uptr addr, FrameInfo *info) {
@@ -133,7 +133,7 @@ bool Symbolizer::SymbolizeFrame(uptr addr, FrameInfo *info) {
       return true;
     }
   }
-  return true;
+  return false;
 }
 
 bool Symbolizer::GetModuleNameAndOffsetForPC(uptr pc, const char **module_name,
@@ -159,13 +159,16 @@ void Symbolizer::Flush() {
 }
 
 const char *Symbolizer::Demangle(const char *name) {
+  CHECK(name);
   Lock l(&mu_);
   for (auto &tool : tools_) {
     SymbolizerScope sym_scope(this);
     if (const char *demangled = tool.Demangle(name))
       return demangled;
   }
-  return PlatformDemangle(name);
+  if (const char *demangled = PlatformDemangle(name))
+    return demangled;
+  return name;
 }
 
 bool Symbolizer::FindModuleNameAndOffsetForAddress(uptr address,
@@ -188,6 +191,13 @@ void Symbolizer::RefreshModules() {
   modules_fresh_ = true;
 }
 
+const ListOfModules &Symbolizer::GetRefreshedListOfModules() {
+  if (!modules_fresh_)
+    RefreshModules();
+
+  return modules_;
+}
+
 static const LoadedModule *SearchForModule(const ListOfModules &modules,
                                            uptr address) {
   for (uptr i = 0; i < modules.size(); i++) {
@@ -382,8 +392,8 @@ void ParseSymbolizeDataOutput(const char *str, DataInfo *info) {
   str = ExtractUptr(str, "\n", &info->line);
 }
 
-static void ParseSymbolizeFrameOutput(const char *str,
-                                      InternalMmapVector<LocalInfo> *locals) {
+void ParseSymbolizeFrameOutput(const char *str,
+                               InternalMmapVector<LocalInfo> *locals) {
   if (internal_strncmp(str, "??", 2) == 0)
     return;
 
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_mac.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_mac.cpp
index a9c958b2d1..f1cc0b5e1e 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_mac.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_mac.cpp
@@ -42,7 +42,8 @@ bool DlAddrSymbolizer::SymbolizePC(uptr addr, SymbolizedStack *stack) {
   }
 
   const char *demangled = DemangleSwiftAndCXX(info.dli_sname);
-  if (!demangled) return false;
+  if (!demangled)
+    demangled = info.dli_sname;
   stack->info.function = internal_strdup(demangled);
   return true;
 }
@@ -52,6 +53,8 @@ bool DlAddrSymbolizer::SymbolizeData(uptr addr, DataInfo *datainfo) {
   int result = dladdr((const void *)addr, &info);
   if (!result) return false;
   const char *demangled = DemangleSwiftAndCXX(info.dli_sname);
+  if (!demangled)
+    demangled = info.dli_sname;
   datainfo->name = internal_strdup(demangled);
   datainfo->start = (uptr)info.dli_saddr;
   return true;
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_markup.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_markup.cpp
index c8c10de10d..31d91ef3c7 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_markup.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_markup.cpp
@@ -8,143 +8,155 @@
 //
 // This file is shared between various sanitizers' runtime libraries.
 //
-// Implementation of offline markup symbolizer.
+// This generic support for offline symbolizing is based on the
+// Fuchsia port.  We don't do any actual symbolization per se.
+// Instead, we emit text containing raw addresses and raw linkage
+// symbol names, embedded in Fuchsia's symbolization markup format.
+// See the spec at:
+// https://llvm.org/docs/SymbolizerMarkupFormat.html
 //===----------------------------------------------------------------------===//
 
-#include "sanitizer_platform.h"
-#if SANITIZER_SYMBOLIZER_MARKUP
-
-#if SANITIZER_FUCHSIA
-#include "sanitizer_symbolizer_fuchsia.h"
-#  endif
+#include "sanitizer_symbolizer_markup.h"
 
-#  include <limits.h>
-#  include <unwind.h>
-
-#  include "sanitizer_stacktrace.h"
-#  include "sanitizer_symbolizer.h"
+#include "sanitizer_common.h"
+#include "sanitizer_symbolizer.h"
+#include "sanitizer_symbolizer_markup_constants.h"
 
 namespace __sanitizer {
 
-// This generic support for offline symbolizing is based on the
-// Fuchsia port.  We don't do any actual symbolization per se.
-// Instead, we emit text containing raw addresses and raw linkage
-// symbol names, embedded in Fuchsia's symbolization markup format.
-// Fuchsia's logging infrastructure emits enough information about
-// process memory layout that a post-processing filter can do the
-// symbolization and pretty-print the markup.  See the spec at:
-// https://fuchsia.googlesource.com/zircon/+/master/docs/symbolizer_markup.md
-
-// This is used by UBSan for type names, and by ASan for global variable names.
-// It's expected to return a static buffer that will be reused on each call.
-const char *Symbolizer::Demangle(const char *name) {
-  static char buffer[kFormatDemangleMax];
-  internal_snprintf(buffer, sizeof(buffer), kFormatDemangle, name);
-  return buffer;
+void MarkupStackTracePrinter::RenderData(InternalScopedString *buffer,
+                                         const char *format, const DataInfo *DI,
+                                         const char *strip_path_prefix) {
+  RenderContext(buffer);
+  buffer->AppendF(kFormatData, reinterpret_cast<void *>(DI->start));
 }
 
-// This is used mostly for suppression matching.  Making it work
-// would enable "interceptor_via_lib" suppressions.  It's also used
-// once in UBSan to say "in module ..." in a message that also
-// includes an address in the module, so post-processing can already
-// pretty-print that so as to indicate the module.
-bool Symbolizer::GetModuleNameAndOffsetForPC(uptr pc, const char **module_name,
-                                             uptr *module_address) {
+bool MarkupStackTracePrinter::RenderNeedsSymbolization(const char *format) {
   return false;
 }
 
-// This is mainly used by hwasan for online symbolization. This isn't needed
-// since hwasan can always just dump stack frames for offline symbolization.
-bool Symbolizer::SymbolizeFrame(uptr addr, FrameInfo *info) { return false; }
-
-// This is used in some places for suppression checking, which we
-// don't really support for Fuchsia.  It's also used in UBSan to
-// identify a PC location to a function name, so we always fill in
-// the function member with a string containing markup around the PC
-// value.
-// TODO(mcgrathr): Under SANITIZER_GO, it's currently used by TSan
-// to render stack frames, but that should be changed to use
-// RenderStackFrame.
-SymbolizedStack *Symbolizer::SymbolizePC(uptr addr) {
-  SymbolizedStack *s = SymbolizedStack::New(addr);
+// We don't support the stack_trace_format flag at all.
+void MarkupStackTracePrinter::RenderFrame(InternalScopedString *buffer,
+                                          const char *format, int frame_no,
+                                          uptr address, const AddressInfo *info,
+                                          bool vs_style,
+                                          const char *strip_path_prefix) {
+  CHECK(!RenderNeedsSymbolization(format));
+  RenderContext(buffer);
+  buffer->AppendF(kFormatFrame, frame_no, reinterpret_cast<void *>(address));
+}
+
+bool MarkupSymbolizerTool::SymbolizePC(uptr addr, SymbolizedStack *stack) {
   char buffer[kFormatFunctionMax];
-  internal_snprintf(buffer, sizeof(buffer), kFormatFunction, addr);
-  s->info.function = internal_strdup(buffer);
-  return s;
+  internal_snprintf(buffer, sizeof(buffer), kFormatFunction,
+                    reinterpret_cast<void *>(addr));
+  stack->info.function = internal_strdup(buffer);
+  return true;
 }
 
-// Always claim we succeeded, so that RenderDataInfo will be called.
-bool Symbolizer::SymbolizeData(uptr addr, DataInfo *info) {
+bool MarkupSymbolizerTool::SymbolizeData(uptr addr, DataInfo *info) {
   info->Clear();
   info->start = addr;
   return true;
 }
 
-// We ignore the format argument to __sanitizer_symbolize_global.
-void RenderData(InternalScopedString *buffer, const char *format,
-                const DataInfo *DI, const char *strip_path_prefix) {
-  buffer->append(kFormatData, DI->start);
+const char *MarkupSymbolizerTool::Demangle(const char *name) {
+  static char buffer[kFormatDemangleMax];
+  internal_snprintf(buffer, sizeof(buffer), kFormatDemangle, name);
+  return buffer;
 }
 
-bool RenderNeedsSymbolization(const char *format) { return false; }
-
-// We don't support the stack_trace_format flag at all.
-void RenderFrame(InternalScopedString *buffer, const char *format, int frame_no,
-                 uptr address, const AddressInfo *info, bool vs_style,
-                 const char *strip_path_prefix) {
-  CHECK(!RenderNeedsSymbolization(format));
-  buffer->append(kFormatFrame, frame_no, address);
+// Fuchsia's implementation of symbolizer markup doesn't need to emit contextual
+// elements at this point.
+// Fuchsia's logging infrastructure emits enough information about
+// process memory layout that a post-processing filter can do the
+// symbolization and pretty-print the markup.
+#if !SANITIZER_FUCHSIA
+
+static bool ModulesEq(const LoadedModule &module,
+                      const RenderedModule &renderedModule) {
+  return module.base_address() == renderedModule.base_address &&
+         internal_memcmp(module.uuid(), renderedModule.uuid,
+                         module.uuid_size()) == 0 &&
+         internal_strcmp(module.full_name(), renderedModule.full_name) == 0;
 }
 
-Symbolizer *Symbolizer::PlatformInit() {
-  return new (symbolizer_allocator_) Symbolizer({});
+static bool ModuleHasBeenRendered(
+    const LoadedModule &module,
+    const InternalMmapVectorNoCtor<RenderedModule> &renderedModules) {
+  for (const auto &renderedModule : renderedModules)
+    if (ModulesEq(module, renderedModule))
+      return true;
+
+  return false;
 }
 
-void Symbolizer::LateInitialize() { Symbolizer::GetOrInit(); }
-
-void StartReportDeadlySignal() {}
-void ReportDeadlySignal(const SignalContext &sig, u32 tid,
-                        UnwindSignalStackCallbackType unwind,
-                        const void *unwind_context) {}
-
-#if SANITIZER_CAN_SLOW_UNWIND
-struct UnwindTraceArg {
-  BufferedStackTrace *stack;
-  u32 max_depth;
-};
-
-_Unwind_Reason_Code Unwind_Trace(struct _Unwind_Context *ctx, void *param) {
-  UnwindTraceArg *arg = static_cast<UnwindTraceArg *>(param);
-  CHECK_LT(arg->stack->size, arg->max_depth);
-  uptr pc = _Unwind_GetIP(ctx);
-  if (pc < PAGE_SIZE) return _URC_NORMAL_STOP;
-  arg->stack->trace_buffer[arg->stack->size++] = pc;
-  return (arg->stack->size == arg->max_depth ? _URC_NORMAL_STOP
-                                             : _URC_NO_REASON);
+static void RenderModule(InternalScopedString *buffer,
+                         const LoadedModule &module, uptr moduleId) {
+  InternalScopedString buildIdBuffer;
+  for (uptr i = 0; i < module.uuid_size(); i++)
+    buildIdBuffer.AppendF("%02x", module.uuid()[i]);
+
+  buffer->AppendF(kFormatModule, moduleId, module.full_name(),
+                  buildIdBuffer.data());
+  buffer->Append("\n");
 }
 
-void BufferedStackTrace::UnwindSlow(uptr pc, u32 max_depth) {
-  CHECK_GE(max_depth, 2);
-  size = 0;
-  UnwindTraceArg arg = {this, Min(max_depth + 1, kStackTraceMax)};
-  _Unwind_Backtrace(Unwind_Trace, &arg);
-  CHECK_GT(size, 0);
-  // We need to pop a few frames so that pc is on top.
-  uptr to_pop = LocatePcInTrace(pc);
-  // trace_buffer[0] belongs to the current function so we always pop it,
-  // unless there is only 1 frame in the stack trace (1 frame is always better
-  // than 0!).
-  PopStackFrames(Min(to_pop, static_cast<uptr>(1)));
-  trace_buffer[0] = pc;
+static void RenderMmaps(InternalScopedString *buffer,
+                        const LoadedModule &module, uptr moduleId) {
+  InternalScopedString accessBuffer;
+
+  // All module mmaps are readable at least
+  for (const auto &range : module.ranges()) {
+    accessBuffer.Append("r");
+    if (range.writable)
+      accessBuffer.Append("w");
+    if (range.executable)
+      accessBuffer.Append("x");
+
+    //{{{mmap:%starting_addr:%size_in_hex:load:%moduleId:r%(w|x):%relative_addr}}}
+
+    // module.base_address == dlpi_addr
+    // range.beg == dlpi_addr + p_vaddr
+    // relative address == p_vaddr == range.beg - module.base_address
+    buffer->AppendF(kFormatMmap, reinterpret_cast<void *>(range.beg),
+                    range.end - range.beg, static_cast<int>(moduleId),
+                    accessBuffer.data(), range.beg - module.base_address());
+
+    buffer->Append("\n");
+    accessBuffer.clear();
+  }
 }
 
-void BufferedStackTrace::UnwindSlow(uptr pc, void *context, u32 max_depth) {
-  CHECK(context);
-  CHECK_GE(max_depth, 2);
-  UNREACHABLE("signal context doesn't exist");
+void MarkupStackTracePrinter::RenderContext(InternalScopedString *buffer) {
+  if (renderedModules_.size() == 0)
+    buffer->Append("{{{reset}}}\n");
+
+  const auto &modules = Symbolizer::GetOrInit()->GetRefreshedListOfModules();
+
+  for (const auto &module : modules) {
+    if (ModuleHasBeenRendered(module, renderedModules_))
+      continue;
+
+    // symbolizer markup id, used to refer to this modules from other contextual
+    // elements
+    uptr moduleId = renderedModules_.size();
+
+    RenderModule(buffer, module, moduleId);
+    RenderMmaps(buffer, module, moduleId);
+
+    renderedModules_.push_back({
+        internal_strdup(module.full_name()),
+        module.base_address(),
+        {},
+    });
+
+    // kModuleUUIDSize is the size of curModule.uuid
+    CHECK_GE(kModuleUUIDSize, module.uuid_size());
+    internal_memcpy(renderedModules_.back().uuid, module.uuid(),
+                    module.uuid_size());
+  }
 }
-#endif  // SANITIZER_CAN_SLOW_UNWIND
+#endif  // !SANITIZER_FUCHSIA
 
 }  // namespace __sanitizer
-
-#endif  // SANITIZER_SYMBOLIZER_MARKUP
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_markup.h b/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_markup.h
new file mode 100644
index 0000000000..bc2ab24d62
--- /dev/null
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_markup.h
@@ -0,0 +1,79 @@
+//===-- sanitizer_symbolizer_markup.h -----------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file is shared between various sanitizers' runtime libraries.
+//
+//  Header for the offline markup symbolizer.
+//===----------------------------------------------------------------------===//
+#ifndef SANITIZER_SYMBOLIZER_MARKUP_H
+#define SANITIZER_SYMBOLIZER_MARKUP_H
+
+#include "sanitizer_common.h"
+#include "sanitizer_stacktrace_printer.h"
+#include "sanitizer_symbolizer.h"
+#include "sanitizer_symbolizer_internal.h"
+
+namespace __sanitizer {
+
+// Simplier view of a LoadedModule. It only holds information necessary to
+// identify unique modules.
+struct RenderedModule {
+  char *full_name;
+  uptr base_address;
+  u8 uuid[kModuleUUIDSize];  // BuildId
+};
+
+class MarkupStackTracePrinter : public StackTracePrinter {
+ public:
+  // We don't support the stack_trace_format flag at all.
+  void RenderFrame(InternalScopedString *buffer, const char *format,
+                   int frame_no, uptr address, const AddressInfo *info,
+                   bool vs_style, const char *strip_path_prefix = "") override;
+
+  bool RenderNeedsSymbolization(const char *format) override;
+
+  // We ignore the format argument to __sanitizer_symbolize_global.
+  void RenderData(InternalScopedString *buffer, const char *format,
+                  const DataInfo *DI,
+                  const char *strip_path_prefix = "") override;
+
+ private:
+  // Keeps track of the modules that have been rendered to avoid re-rendering
+  // them
+  InternalMmapVector<RenderedModule> renderedModules_;
+  void RenderContext(InternalScopedString *buffer);
+
+ protected:
+  ~MarkupStackTracePrinter() {}
+};
+
+class MarkupSymbolizerTool final : public SymbolizerTool {
+ public:
+  // This is used in some places for suppression checking, which we
+  // don't really support for Fuchsia.  It's also used in UBSan to
+  // identify a PC location to a function name, so we always fill in
+  // the function member with a string containing markup around the PC
+  // value.
+  // TODO(mcgrathr): Under SANITIZER_GO, it's currently used by TSan
+  // to render stack frames, but that should be changed to use
+  // RenderStackFrame.
+  bool SymbolizePC(uptr addr, SymbolizedStack *stack) override;
+
+  // Always claim we succeeded, so that RenderDataInfo will be called.
+  bool SymbolizeData(uptr addr, DataInfo *info) override;
+
+  // May return NULL if demangling failed.
+  // This is used by UBSan for type names, and by ASan for global variable
+  // names. It's expected to return a static buffer that will be reused on each
+  // call.
+  const char *Demangle(const char *name) override;
+};
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_SYMBOLIZER_MARKUP_H
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_fuchsia.h b/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_markup_constants.h
similarity index 69%
rename from zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_fuchsia.h
rename to zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_markup_constants.h
index c4061e38c6..a43661eaec 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_fuchsia.h
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_markup_constants.h
@@ -1,4 +1,5 @@
-//===-- sanitizer_symbolizer_fuchsia.h -----------------------------------===//
+//===-- sanitizer_symbolizer_markup_constants.h
+//-----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -8,10 +9,10 @@
 //
 // This file is shared between various sanitizers' runtime libraries.
 //
-// Define Fuchsia's string formats and limits for the markup symbolizer.
+// Define string formats and limits for the markup symbolizer.
 //===----------------------------------------------------------------------===//
-#ifndef SANITIZER_SYMBOLIZER_FUCHSIA_H
-#define SANITIZER_SYMBOLIZER_FUCHSIA_H
+#ifndef SANITIZER_SYMBOLIZER_MARKUP_CONSTANTS_H
+#define SANITIZER_SYMBOLIZER_MARKUP_CONSTANTS_H
 
 #include "sanitizer_internal_defs.h"
 
@@ -32,11 +33,17 @@ constexpr uptr kFormatFunctionMax = 64;  // More than big enough for 64-bit hex.
 constexpr const char *kFormatData = "{{{data:%p}}}";
 
 // One frame in a backtrace (printed on a line by itself).
-constexpr const char *kFormatFrame = "{{{bt:%u:%p}}}";
+constexpr const char *kFormatFrame = "{{{bt:%d:%p}}}";
+
+// Module contextual element.
+constexpr const char *kFormatModule = "{{{module:%zu:%s:elf:%s}}}";
+
+// mmap for a module segment.
+constexpr const char *kFormatMmap = "{{{mmap:%p:0x%zx:load:%d:%s:0x%zx}}}";
 
 // Dump trigger element.
 #define FORMAT_DUMPFILE "{{{dumpfile:%s:%s}}}"
 
 }  // namespace __sanitizer
 
-#endif  // SANITIZER_SYMBOLIZER_FUCHSIA_H
+#endif  // SANITIZER_SYMBOLIZER_MARKUP_CONSTANTS_H
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_markup_fuchsia.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_markup_fuchsia.cpp
new file mode 100644
index 0000000000..08b06c2faf
--- /dev/null
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_markup_fuchsia.cpp
@@ -0,0 +1,85 @@
+//===-- sanitizer_symbolizer_markup_fuchsia.cpp ---------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between various sanitizers' runtime libraries.
+//
+// Fuchsia specific implementation of offline markup symbolizer.
+//===----------------------------------------------------------------------===//
+#include "sanitizer_platform.h"
+
+#if SANITIZER_SYMBOLIZER_MARKUP
+
+#  include "sanitizer_common.h"
+#  include "sanitizer_stacktrace_printer.h"
+#  include "sanitizer_symbolizer.h"
+#  include "sanitizer_symbolizer_markup.h"
+#  include "sanitizer_symbolizer_markup_constants.h"
+
+namespace __sanitizer {
+
+// This is used by UBSan for type names, and by ASan for global variable names.
+// It's expected to return a static buffer that will be reused on each call.
+const char *Symbolizer::Demangle(const char *name) {
+  static char buffer[kFormatDemangleMax];
+  internal_snprintf(buffer, sizeof(buffer), kFormatDemangle, name);
+  return buffer;
+}
+
+// This is used mostly for suppression matching.  Making it work
+// would enable "interceptor_via_lib" suppressions.  It's also used
+// once in UBSan to say "in module ..." in a message that also
+// includes an address in the module, so post-processing can already
+// pretty-print that so as to indicate the module.
+bool Symbolizer::GetModuleNameAndOffsetForPC(uptr pc, const char **module_name,
+                                             uptr *module_address) {
+  return false;
+}
+
+// This is mainly used by hwasan for online symbolization. This isn't needed
+// since hwasan can always just dump stack frames for offline symbolization.
+bool Symbolizer::SymbolizeFrame(uptr addr, FrameInfo *info) { return false; }
+
+// This is used in some places for suppression checking, which we
+// don't really support for Fuchsia.  It's also used in UBSan to
+// identify a PC location to a function name, so we always fill in
+// the function member with a string containing markup around the PC
+// value.
+// TODO(mcgrathr): Under SANITIZER_GO, it's currently used by TSan
+// to render stack frames, but that should be changed to use
+// RenderStackFrame.
+SymbolizedStack *Symbolizer::SymbolizePC(uptr addr) {
+  SymbolizedStack *s = SymbolizedStack::New(addr);
+  char buffer[kFormatFunctionMax];
+  internal_snprintf(buffer, sizeof(buffer), kFormatFunction, addr);
+  s->info.function = internal_strdup(buffer);
+  return s;
+}
+
+// Always claim we succeeded, so that RenderDataInfo will be called.
+bool Symbolizer::SymbolizeData(uptr addr, DataInfo *info) {
+  info->Clear();
+  info->start = addr;
+  return true;
+}
+
+// Fuchsia only uses MarkupStackTracePrinter
+StackTracePrinter *StackTracePrinter::NewStackTracePrinter() {
+  return new (GetGlobalLowLevelAllocator()) MarkupStackTracePrinter();
+}
+
+void MarkupStackTracePrinter::RenderContext(InternalScopedString *) {}
+
+Symbolizer *Symbolizer::PlatformInit() {
+  return new (symbolizer_allocator_) Symbolizer({});
+}
+
+void Symbolizer::LateInitialize() { Symbolizer::GetOrInit(); }
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_SYMBOLIZER_MARKUP
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cpp
index 1a5e38faea..0ddc24802d 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cpp
@@ -12,6 +12,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_platform.h"
+#include "sanitizer_symbolizer_markup.h"
 #if SANITIZER_POSIX
 #  include <dlfcn.h>  // for dlsym()
 #  include <errno.h>
@@ -56,7 +57,7 @@ const char *DemangleCXXABI(const char *name) {
           __cxxabiv1::__cxa_demangle(name, 0, 0, 0))
       return demangled_name;
 
-  return name;
+  return nullptr;
 }
 
 // As of now, there are no headers for the Swift runtime. Once they are
@@ -324,9 +325,12 @@ __sanitizer_symbolize_code(const char *ModuleName, u64 ModuleOffset,
 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE bool
 __sanitizer_symbolize_data(const char *ModuleName, u64 ModuleOffset,
                            char *Buffer, int MaxLength);
+SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE bool
+__sanitizer_symbolize_frame(const char *ModuleName, u64 ModuleOffset,
+                            char *Buffer, int MaxLength);
 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void
 __sanitizer_symbolize_flush();
-SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE int
+SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE bool
 __sanitizer_symbolize_demangle(const char *Name, char *Buffer, int MaxLength);
 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE bool
 __sanitizer_symbolize_set_demangle(bool Demangle);
@@ -337,19 +341,19 @@ __sanitizer_symbolize_set_inline_frames(bool InlineFrames);
 class InternalSymbolizer final : public SymbolizerTool {
  public:
   static InternalSymbolizer *get(LowLevelAllocator *alloc) {
-    if (__sanitizer_symbolize_set_demangle)
-      CHECK(__sanitizer_symbolize_set_demangle(common_flags()->demangle));
-    if (__sanitizer_symbolize_set_inline_frames)
-      CHECK(__sanitizer_symbolize_set_inline_frames(
-          common_flags()->symbolize_inline_frames));
-    if (__sanitizer_symbolize_code && __sanitizer_symbolize_data)
-      return new (*alloc) InternalSymbolizer();
-    return 0;
+    // These one is the most used one, so we will use it to detect a presence of
+    // internal symbolizer.
+    if (&__sanitizer_symbolize_code == nullptr)
+      return nullptr;
+    CHECK(__sanitizer_symbolize_set_demangle(common_flags()->demangle));
+    CHECK(__sanitizer_symbolize_set_inline_frames(
+        common_flags()->symbolize_inline_frames));
+    return new (*alloc) InternalSymbolizer();
   }
 
   bool SymbolizePC(uptr addr, SymbolizedStack *stack) override {
     bool result = __sanitizer_symbolize_code(
-        stack->info.module, stack->info.module_offset, buffer_, kBufferSize);
+        stack->info.module, stack->info.module_offset, buffer_, sizeof(buffer_));
     if (result)
       ParseSymbolizePCOutput(buffer_, stack);
     return result;
@@ -357,7 +361,7 @@ class InternalSymbolizer final : public SymbolizerTool {
 
   bool SymbolizeData(uptr addr, DataInfo *info) override {
     bool result = __sanitizer_symbolize_data(info->module, info->module_offset,
-                                             buffer_, kBufferSize);
+                                             buffer_, sizeof(buffer_));
     if (result) {
       ParseSymbolizeDataOutput(buffer_, info);
       info->start += (addr - info->module_offset);  // Add the base address.
@@ -365,34 +369,29 @@ class InternalSymbolizer final : public SymbolizerTool {
     return result;
   }
 
-  void Flush() override {
-    if (__sanitizer_symbolize_flush)
-      __sanitizer_symbolize_flush();
+  bool SymbolizeFrame(uptr addr, FrameInfo *info) override {
+    bool result = __sanitizer_symbolize_frame(info->module, info->module_offset,
+                                              buffer_, sizeof(buffer_));
+    if (result)
+      ParseSymbolizeFrameOutput(buffer_, &info->locals);
+    return result;
   }
 
+  void Flush() override { __sanitizer_symbolize_flush(); }
+
   const char *Demangle(const char *name) override {
-    if (__sanitizer_symbolize_demangle) {
-      for (uptr res_length = 1024;
-           res_length <= InternalSizeClassMap::kMaxSize;) {
-        char *res_buff = static_cast<char *>(InternalAlloc(res_length));
-        uptr req_length =
-            __sanitizer_symbolize_demangle(name, res_buff, res_length);
-        if (req_length > res_length) {
-          res_length = req_length + 1;
-          InternalFree(res_buff);
-          continue;
-        }
-        return res_buff;
-      }
+    if (__sanitizer_symbolize_demangle(name, buffer_, sizeof(buffer_))) {
+      char *res_buff = nullptr;
+      ExtractToken(buffer_, "", &res_buff);
+      return res_buff;
     }
-    return name;
+    return nullptr;
   }
 
  private:
   InternalSymbolizer() {}
 
-  static const int kBufferSize = 16 * 1024;
-  char buffer_[kBufferSize];
+  char buffer_[16 * 1024];
 };
 #  else  // SANITIZER_SUPPORTS_WEAK_HOOKS
 
@@ -470,6 +469,12 @@ static void ChooseSymbolizerTools(IntrusiveList<SymbolizerTool> *list,
     VReport(2, "Symbolizer is disabled.\n");
     return;
   }
+  if (common_flags()->enable_symbolizer_markup) {
+    VReport(2, "Using symbolizer markup");
+    SymbolizerTool *tool = new (*allocator) MarkupSymbolizerTool();
+    CHECK(tool);
+    list->push_back(tool);
+  }
   if (IsAllocatorOutOfMemory()) {
     VReport(2, "Cannot use internal symbolizer: out of memory\n");
   } else if (SymbolizerTool *tool = InternalSymbolizer::get(allocator)) {
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_report.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_report.cpp
index 73915715c5..ffbaf1468e 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_report.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_report.cpp
@@ -28,14 +28,41 @@
 namespace __sanitizer {
 
 #if !SANITIZER_GO
+
+static bool FrameIsInternal(const SymbolizedStack *frame) {
+  if (!frame)
+    return true;
+  const char *file = frame->info.file;
+  const char *module = frame->info.module;
+  // On Gentoo, the path is g++-*, so there's *not* a missing /.
+  if (file && (internal_strstr(file, "/compiler-rt/lib/") ||
+               internal_strstr(file, "/include/c++/") ||
+               internal_strstr(file, "/include/g++")))
+    return true;
+  if (file && internal_strstr(file, "\\compiler-rt\\lib\\"))
+    return true;
+  if (module && (internal_strstr(module, "libclang_rt.")))
+    return true;
+  if (module && (internal_strstr(module, "clang_rt.")))
+    return true;
+  return false;
+}
+
+const SymbolizedStack *SkipInternalFrames(const SymbolizedStack *frames) {
+  for (const SymbolizedStack *f = frames; f; f = f->next)
+    if (!FrameIsInternal(f))
+      return f;
+  return nullptr;
+}
+
 void ReportErrorSummary(const char *error_type, const AddressInfo &info,
                         const char *alt_tool_name) {
   if (!common_flags()->print_summary) return;
   InternalScopedString buff;
-  buff.append("%s ", error_type);
-  RenderFrame(&buff, "%L %F", 0, info.address, &info,
-              common_flags()->symbolize_vs_style,
-              common_flags()->strip_path_prefix);
+  buff.AppendF("%s ", error_type);
+  StackTracePrinter::GetOrInit()->RenderFrame(
+      &buff, "%L %F", 0, info.address, &info,
+      common_flags()->symbolize_vs_style, common_flags()->strip_path_prefix);
   ReportErrorSummary(buff.data(), alt_tool_name);
 }
 #endif
@@ -75,16 +102,33 @@ void ReportErrorSummary(const char *error_type, const StackTrace *stack,
 #if !SANITIZER_GO
   if (!common_flags()->print_summary)
     return;
-  if (stack->size == 0) {
-    ReportErrorSummary(error_type);
-    return;
+
+  // Find first non-internal stack frame.
+  for (uptr i = 0; i < stack->size; ++i) {
+    uptr pc = StackTrace::GetPreviousInstructionPc(stack->trace[i]);
+    SymbolizedStackHolder symbolized_stack(
+        Symbolizer::GetOrInit()->SymbolizePC(pc));
+    if (const SymbolizedStack *frame = symbolized_stack.get()) {
+      if (const SymbolizedStack *summary_frame = SkipInternalFrames(frame)) {
+        ReportErrorSummary(error_type, summary_frame->info, alt_tool_name);
+        return;
+      }
+    }
+  }
+
+  // Fallback to the top one.
+  if (stack->size) {
+    uptr pc = StackTrace::GetPreviousInstructionPc(stack->trace[0]);
+    SymbolizedStackHolder symbolized_stack(
+        Symbolizer::GetOrInit()->SymbolizePC(pc));
+    if (const SymbolizedStack *frame = symbolized_stack.get()) {
+      ReportErrorSummary(error_type, frame->info, alt_tool_name);
+      return;
+    }
   }
-  // Currently, we include the first stack frame into the report summary.
-  // Maybe sometimes we need to choose another frame (e.g. skip memcpy/etc).
-  uptr pc = StackTrace::GetPreviousInstructionPc(stack->trace[0]);
-  SymbolizedStack *frame = Symbolizer::GetOrInit()->SymbolizePC(pc);
-  ReportErrorSummary(error_type, frame->info, alt_tool_name);
-  frame->ClearAll();
+
+  // Fallback to a summary without location.
+  ReportErrorSummary(error_type);
 #endif
 }
 
@@ -148,22 +192,22 @@ static void MaybeReportNonExecRegion(uptr pc) {
 static void PrintMemoryByte(InternalScopedString *str, const char *before,
                             u8 byte) {
   SanitizerCommonDecorator d;
-  str->append("%s%s%x%x%s ", before, d.MemoryByte(), byte >> 4, byte & 15,
-              d.Default());
+  str->AppendF("%s%s%x%x%s ", before, d.MemoryByte(), byte >> 4, byte & 15,
+               d.Default());
 }
 
 static void MaybeDumpInstructionBytes(uptr pc) {
   if (!common_flags()->dump_instruction_bytes || (pc < GetPageSizeCached()))
     return;
   InternalScopedString str;
-  str.append("First 16 instruction bytes at pc: ");
+  str.AppendF("First 16 instruction bytes at pc: ");
   if (IsAccessibleMemoryRange(pc, 16)) {
     for (int i = 0; i < 16; ++i) {
       PrintMemoryByte(&str, "", ((u8 *)pc)[i]);
     }
-    str.append("\n");
+    str.AppendF("\n");
   } else {
-    str.append("unaccessible\n");
+    str.AppendF("unaccessible\n");
   }
   Report("%s", str.data());
 }
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_report_fuchsia.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_report_fuchsia.cpp
new file mode 100644
index 0000000000..fb49cfbb30
--- /dev/null
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_report_fuchsia.cpp
@@ -0,0 +1,33 @@
+//===-- sanitizer_symbolizer_report_fuchsia.cpp
+//-----------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Implementation of the report functions for fuchsia.
+//
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_platform.h"
+
+#if SANITIZER_SYMBOLIZER_MARKUP
+
+#  include "sanitizer_common.h"
+
+namespace __sanitizer {
+void StartReportDeadlySignal() {}
+
+void ReportDeadlySignal(const SignalContext &sig, u32 tid,
+                        UnwindSignalStackCallbackType unwind,
+                        const void *unwind_context) {}
+
+void HandleDeadlySignal(void *siginfo, void *context, u32 tid,
+                        UnwindSignalStackCallbackType unwind,
+                        const void *unwind_context) {}
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_SYMBOLIZER_MARKUP
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_win.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_win.cpp
index ae2d3be19e..aae3e76ea2 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_win.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_symbolizer_win.cpp
@@ -175,9 +175,7 @@ const char *WinSymbolizerTool::Demangle(const char *name) {
     return name;
 }
 
-const char *Symbolizer::PlatformDemangle(const char *name) {
-  return name;
-}
+const char *Symbolizer::PlatformDemangle(const char *name) { return nullptr; }
 
 namespace {
 struct ScopedHandle {
@@ -233,7 +231,7 @@ bool SymbolizerProcess::StartSymbolizerSubprocess() {
     CHECK(!internal_strchr(arg, '"') && "quotes in args unsupported");
     CHECK(arglen > 0 && arg[arglen - 1] != '\\' &&
           "args ending in backslash and empty args unsupported");
-    command_line.append("\"%s\" ", arg);
+    command_line.AppendF("\"%s\" ", arg);
   }
   VReport(3, "Launching symbolizer command: %s\n", command_line.data());
 
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_syscall_linux_hexagon.inc b/zig/lib/tsan/sanitizer_common/sanitizer_syscall_linux_hexagon.inc
new file mode 100644
index 0000000000..553bff7503
--- /dev/null
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_syscall_linux_hexagon.inc
@@ -0,0 +1,131 @@
+//===-- sanitizer_syscall_linux_hexagon.inc ---------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Implementations of internal_syscall and internal_iserror for Linux/hexagon.
+//
+//===----------------------------------------------------------------------===//
+
+#define SYSCALL(name) __NR_##name
+
+#define __internal_syscall_LL_E(x) \
+  ((union {                        \
+    long long ll;                  \
+    long l[2];                     \
+  }){.ll = x})                     \
+      .l[0],                       \
+      ((union {                    \
+        long long ll;              \
+        long l[2];                 \
+      }){.ll = x})                 \
+          .l[1]
+#define __internal_syscall_LL_O(x) 0, __SYSCALL_LL_E((x))
+
+#define __asm_syscall(...)                                                 \
+  do {                                                                     \
+    __asm__ __volatile__("trap0(#1)" : "=r"(r0) : __VA_ARGS__ : "memory"); \
+    return r0;                                                             \
+  } while (0)
+
+#define __internal_syscall0(n) (__internal_syscall)(n)
+
+static uptr __internal_syscall(long n) {
+  register u32 r6 __asm__("r6") = n;
+  register u32 r0 __asm__("r0");
+  __asm_syscall("r"(r6));
+}
+
+#define __internal_syscall1(n, a1) (__internal_syscall)(n, (long)(a1))
+
+static uptr __internal_syscall(long n, long a) {
+  register u32 r6 __asm__("r6") = n;
+  register u32 r0 __asm__("r0") = a;
+  __asm_syscall("r"(r6), "0"(r0));
+}
+
+#define __internal_syscall2(n, a1, a2) \
+  (__internal_syscall)(n, (long)(a1), (long)(a2))
+
+static uptr __internal_syscall(long n, long a, long b) {
+  register u32 r6 __asm__("r6") = n;
+  register u32 r0 __asm__("r0") = a;
+  register u32 r1 __asm__("r1") = b;
+  __asm_syscall("r"(r6), "0"(r0), "r"(r1));
+}
+
+#define __internal_syscall3(n, a1, a2, a3) \
+  (__internal_syscall)(n, (long)(a1), (long)(a2), (long)(a3))
+
+static uptr __internal_syscall(long n, long a, long b, long c) {
+  register u32 r6 __asm__("r6") = n;
+  register u32 r0 __asm__("r0") = a;
+  register u32 r1 __asm__("r1") = b;
+  register u32 r2 __asm__("r2") = c;
+  __asm_syscall("r"(r6), "0"(r0), "r"(r1), "r"(r2));
+}
+
+#define __internal_syscall4(n, a1, a2, a3, a4) \
+  (__internal_syscall)(n, (long)(a1), (long)(a2), (long)(a3), (long)(a4))
+
+static uptr __internal_syscall(long n, long a, long b, long c, long d) {
+  register u32 r6 __asm__("r6") = n;
+  register u32 r0 __asm__("r0") = a;
+  register u32 r1 __asm__("r1") = b;
+  register u32 r2 __asm__("r2") = c;
+  register u32 r3 __asm__("r3") = d;
+  __asm_syscall("r"(r6), "0"(r0), "r"(r1), "r"(r2), "r"(r3));
+}
+
+#define __internal_syscall5(n, a1, a2, a3, a4, a5)                        \
+  (__internal_syscall)(n, (long)(a1), (long)(a2), (long)(a3), (long)(a4), \
+                       (long)(a5))
+
+static uptr __internal_syscall(long n, long a, long b, long c, long d, long e) {
+  register u32 r6 __asm__("r6") = n;
+  register u32 r0 __asm__("r0") = a;
+  register u32 r1 __asm__("r1") = b;
+  register u32 r2 __asm__("r2") = c;
+  register u32 r3 __asm__("r3") = d;
+  register u32 r4 __asm__("r4") = e;
+  __asm_syscall("r"(r6), "0"(r0), "r"(r1), "r"(r2), "r"(r3), "r"(r4));
+}
+
+#define __internal_syscall6(n, a1, a2, a3, a4, a5, a6)                    \
+  (__internal_syscall)(n, (long)(a1), (long)(a2), (long)(a3), (long)(a4), \
+                       (long)(a5), (long)(a6))
+
+static uptr __internal_syscall(long n, long a, long b, long c, long d, long e,
+                               long f) {
+  register u32 r6 __asm__("r6") = n;
+  register u32 r0 __asm__("r0") = a;
+  register u32 r1 __asm__("r1") = b;
+  register u32 r2 __asm__("r2") = c;
+  register u32 r3 __asm__("r3") = d;
+  register u32 r4 __asm__("r4") = e;
+  register u32 r5 __asm__("r5") = f;
+  __asm_syscall("r"(r6), "0"(r0), "r"(r1), "r"(r2), "r"(r3), "r"(r4), "r"(r5));
+}
+
+#define __SYSCALL_NARGS_X(a1, a2, a3, a4, a5, a6, a7, a8, n, ...) n
+#define __SYSCALL_NARGS(...) \
+  __SYSCALL_NARGS_X(__VA_ARGS__, 7, 6, 5, 4, 3, 2, 1, 0, )
+#define __SYSCALL_CONCAT_X(a, b) a##b
+#define __SYSCALL_CONCAT(a, b) __SYSCALL_CONCAT_X(a, b)
+#define __SYSCALL_DISP(b, ...) \
+  __SYSCALL_CONCAT(b, __SYSCALL_NARGS(__VA_ARGS__))(__VA_ARGS__)
+
+#define internal_syscall(...) __SYSCALL_DISP(__internal_syscall, __VA_ARGS__)
+
+// Helper function used to avoid clobbering of errno.
+bool internal_iserror(uptr retval, int *rverrno) {
+  if (retval >= (uptr)-4095) {
+    if (rverrno)
+      *rverrno = -retval;
+    return true;
+  }
+  return false;
+}
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_syscall_linux_loongarch64.inc b/zig/lib/tsan/sanitizer_common/sanitizer_syscall_linux_loongarch64.inc
new file mode 100644
index 0000000000..80f5e6be8a
--- /dev/null
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_syscall_linux_loongarch64.inc
@@ -0,0 +1,171 @@
+//===-- sanitizer_syscall_linux_loongarch64.inc -----------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Implementations of internal_syscall and internal_iserror for
+// Linux/loongarch64.
+//
+//===----------------------------------------------------------------------===//
+
+// About local register variables:
+// https://gcc.gnu.org/onlinedocs/gcc/Local-Register-Variables.html#Local-Register-Variables
+//
+// Kernel ABI:
+// https://lore.kernel.org/loongarch/1f353678-3398-e30b-1c87-6edb278f74db@xen0n.name/T/#m1613bc86c2d7bf5f6da92bd62984302bfd699a2f
+//  syscall number is placed in a7
+//  parameters, if present, are placed in a0-a6
+//  upon return:
+//    the return value is placed in a0
+//    t0-t8 should be considered clobbered
+//    all other registers are preserved
+#define SYSCALL(name) __NR_##name
+
+#define INTERNAL_SYSCALL_CLOBBERS \
+  "memory", "$t0", "$t1", "$t2", "$t3", "$t4", "$t5", "$t6", "$t7", "$t8"
+
+static uptr __internal_syscall(u64 nr) {
+  register u64 a7 asm("$a7") = nr;
+  register u64 a0 asm("$a0");
+  __asm__ volatile("syscall 0\n\t"
+                   : "=r"(a0)
+                   : "r"(a7)
+                   : INTERNAL_SYSCALL_CLOBBERS);
+  return a0;
+}
+#define __internal_syscall0(n) (__internal_syscall)(n)
+
+static uptr __internal_syscall(u64 nr, u64 arg1) {
+  register u64 a7 asm("$a7") = nr;
+  register u64 a0 asm("$a0") = arg1;
+  __asm__ volatile("syscall 0\n\t"
+                   : "+r"(a0)
+                   : "r"(a7)
+                   : INTERNAL_SYSCALL_CLOBBERS);
+  return a0;
+}
+#define __internal_syscall1(n, a1) (__internal_syscall)(n, (u64)(a1))
+
+static uptr __internal_syscall(u64 nr, u64 arg1, long arg2) {
+  register u64 a7 asm("$a7") = nr;
+  register u64 a0 asm("$a0") = arg1;
+  register u64 a1 asm("$a1") = arg2;
+  __asm__ volatile("syscall 0\n\t"
+                   : "+r"(a0)
+                   : "r"(a7), "r"(a1)
+                   : INTERNAL_SYSCALL_CLOBBERS);
+  return a0;
+}
+#define __internal_syscall2(n, a1, a2) \
+  (__internal_syscall)(n, (u64)(a1), (long)(a2))
+
+static uptr __internal_syscall(u64 nr, u64 arg1, long arg2, long arg3) {
+  register u64 a7 asm("$a7") = nr;
+  register u64 a0 asm("$a0") = arg1;
+  register u64 a1 asm("$a1") = arg2;
+  register u64 a2 asm("$a2") = arg3;
+  __asm__ volatile("syscall 0\n\t"
+                   : "+r"(a0)
+                   : "r"(a7), "r"(a1), "r"(a2)
+                   : INTERNAL_SYSCALL_CLOBBERS);
+  return a0;
+}
+#define __internal_syscall3(n, a1, a2, a3) \
+  (__internal_syscall)(n, (u64)(a1), (long)(a2), (long)(a3))
+
+static uptr __internal_syscall(u64 nr, u64 arg1, long arg2, long arg3,
+                               u64 arg4) {
+  register u64 a7 asm("$a7") = nr;
+  register u64 a0 asm("$a0") = arg1;
+  register u64 a1 asm("$a1") = arg2;
+  register u64 a2 asm("$a2") = arg3;
+  register u64 a3 asm("$a3") = arg4;
+  __asm__ volatile("syscall 0\n\t"
+                   : "+r"(a0)
+                   : "r"(a7), "r"(a1), "r"(a2), "r"(a3)
+                   : INTERNAL_SYSCALL_CLOBBERS);
+  return a0;
+}
+#define __internal_syscall4(n, a1, a2, a3, a4) \
+  (__internal_syscall)(n, (u64)(a1), (long)(a2), (long)(a3), (long)(a4))
+
+static uptr __internal_syscall(u64 nr, u64 arg1, long arg2, long arg3, u64 arg4,
+                               long arg5) {
+  register u64 a7 asm("$a7") = nr;
+  register u64 a0 asm("$a0") = arg1;
+  register u64 a1 asm("$a1") = arg2;
+  register u64 a2 asm("$a2") = arg3;
+  register u64 a3 asm("$a3") = arg4;
+  register u64 a4 asm("$a4") = arg5;
+  __asm__ volatile("syscall 0\n\t"
+                   : "+r"(a0)
+                   : "r"(a7), "r"(a1), "r"(a2), "r"(a3), "r"(a4)
+                   : INTERNAL_SYSCALL_CLOBBERS);
+  return a0;
+}
+#define __internal_syscall5(n, a1, a2, a3, a4, a5)                       \
+  (__internal_syscall)(n, (u64)(a1), (long)(a2), (long)(a3), (long)(a4), \
+                       (u64)(a5))
+
+static uptr __internal_syscall(u64 nr, u64 arg1, long arg2, long arg3, u64 arg4,
+                               long arg5, long arg6) {
+  register u64 a7 asm("$a7") = nr;
+  register u64 a0 asm("$a0") = arg1;
+  register u64 a1 asm("$a1") = arg2;
+  register u64 a2 asm("$a2") = arg3;
+  register u64 a3 asm("$a3") = arg4;
+  register u64 a4 asm("$a4") = arg5;
+  register u64 a5 asm("$a5") = arg6;
+  __asm__ volatile("syscall 0\n\t"
+                   : "+r"(a0)
+                   : "r"(a7), "r"(a1), "r"(a2), "r"(a3), "r"(a4), "r"(a5)
+                   : INTERNAL_SYSCALL_CLOBBERS);
+  return a0;
+}
+#define __internal_syscall6(n, a1, a2, a3, a4, a5, a6)                   \
+  (__internal_syscall)(n, (u64)(a1), (long)(a2), (long)(a3), (long)(a4), \
+                       (u64)(a5), (long)(a6))
+
+static uptr __internal_syscall(u64 nr, u64 arg1, long arg2, long arg3, u64 arg4,
+                               long arg5, long arg6, long arg7) {
+  register u64 a7 asm("$a7") = nr;
+  register u64 a0 asm("$a0") = arg1;
+  register u64 a1 asm("$a1") = arg2;
+  register u64 a2 asm("$a2") = arg3;
+  register u64 a3 asm("$a3") = arg4;
+  register u64 a4 asm("$a4") = arg5;
+  register u64 a5 asm("$a5") = arg6;
+  register u64 a6 asm("$a6") = arg7;
+  __asm__ volatile("syscall 0\n\t"
+                   : "+r"(a0)
+                   : "r"(a7), "r"(a1), "r"(a2), "r"(a3), "r"(a4), "r"(a5),
+                     "r"(a6)
+                   : INTERNAL_SYSCALL_CLOBBERS);
+  return a0;
+}
+#define __internal_syscall7(n, a1, a2, a3, a4, a5, a6, a7)               \
+  (__internal_syscall)(n, (u64)(a1), (long)(a2), (long)(a3), (long)(a4), \
+                       (u64)(a5), (long)(a6), (long)(a7))
+
+#define __SYSCALL_NARGS_X(a1, a2, a3, a4, a5, a6, a7, a8, n, ...) n
+#define __SYSCALL_NARGS(...) \
+  __SYSCALL_NARGS_X(__VA_ARGS__, 7, 6, 5, 4, 3, 2, 1, 0, )
+#define __SYSCALL_CONCAT_X(a, b) a##b
+#define __SYSCALL_CONCAT(a, b) __SYSCALL_CONCAT_X(a, b)
+#define __SYSCALL_DISP(b, ...) \
+  __SYSCALL_CONCAT(b, __SYSCALL_NARGS(__VA_ARGS__))(__VA_ARGS__)
+
+#define internal_syscall(...) __SYSCALL_DISP(__internal_syscall, __VA_ARGS__)
+
+// Helper function used to avoid clobbering of errno.
+bool internal_iserror(uptr retval, int *internal_errno) {
+  if (retval >= (uptr)-4095) {
+    if (internal_errno)
+      *internal_errno = -retval;
+    return true;
+  }
+  return false;
+}
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_syscall_linux_riscv64.inc b/zig/lib/tsan/sanitizer_common/sanitizer_syscall_linux_riscv64.inc
new file mode 100644
index 0000000000..89c1260205
--- /dev/null
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_syscall_linux_riscv64.inc
@@ -0,0 +1,174 @@
+//===-- sanitizer_syscall_linux_riscv64.inc ---------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Implementations of internal_syscall and internal_iserror for Linux/riscv64.
+//
+//===----------------------------------------------------------------------===//
+
+// About local register variables:
+// https://gcc.gnu.org/onlinedocs/gcc/Local-Register-Variables.html#Local-Register-Variables
+//
+// Kernel ABI...
+// To my surprise I haven't found much information regarding it.
+// Kernel source and internet browsing shows that:
+//  syscall number is passed in a7
+//  (http://man7.org/linux/man-pages/man2/syscall.2.html) results are return in
+//  a0 and a1 (http://man7.org/linux/man-pages/man2/syscall.2.html) arguments
+//  are passed in: a0-a7 (see below)
+//
+//  Regarding the arguments. The only "documentation" I could find is
+//  this comment (!!!) by Bruce Hold on google forums (!!!):
+//    https://groups.google.com/a/groups.riscv.org/forum/#!topic/sw-dev/exbrzM3GZDQ
+//    Confirmed by inspecting glibc sources.
+//  Great way to document things.
+#define SYSCALL(name) __NR_##name
+
+#define INTERNAL_SYSCALL_CLOBBERS "memory"
+
+static uptr __internal_syscall(u64 nr) {
+  register u64 a7 asm("a7") = nr;
+  register u64 a0 asm("a0");
+  __asm__ volatile("ecall\n\t"
+                   : "=r"(a0)
+                   : "r"(a7)
+                   : INTERNAL_SYSCALL_CLOBBERS);
+  return a0;
+}
+#define __internal_syscall0(n) (__internal_syscall)(n)
+
+static uptr __internal_syscall(u64 nr, u64 arg1) {
+  register u64 a7 asm("a7") = nr;
+  register u64 a0 asm("a0") = arg1;
+  __asm__ volatile("ecall\n\t"
+                   : "+r"(a0)
+                   : "r"(a7)
+                   : INTERNAL_SYSCALL_CLOBBERS);
+  return a0;
+}
+#define __internal_syscall1(n, a1) (__internal_syscall)(n, (u64)(a1))
+
+static uptr __internal_syscall(u64 nr, u64 arg1, long arg2) {
+  register u64 a7 asm("a7") = nr;
+  register u64 a0 asm("a0") = arg1;
+  register u64 a1 asm("a1") = arg2;
+  __asm__ volatile("ecall\n\t"
+                   : "+r"(a0)
+                   : "r"(a7), "r"(a1)
+                   : INTERNAL_SYSCALL_CLOBBERS);
+  return a0;
+}
+#define __internal_syscall2(n, a1, a2) \
+  (__internal_syscall)(n, (u64)(a1), (long)(a2))
+
+static uptr __internal_syscall(u64 nr, u64 arg1, long arg2, long arg3) {
+  register u64 a7 asm("a7") = nr;
+  register u64 a0 asm("a0") = arg1;
+  register u64 a1 asm("a1") = arg2;
+  register u64 a2 asm("a2") = arg3;
+  __asm__ volatile("ecall\n\t"
+                   : "+r"(a0)
+                   : "r"(a7), "r"(a1), "r"(a2)
+                   : INTERNAL_SYSCALL_CLOBBERS);
+  return a0;
+}
+#define __internal_syscall3(n, a1, a2, a3) \
+  (__internal_syscall)(n, (u64)(a1), (long)(a2), (long)(a3))
+
+static uptr __internal_syscall(u64 nr, u64 arg1, long arg2, long arg3,
+                               u64 arg4) {
+  register u64 a7 asm("a7") = nr;
+  register u64 a0 asm("a0") = arg1;
+  register u64 a1 asm("a1") = arg2;
+  register u64 a2 asm("a2") = arg3;
+  register u64 a3 asm("a3") = arg4;
+  __asm__ volatile("ecall\n\t"
+                   : "+r"(a0)
+                   : "r"(a7), "r"(a1), "r"(a2), "r"(a3)
+                   : INTERNAL_SYSCALL_CLOBBERS);
+  return a0;
+}
+#define __internal_syscall4(n, a1, a2, a3, a4) \
+  (__internal_syscall)(n, (u64)(a1), (long)(a2), (long)(a3), (long)(a4))
+
+static uptr __internal_syscall(u64 nr, u64 arg1, long arg2, long arg3, u64 arg4,
+                               long arg5) {
+  register u64 a7 asm("a7") = nr;
+  register u64 a0 asm("a0") = arg1;
+  register u64 a1 asm("a1") = arg2;
+  register u64 a2 asm("a2") = arg3;
+  register u64 a3 asm("a3") = arg4;
+  register u64 a4 asm("a4") = arg5;
+  __asm__ volatile("ecall\n\t"
+                   : "+r"(a0)
+                   : "r"(a7), "r"(a1), "r"(a2), "r"(a3), "r"(a4)
+                   : INTERNAL_SYSCALL_CLOBBERS);
+  return a0;
+}
+#define __internal_syscall5(n, a1, a2, a3, a4, a5)                       \
+  (__internal_syscall)(n, (u64)(a1), (long)(a2), (long)(a3), (long)(a4), \
+                       (u64)(a5))
+
+static uptr __internal_syscall(u64 nr, u64 arg1, long arg2, long arg3, u64 arg4,
+                               long arg5, long arg6) {
+  register u64 a7 asm("a7") = nr;
+  register u64 a0 asm("a0") = arg1;
+  register u64 a1 asm("a1") = arg2;
+  register u64 a2 asm("a2") = arg3;
+  register u64 a3 asm("a3") = arg4;
+  register u64 a4 asm("a4") = arg5;
+  register u64 a5 asm("a5") = arg6;
+  __asm__ volatile("ecall\n\t"
+                   : "+r"(a0)
+                   : "r"(a7), "r"(a1), "r"(a2), "r"(a3), "r"(a4), "r"(a5)
+                   : INTERNAL_SYSCALL_CLOBBERS);
+  return a0;
+}
+#define __internal_syscall6(n, a1, a2, a3, a4, a5, a6)                   \
+  (__internal_syscall)(n, (u64)(a1), (long)(a2), (long)(a3), (long)(a4), \
+                       (u64)(a5), (long)(a6))
+
+static uptr __internal_syscall(u64 nr, u64 arg1, long arg2, long arg3, u64 arg4,
+                               long arg5, long arg6, long arg7) {
+  register u64 a7 asm("a7") = nr;
+  register u64 a0 asm("a0") = arg1;
+  register u64 a1 asm("a1") = arg2;
+  register u64 a2 asm("a2") = arg3;
+  register u64 a3 asm("a3") = arg4;
+  register u64 a4 asm("a4") = arg5;
+  register u64 a5 asm("a5") = arg6;
+  register u64 a6 asm("a6") = arg7;
+  __asm__ volatile("ecall\n\t"
+                   : "+r"(a0)
+                   : "r"(a7), "r"(a1), "r"(a2), "r"(a3), "r"(a4), "r"(a5),
+                     "r"(a6)
+                   : INTERNAL_SYSCALL_CLOBBERS);
+  return a0;
+}
+#define __internal_syscall7(n, a1, a2, a3, a4, a5, a6, a7)               \
+  (__internal_syscall)(n, (u64)(a1), (long)(a2), (long)(a3), (long)(a4), \
+                       (u64)(a5), (long)(a6), (long)(a7))
+
+#define __SYSCALL_NARGS_X(a1, a2, a3, a4, a5, a6, a7, a8, n, ...) n
+#define __SYSCALL_NARGS(...) \
+  __SYSCALL_NARGS_X(__VA_ARGS__, 7, 6, 5, 4, 3, 2, 1, 0, )
+#define __SYSCALL_CONCAT_X(a, b) a##b
+#define __SYSCALL_CONCAT(a, b) __SYSCALL_CONCAT_X(a, b)
+#define __SYSCALL_DISP(b, ...) \
+  __SYSCALL_CONCAT(b, __SYSCALL_NARGS(__VA_ARGS__))(__VA_ARGS__)
+
+#define internal_syscall(...) __SYSCALL_DISP(__internal_syscall, __VA_ARGS__)
+
+// Helper function used to avoid clobbering of errno.
+bool internal_iserror(uptr retval, int *rverrno) {
+  if (retval >= (uptr)-4095) {
+    if (rverrno)
+      *rverrno = -retval;
+    return true;
+  }
+  return false;
+}
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_thread_arg_retval.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_thread_arg_retval.cpp
index bddb285214..754fd7b65a 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_thread_arg_retval.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_thread_arg_retval.cpp
@@ -23,6 +23,9 @@ void ThreadArgRetval::CreateLocked(uptr thread, bool detached,
   Data& t = data_[thread];
   t = {};
   t.gen = gen_++;
+  static_assert(sizeof(gen_) == sizeof(u32) && kInvalidGen == UINT32_MAX);
+  if (gen_ == kInvalidGen)
+    gen_ = 0;
   t.detached = detached;
   t.args = args;
 }
@@ -53,16 +56,28 @@ void ThreadArgRetval::Finish(uptr thread, void* retval) {
 u32 ThreadArgRetval::BeforeJoin(uptr thread) const {
   __sanitizer::Lock lock(&mtx_);
   auto t = data_.find(thread);
-  CHECK(t);
-  CHECK(!t->second.detached);
-  return t->second.gen;
+  if (t && !t->second.detached) {
+    return t->second.gen;
+  }
+  if (!common_flags()->detect_invalid_join)
+    return kInvalidGen;
+  const char* reason = "unknown";
+  if (!t) {
+    reason = "already joined";
+  } else if (t->second.detached) {
+    reason = "detached";
+  }
+  Report("ERROR: %s: Joining %s thread, aborting.\n", SanitizerToolName,
+         reason);
+  Die();
 }
 
 void ThreadArgRetval::AfterJoin(uptr thread, u32 gen) {
   __sanitizer::Lock lock(&mtx_);
   auto t = data_.find(thread);
   if (!t || gen != t->second.gen) {
-    // Thread was reused and erased by any other event.
+    // Thread was reused and erased by any other event, or we had an invalid
+    // join.
     return;
   }
   CHECK(!t->second.detached);
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_thread_arg_retval.h b/zig/lib/tsan/sanitizer_common/sanitizer_thread_arg_retval.h
index c77021beb6..0e6d35131c 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_thread_arg_retval.h
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_thread_arg_retval.h
@@ -93,6 +93,7 @@ class SANITIZER_MUTEX ThreadArgRetval {
   // will keep pointers alive forever, missing leaks caused by cancelation.
 
  private:
+  static const u32 kInvalidGen = UINT32_MAX;
   struct Data {
     Args args;
     u32 gen;  // Avoid collision if thread id re-used.
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_tls_get_addr.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_tls_get_addr.cpp
index 252979f1c2..ee293bbd68 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_tls_get_addr.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_tls_get_addr.cpp
@@ -121,25 +121,26 @@ DTLS::DTV *DTLS_on_tls_get_addr(void *arg_void, void *res,
   uptr tls_size = 0;
   uptr tls_beg = reinterpret_cast<uptr>(res) - arg->offset - kDtvOffset;
   VReport(2,
-          "__tls_get_addr: %p {0x%zx,0x%zx} => %p; tls_beg: 0x%zx; sp: %p "
+          "__tls_get_addr: %p {0x%zx,0x%zx} => %p; tls_beg: %p; sp: %p "
           "num_live_dtls %zd\n",
-          (void *)arg, arg->dso_id, arg->offset, res, tls_beg, (void *)&tls_beg,
+          (void *)arg, arg->dso_id, arg->offset, res, (void *)tls_beg,
+          (void *)&tls_beg,
           atomic_load(&number_of_live_dtls, memory_order_relaxed));
   if (dtls.last_memalign_ptr == tls_beg) {
     tls_size = dtls.last_memalign_size;
-    VReport(2, "__tls_get_addr: glibc <=2.24 suspected; tls={0x%zx,0x%zx}\n",
-            tls_beg, tls_size);
+    VReport(2, "__tls_get_addr: glibc <=2.24 suspected; tls={%p,0x%zx}\n",
+            (void *)tls_beg, tls_size);
   } else if (tls_beg >= static_tls_begin && tls_beg < static_tls_end) {
     // This is the static TLS block which was initialized / unpoisoned at thread
     // creation.
-    VReport(2, "__tls_get_addr: static tls: 0x%zx\n", tls_beg);
+    VReport(2, "__tls_get_addr: static tls: %p\n", (void *)tls_beg);
     tls_size = 0;
   } else if (const void *start =
                  __sanitizer_get_allocated_begin((void *)tls_beg)) {
     tls_beg = (uptr)start;
     tls_size = __sanitizer_get_allocated_size(start);
-    VReport(2, "__tls_get_addr: glibc >=2.25 suspected; tls={0x%zx,0x%zx}\n",
-            tls_beg, tls_size);
+    VReport(2, "__tls_get_addr: glibc >=2.25 suspected; tls={%p,0x%zx}\n",
+            (void *)tls_beg, tls_size);
   } else {
     VReport(2, "__tls_get_addr: Can't guess glibc version\n");
     // This may happen inside the DTOR of main thread, so just ignore it.
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_unwind_fuchsia.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_unwind_fuchsia.cpp
new file mode 100644
index 0000000000..f3eb8591dc
--- /dev/null
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_unwind_fuchsia.cpp
@@ -0,0 +1,66 @@
+//===------------------ sanitizer_unwind_fuchsia.cpp
+//---------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+/// Sanitizer unwind Fuchsia specific functions.
+//
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_platform.h"
+#if SANITIZER_FUCHSIA
+
+#  include <limits.h>
+#  include <unwind.h>
+
+#  include "sanitizer_common.h"
+#  include "sanitizer_stacktrace.h"
+
+namespace __sanitizer {
+
+#  if SANITIZER_CAN_SLOW_UNWIND
+struct UnwindTraceArg {
+  BufferedStackTrace *stack;
+  u32 max_depth;
+};
+
+_Unwind_Reason_Code Unwind_Trace(struct _Unwind_Context *ctx, void *param) {
+  UnwindTraceArg *arg = static_cast<UnwindTraceArg *>(param);
+  CHECK_LT(arg->stack->size, arg->max_depth);
+  uptr pc = _Unwind_GetIP(ctx);
+  if (pc < GetPageSizeCached())
+    return _URC_NORMAL_STOP;
+  arg->stack->trace_buffer[arg->stack->size++] = pc;
+  return (arg->stack->size == arg->max_depth ? _URC_NORMAL_STOP
+                                             : _URC_NO_REASON);
+}
+
+void BufferedStackTrace::UnwindSlow(uptr pc, u32 max_depth) {
+  CHECK_GE(max_depth, 2);
+  size = 0;
+  UnwindTraceArg arg = {this, Min(max_depth + 1, kStackTraceMax)};
+  _Unwind_Backtrace(Unwind_Trace, &arg);
+  CHECK_GT(size, 0);
+  // We need to pop a few frames so that pc is on top.
+  uptr to_pop = LocatePcInTrace(pc);
+  // trace_buffer[0] belongs to the current function so we always pop it,
+  // unless there is only 1 frame in the stack trace (1 frame is always better
+  // than 0!).
+  PopStackFrames(Min(to_pop, static_cast<uptr>(1)));
+  trace_buffer[0] = pc;
+}
+
+void BufferedStackTrace::UnwindSlow(uptr pc, void *context, u32 max_depth) {
+  CHECK(context);
+  CHECK_GE(max_depth, 2);
+  UNREACHABLE("signal context doesn't exist");
+}
+#  endif  //  SANITIZER_CAN_SLOW_UNWIND
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_FUCHSIA
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_unwind_win.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_unwind_win.cpp
index afcd01dae0..6fc18396ca 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_unwind_win.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_unwind_win.cpp
@@ -70,10 +70,17 @@ void BufferedStackTrace::UnwindSlow(uptr pc, void *context, u32 max_depth) {
   stack_frame.AddrStack.Offset = ctx.Rsp;
 #      endif
 #    else
+#      if SANITIZER_ARM
+  int machine_type = IMAGE_FILE_MACHINE_ARM;
+  stack_frame.AddrPC.Offset = ctx.Pc;
+  stack_frame.AddrFrame.Offset = ctx.R11;
+  stack_frame.AddrStack.Offset = ctx.Sp;
+#      else
   int machine_type = IMAGE_FILE_MACHINE_I386;
   stack_frame.AddrPC.Offset = ctx.Eip;
   stack_frame.AddrFrame.Offset = ctx.Ebp;
   stack_frame.AddrStack.Offset = ctx.Esp;
+#      endif
 #    endif
   stack_frame.AddrPC.Mode = AddrModeFlat;
   stack_frame.AddrFrame.Mode = AddrModeFlat;
diff --git a/zig/lib/tsan/sanitizer_common/sanitizer_win.cpp b/zig/lib/tsan/sanitizer_common/sanitizer_win.cpp
index 06e496523e..8a80d54751 100644
--- a/zig/lib/tsan/sanitizer_common/sanitizer_win.cpp
+++ b/zig/lib/tsan/sanitizer_common/sanitizer_win.cpp
@@ -144,7 +144,7 @@ void *MmapOrDie(uptr size, const char *mem_type, bool raw_report) {
   return rv;
 }
 
-void UnmapOrDie(void *addr, uptr size) {
+void UnmapOrDie(void *addr, uptr size, bool raw_report) {
   if (!size || !addr)
     return;
 
@@ -156,10 +156,7 @@ void UnmapOrDie(void *addr, uptr size) {
   // fails try MEM_DECOMMIT.
   if (VirtualFree(addr, 0, MEM_RELEASE) == 0) {
     if (VirtualFree(addr, size, MEM_DECOMMIT) == 0) {
-      Report("ERROR: %s failed to "
-             "deallocate 0x%zx (%zd) bytes at address %p (error code: %d)\n",
-             SanitizerToolName, size, size, addr, GetLastError());
-      CHECK("unable to unmap" && 0);
+      ReportMunmapFailureAndDie(addr, size, GetLastError(), raw_report);
     }
   }
 }
@@ -279,8 +276,8 @@ void *MmapFixedOrDie(uptr fixed_addr, uptr size, const char *name) {
       MEM_COMMIT, PAGE_READWRITE);
   if (p == 0) {
     char mem_type[30];
-    internal_snprintf(mem_type, sizeof(mem_type), "memory at address 0x%zx",
-                      fixed_addr);
+    internal_snprintf(mem_type, sizeof(mem_type), "memory at address %p",
+                      (void *)fixed_addr);
     ReportMmapFailureAndDie(size, mem_type, "allocate", GetLastError());
   }
   return p;
@@ -311,8 +308,8 @@ void *MmapFixedOrDieOnFatalError(uptr fixed_addr, uptr size, const char *name) {
       MEM_COMMIT, PAGE_READWRITE);
   if (p == 0) {
     char mem_type[30];
-    internal_snprintf(mem_type, sizeof(mem_type), "memory at address 0x%zx",
-                      fixed_addr);
+    internal_snprintf(mem_type, sizeof(mem_type), "memory at address %p",
+                      (void *)fixed_addr);
     return ReturnNullptrOnOOMOrDie(size, mem_type, "allocate");
   }
   return p;
@@ -387,9 +384,8 @@ bool DontDumpShadowMemory(uptr addr, uptr length) {
 }
 
 uptr MapDynamicShadow(uptr shadow_size_bytes, uptr shadow_scale,
-                      uptr min_shadow_base_alignment,
-                      UNUSED uptr &high_mem_end) {
-  const uptr granularity = GetMmapGranularity();
+                      uptr min_shadow_base_alignment, UNUSED uptr &high_mem_end,
+                      uptr granularity) {
   const uptr alignment =
       Max<uptr>(granularity << shadow_scale, 1ULL << min_shadow_base_alignment);
   const uptr left_padding =
@@ -996,8 +992,13 @@ void SignalContext::InitPcSpBp() {
   sp = (uptr)context_record->Rsp;
 #    endif
 #  else
+#    if SANITIZER_ARM
+  bp = (uptr)context_record->R11;
+  sp = (uptr)context_record->Sp;
+#    else
   bp = (uptr)context_record->Ebp;
   sp = (uptr)context_record->Esp;
+#    endif
 #  endif
 }
 
diff --git a/zig/lib/tsan/tsan_debugging.cpp b/zig/lib/tsan/tsan_debugging.cpp
index 1e61c31c5a..41fa293dba 100644
--- a/zig/lib/tsan/tsan_debugging.cpp
+++ b/zig/lib/tsan/tsan_debugging.cpp
@@ -35,7 +35,9 @@ static const char *ReportTypeDescription(ReportType typ) {
     case ReportTypeSignalUnsafe: return "signal-unsafe-call";
     case ReportTypeErrnoInSignal: return "errno-in-signal-handler";
     case ReportTypeDeadlock: return "lock-order-inversion";
-    // No default case so compiler warns us if we miss one
+    case ReportTypeMutexHeldWrongContext:
+      return "mutex-held-in-wrong-context";
+      // No default case so compiler warns us if we miss one
   }
   UNREACHABLE("missing case");
 }
diff --git a/zig/lib/tsan/tsan_defs.h b/zig/lib/tsan/tsan_defs.h
index 1ffa3d6aec..270d441dc9 100644
--- a/zig/lib/tsan/tsan_defs.h
+++ b/zig/lib/tsan/tsan_defs.h
@@ -30,7 +30,7 @@
 #  define __MM_MALLOC_H
 #  include <emmintrin.h>
 #  include <smmintrin.h>
-#  define VECTOR_ALIGNED ALIGNED(16)
+#  define VECTOR_ALIGNED alignas(16)
 typedef __m128i m128;
 #else
 #  define VECTOR_ALIGNED
diff --git a/zig/lib/tsan/tsan_dispatch_defs.h b/zig/lib/tsan/tsan_dispatch_defs.h
index 54c0b0ba4b..8d38beb0b0 100644
--- a/zig/lib/tsan/tsan_dispatch_defs.h
+++ b/zig/lib/tsan/tsan_dispatch_defs.h
@@ -56,13 +56,6 @@ extern const dispatch_block_t _dispatch_data_destructor_munmap;
 # define DISPATCH_NOESCAPE
 #endif
 
-#if SANITIZER_APPLE
-# define SANITIZER_WEAK_IMPORT extern "C" __attribute((weak_import))
-#else
-# define SANITIZER_WEAK_IMPORT extern "C" __attribute((weak))
-#endif
-
-
 // Data types used in dispatch APIs
 typedef unsigned long size_t;
 typedef unsigned long uintptr_t;
diff --git a/zig/lib/tsan/tsan_interceptors_posix.cpp b/zig/lib/tsan/tsan_interceptors_posix.cpp
index 177e338bf2..9cab2a3727 100644
--- a/zig/lib/tsan/tsan_interceptors_posix.cpp
+++ b/zig/lib/tsan/tsan_interceptors_posix.cpp
@@ -14,6 +14,7 @@
 
 #include "sanitizer_common/sanitizer_atomic.h"
 #include "sanitizer_common/sanitizer_errno.h"
+#include "sanitizer_common/sanitizer_glibc_version.h"
 #include "sanitizer_common/sanitizer_libc.h"
 #include "sanitizer_common/sanitizer_linux.h"
 #include "sanitizer_common/sanitizer_platform_limits_netbsd.h"
@@ -81,6 +82,8 @@ struct ucontext_t {
 #define PTHREAD_ABI_BASE  "GLIBC_2.17"
 #elif SANITIZER_LOONGARCH64
 #define PTHREAD_ABI_BASE  "GLIBC_2.36"
+#elif SANITIZER_RISCV64
+#  define PTHREAD_ABI_BASE "GLIBC_2.27"
 #endif
 
 extern "C" int pthread_attr_init(void *attr);
@@ -205,7 +208,7 @@ struct AtExitCtx {
 struct InterceptorContext {
   // The object is 64-byte aligned, because we want hot data to be located
   // in a single cache line if possible (it's accessed in every interceptor).
-  ALIGNED(64) LibIgnore libignore;
+  alignas(64) LibIgnore libignore;
   __sanitizer_sigaction sigactions[kSigCount];
 #if !SANITIZER_APPLE && !SANITIZER_NETBSD
   unsigned finalize_key;
@@ -217,7 +220,7 @@ struct InterceptorContext {
   InterceptorContext() : libignore(LINKER_INITIALIZED), atexit_mu(MutexTypeAtExit), AtExitStack() {}
 };
 
-static ALIGNED(64) char interceptor_placeholder[sizeof(InterceptorContext)];
+alignas(64) static char interceptor_placeholder[sizeof(InterceptorContext)];
 InterceptorContext *interceptor_ctx() {
   return reinterpret_cast<InterceptorContext*>(&interceptor_placeholder[0]);
 }
@@ -1085,7 +1088,18 @@ TSAN_INTERCEPTOR(int, pthread_join, void *th, void **ret) {
   return res;
 }
 
-DEFINE_REAL_PTHREAD_FUNCTIONS
+// DEFINE_INTERNAL_PTHREAD_FUNCTIONS
+namespace __sanitizer {
+int internal_pthread_create(void *th, void *attr, void *(*callback)(void *),
+                            void *param) {
+  ScopedIgnoreInterceptors ignore;
+  return REAL(pthread_create)(th, attr, callback, param);
+}
+int internal_pthread_join(void *th, void **ret) {
+  ScopedIgnoreInterceptors ignore;
+  return REAL(pthread_join(th, ret));
+}
+}  // namespace __sanitizer
 
 TSAN_INTERCEPTOR(int, pthread_detach, void *th) {
   SCOPED_INTERCEPTOR_RAW(pthread_detach, th);
@@ -1338,7 +1352,7 @@ TSAN_INTERCEPTOR(int, pthread_mutex_destroy, void *m) {
 TSAN_INTERCEPTOR(int, pthread_mutex_lock, void *m) {
   SCOPED_TSAN_INTERCEPTOR(pthread_mutex_lock, m);
   MutexPreLock(thr, pc, (uptr)m);
-  int res = REAL(pthread_mutex_lock)(m);
+  int res = BLOCK_REAL(pthread_mutex_lock)(m);
   if (res == errno_EOWNERDEAD)
     MutexRepair(thr, pc, (uptr)m);
   if (res == 0 || res == errno_EOWNERDEAD)
@@ -1378,6 +1392,22 @@ TSAN_INTERCEPTOR(int, pthread_mutex_unlock, void *m) {
   return res;
 }
 
+#if SANITIZER_LINUX
+TSAN_INTERCEPTOR(int, pthread_mutex_clocklock, void *m,
+                 __sanitizer_clockid_t clock, void *abstime) {
+  SCOPED_TSAN_INTERCEPTOR(pthread_mutex_clocklock, m, clock, abstime);
+  MutexPreLock(thr, pc, (uptr)m);
+  int res = BLOCK_REAL(pthread_mutex_clocklock)(m, clock, abstime);
+  if (res == errno_EOWNERDEAD)
+    MutexRepair(thr, pc, (uptr)m);
+  if (res == 0 || res == errno_EOWNERDEAD)
+    MutexPostLock(thr, pc, (uptr)m);
+  if (res == errno_EINVAL)
+    MutexInvalidAccess(thr, pc, (uptr)m);
+  return res;
+}
+#endif
+
 #if SANITIZER_GLIBC
 #  if !__GLIBC_PREREQ(2, 34)
 // glibc 2.34 applies a non-default version for the two functions. They are no
@@ -1385,7 +1415,7 @@ TSAN_INTERCEPTOR(int, pthread_mutex_unlock, void *m) {
 TSAN_INTERCEPTOR(int, __pthread_mutex_lock, void *m) {
   SCOPED_TSAN_INTERCEPTOR(__pthread_mutex_lock, m);
   MutexPreLock(thr, pc, (uptr)m);
-  int res = REAL(__pthread_mutex_lock)(m);
+  int res = BLOCK_REAL(__pthread_mutex_lock)(m);
   if (res == errno_EOWNERDEAD)
     MutexRepair(thr, pc, (uptr)m);
   if (res == 0 || res == errno_EOWNERDEAD)
@@ -1428,7 +1458,7 @@ TSAN_INTERCEPTOR(int, pthread_spin_destroy, void *m) {
 TSAN_INTERCEPTOR(int, pthread_spin_lock, void *m) {
   SCOPED_TSAN_INTERCEPTOR(pthread_spin_lock, m);
   MutexPreLock(thr, pc, (uptr)m);
-  int res = REAL(pthread_spin_lock)(m);
+  int res = BLOCK_REAL(pthread_spin_lock)(m);
   if (res == 0) {
     MutexPostLock(thr, pc, (uptr)m);
   }
@@ -1503,7 +1533,7 @@ TSAN_INTERCEPTOR(int, pthread_rwlock_timedrdlock, void *m, void *abstime) {
 TSAN_INTERCEPTOR(int, pthread_rwlock_wrlock, void *m) {
   SCOPED_TSAN_INTERCEPTOR(pthread_rwlock_wrlock, m);
   MutexPreLock(thr, pc, (uptr)m);
-  int res = REAL(pthread_rwlock_wrlock)(m);
+  int res = BLOCK_REAL(pthread_rwlock_wrlock)(m);
   if (res == 0) {
     MutexPostLock(thr, pc, (uptr)m);
   }
@@ -1595,47 +1625,40 @@ TSAN_INTERCEPTOR(int, __fxstat, int version, int fd, void *buf) {
     FdAccess(thr, pc, fd);
   return REAL(__fxstat)(version, fd, buf);
 }
-#define TSAN_MAYBE_INTERCEPT___FXSTAT TSAN_INTERCEPT(__fxstat)
+
+TSAN_INTERCEPTOR(int, __fxstat64, int version, int fd, void *buf) {
+  SCOPED_TSAN_INTERCEPTOR(__fxstat64, version, fd, buf);
+  if (fd > 0)
+    FdAccess(thr, pc, fd);
+  return REAL(__fxstat64)(version, fd, buf);
+}
+#define TSAN_MAYBE_INTERCEPT___FXSTAT TSAN_INTERCEPT(__fxstat); TSAN_INTERCEPT(__fxstat64)
 #else
 #define TSAN_MAYBE_INTERCEPT___FXSTAT
 #endif
 
+#if !SANITIZER_GLIBC || __GLIBC_PREREQ(2, 33)
 TSAN_INTERCEPTOR(int, fstat, int fd, void *buf) {
-#if SANITIZER_GLIBC
-  SCOPED_TSAN_INTERCEPTOR(__fxstat, 0, fd, buf);
-  if (fd > 0)
-    FdAccess(thr, pc, fd);
-  return REAL(__fxstat)(0, fd, buf);
-#else
   SCOPED_TSAN_INTERCEPTOR(fstat, fd, buf);
   if (fd > 0)
     FdAccess(thr, pc, fd);
   return REAL(fstat)(fd, buf);
-#endif
-}
-
-#if SANITIZER_GLIBC
-TSAN_INTERCEPTOR(int, __fxstat64, int version, int fd, void *buf) {
-  SCOPED_TSAN_INTERCEPTOR(__fxstat64, version, fd, buf);
-  if (fd > 0)
-    FdAccess(thr, pc, fd);
-  return REAL(__fxstat64)(version, fd, buf);
 }
-#define TSAN_MAYBE_INTERCEPT___FXSTAT64 TSAN_INTERCEPT(__fxstat64)
+#  define TSAN_MAYBE_INTERCEPT_FSTAT TSAN_INTERCEPT(fstat)
 #else
-#define TSAN_MAYBE_INTERCEPT___FXSTAT64
+#  define TSAN_MAYBE_INTERCEPT_FSTAT
 #endif
 
-#if SANITIZER_GLIBC
+#if __GLIBC_PREREQ(2, 33)
 TSAN_INTERCEPTOR(int, fstat64, int fd, void *buf) {
-  SCOPED_TSAN_INTERCEPTOR(__fxstat64, 0, fd, buf);
+  SCOPED_TSAN_INTERCEPTOR(fstat64, fd, buf);
   if (fd > 0)
     FdAccess(thr, pc, fd);
-  return REAL(__fxstat64)(0, fd, buf);
+  return REAL(fstat64)(fd, buf);
 }
-#define TSAN_MAYBE_INTERCEPT_FSTAT64 TSAN_INTERCEPT(fstat64)
+#  define TSAN_MAYBE_INTERCEPT_FSTAT64 TSAN_INTERCEPT(fstat64)
 #else
-#define TSAN_MAYBE_INTERCEPT_FSTAT64
+#  define TSAN_MAYBE_INTERCEPT_FSTAT64
 #endif
 
 TSAN_INTERCEPTOR(int, open, const char *name, int oflag, ...) {
@@ -2565,7 +2588,7 @@ int sigaction_impl(int sig, const __sanitizer_sigaction *act,
     // Copy act into sigactions[sig].
     // Can't use struct copy, because compiler can emit call to memcpy.
     // Can't use internal_memcpy, because it copies byte-by-byte,
-    // and signal handler reads the handler concurrently. It it can read
+    // and signal handler reads the handler concurrently. It can read
     // some bytes from old value and some bytes from new value.
     // Use volatile to prevent insertion of memcpy.
     sigactions[sig].handler =
@@ -2655,6 +2678,25 @@ static USED void syscall_fd_release(uptr pc, int fd) {
   FdRelease(thr, pc, fd);
 }
 
+static USED void sycall_blocking_start() {
+  DPrintf("sycall_blocking_start()\n");
+  ThreadState *thr = cur_thread();
+  EnterBlockingFunc(thr);
+  // When we are in a "blocking call", we process signals asynchronously
+  // (right when they arrive). In this context we do not expect to be
+  // executing any user/runtime code. The known interceptor sequence when
+  // this is not true is: pthread_join -> munmap(stack). It's fine
+  // to ignore munmap in this case -- we handle stack shadow separately.
+  thr->ignore_interceptors++;
+}
+
+static USED void sycall_blocking_end() {
+  DPrintf("sycall_blocking_end()\n");
+  ThreadState *thr = cur_thread();
+  thr->ignore_interceptors--;
+  atomic_store(&thr->in_blocking_func, 0, memory_order_relaxed);
+}
+
 static void syscall_pre_fork(uptr pc) { ForkBefore(cur_thread(), pc); }
 
 static void syscall_post_fork(uptr pc, int pid) {
@@ -2709,6 +2751,9 @@ static void syscall_post_fork(uptr pc, int pid) {
 #define COMMON_SYSCALL_POST_FORK(res) \
   syscall_post_fork(GET_CALLER_PC(), res)
 
+#define COMMON_SYSCALL_BLOCKING_START() sycall_blocking_start()
+#define COMMON_SYSCALL_BLOCKING_END() sycall_blocking_end()
+
 #include "sanitizer_common/sanitizer_common_syscalls.inc"
 #include "sanitizer_common/sanitizer_syscalls_netbsd.inc"
 
@@ -2843,8 +2888,21 @@ void InitializeInterceptors() {
   REAL(memcpy) = internal_memcpy;
 #endif
 
+  __interception::DoesNotSupportStaticLinking();
+
   new(interceptor_ctx()) InterceptorContext();
 
+  // Interpose __tls_get_addr before the common interposers. This is needed
+  // because dlsym() may call malloc on failure which could result in other
+  // interposed functions being called that could eventually make use of TLS.
+#ifdef NEED_TLS_GET_ADDR
+#  if !SANITIZER_S390
+  TSAN_INTERCEPT(__tls_get_addr);
+#  else
+  TSAN_INTERCEPT(__tls_get_addr_internal);
+  TSAN_INTERCEPT(__tls_get_offset);
+#  endif
+#endif
   InitializeCommonInterceptors();
   InitializeSignalInterceptors();
   InitializeLibdispatchInterceptors();
@@ -2900,6 +2958,9 @@ void InitializeInterceptors() {
   TSAN_INTERCEPT(pthread_mutex_trylock);
   TSAN_INTERCEPT(pthread_mutex_timedlock);
   TSAN_INTERCEPT(pthread_mutex_unlock);
+#if SANITIZER_LINUX
+  TSAN_INTERCEPT(pthread_mutex_clocklock);
+#endif
 #if SANITIZER_GLIBC
 #  if !__GLIBC_PREREQ(2, 34)
   TSAN_INTERCEPT(__pthread_mutex_lock);
@@ -2929,10 +2990,9 @@ void InitializeInterceptors() {
 
   TSAN_INTERCEPT(pthread_once);
 
-  TSAN_INTERCEPT(fstat);
   TSAN_MAYBE_INTERCEPT___FXSTAT;
+  TSAN_MAYBE_INTERCEPT_FSTAT;
   TSAN_MAYBE_INTERCEPT_FSTAT64;
-  TSAN_MAYBE_INTERCEPT___FXSTAT64;
   TSAN_INTERCEPT(open);
   TSAN_MAYBE_INTERCEPT_OPEN64;
   TSAN_INTERCEPT(creat);
@@ -2989,15 +3049,6 @@ void InitializeInterceptors() {
   TSAN_INTERCEPT(__cxa_atexit);
   TSAN_INTERCEPT(_exit);
 
-#ifdef NEED_TLS_GET_ADDR
-#if !SANITIZER_S390
-  TSAN_INTERCEPT(__tls_get_addr);
-#else
-  TSAN_INTERCEPT(__tls_get_addr_internal);
-  TSAN_INTERCEPT(__tls_get_offset);
-#endif
-#endif
-
   TSAN_MAYBE_INTERCEPT__LWP_EXIT;
   TSAN_MAYBE_INTERCEPT_THR_EXIT;
 
diff --git a/zig/lib/tsan/tsan_interface.h b/zig/lib/tsan/tsan_interface.h
index d53c1e3935..3731c90d45 100644
--- a/zig/lib/tsan/tsan_interface.h
+++ b/zig/lib/tsan/tsan_interface.h
@@ -419,6 +419,14 @@ void __tsan_go_atomic32_fetch_add(ThreadState *thr, uptr cpc, uptr pc, u8 *a);
 SANITIZER_INTERFACE_ATTRIBUTE
 void __tsan_go_atomic64_fetch_add(ThreadState *thr, uptr cpc, uptr pc, u8 *a);
 SANITIZER_INTERFACE_ATTRIBUTE
+void __tsan_go_atomic32_fetch_and(ThreadState *thr, uptr cpc, uptr pc, u8 *a);
+SANITIZER_INTERFACE_ATTRIBUTE
+void __tsan_go_atomic64_fetch_and(ThreadState *thr, uptr cpc, uptr pc, u8 *a);
+SANITIZER_INTERFACE_ATTRIBUTE
+void __tsan_go_atomic32_fetch_or(ThreadState *thr, uptr cpc, uptr pc, u8 *a);
+SANITIZER_INTERFACE_ATTRIBUTE
+void __tsan_go_atomic64_fetch_or(ThreadState *thr, uptr cpc, uptr pc, u8 *a);
+SANITIZER_INTERFACE_ATTRIBUTE
 void __tsan_go_atomic32_exchange(ThreadState *thr, uptr cpc, uptr pc, u8 *a);
 SANITIZER_INTERFACE_ATTRIBUTE
 void __tsan_go_atomic64_exchange(ThreadState *thr, uptr cpc, uptr pc, u8 *a);
diff --git a/zig/lib/tsan/tsan_interface_ann.cpp b/zig/lib/tsan/tsan_interface_ann.cpp
index 6bd72e18d9..befd6a3690 100644
--- a/zig/lib/tsan/tsan_interface_ann.cpp
+++ b/zig/lib/tsan/tsan_interface_ann.cpp
@@ -76,7 +76,7 @@ struct DynamicAnnContext {
 };
 
 static DynamicAnnContext *dyn_ann_ctx;
-static char dyn_ann_ctx_placeholder[sizeof(DynamicAnnContext)] ALIGNED(64);
+alignas(64) static char dyn_ann_ctx_placeholder[sizeof(DynamicAnnContext)];
 
 static void AddExpectRace(ExpectRace *list,
     char *f, int l, uptr addr, uptr size, char *desc) {
@@ -435,4 +435,26 @@ void __tsan_mutex_post_divert(void *addr, unsigned flagz) {
   ThreadIgnoreBegin(thr, 0);
   ThreadIgnoreSyncBegin(thr, 0);
 }
+
+static void ReportMutexHeldWrongContext(ThreadState *thr, uptr pc) {
+  ThreadRegistryLock l(&ctx->thread_registry);
+  ScopedReport rep(ReportTypeMutexHeldWrongContext);
+  for (uptr i = 0; i < thr->mset.Size(); ++i) {
+    MutexSet::Desc desc = thr->mset.Get(i);
+    rep.AddMutex(desc.addr, desc.stack_id);
+  }
+  VarSizeStackTrace trace;
+  ObtainCurrentStack(thr, pc, &trace);
+  rep.AddStack(trace, true);
+  OutputReport(thr, rep);
+}
+
+INTERFACE_ATTRIBUTE
+void __tsan_check_no_mutexes_held() {
+  SCOPED_ANNOTATION(__tsan_check_no_mutexes_held);
+  if (thr->mset.Size() == 0) {
+    return;
+  }
+  ReportMutexHeldWrongContext(thr, pc);
+}
 }  // extern "C"
diff --git a/zig/lib/tsan/tsan_interface_atomic.cpp b/zig/lib/tsan/tsan_interface_atomic.cpp
index f794a2fcdd..2b5a2c6ef7 100644
--- a/zig/lib/tsan/tsan_interface_atomic.cpp
+++ b/zig/lib/tsan/tsan_interface_atomic.cpp
@@ -894,6 +894,30 @@ void __tsan_go_atomic64_fetch_add(ThreadState *thr, uptr cpc, uptr pc, u8 *a) {
   ATOMIC_RET(FetchAdd, *(a64*)(a+16), *(a64**)a, *(a64*)(a+8), mo_acq_rel);
 }
 
+SANITIZER_INTERFACE_ATTRIBUTE
+void __tsan_go_atomic32_fetch_and(ThreadState *thr, uptr cpc, uptr pc, u8 *a) {
+  ATOMIC_RET(FetchAnd, *(a32 *)(a + 16), *(a32 **)a, *(a32 *)(a + 8),
+             mo_acq_rel);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __tsan_go_atomic64_fetch_and(ThreadState *thr, uptr cpc, uptr pc, u8 *a) {
+  ATOMIC_RET(FetchAnd, *(a64 *)(a + 16), *(a64 **)a, *(a64 *)(a + 8),
+             mo_acq_rel);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __tsan_go_atomic32_fetch_or(ThreadState *thr, uptr cpc, uptr pc, u8 *a) {
+  ATOMIC_RET(FetchOr, *(a32 *)(a + 16), *(a32 **)a, *(a32 *)(a + 8),
+             mo_acq_rel);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __tsan_go_atomic64_fetch_or(ThreadState *thr, uptr cpc, uptr pc, u8 *a) {
+  ATOMIC_RET(FetchOr, *(a64 *)(a + 16), *(a64 **)a, *(a64 *)(a + 8),
+             mo_acq_rel);
+}
+
 SANITIZER_INTERFACE_ATTRIBUTE
 void __tsan_go_atomic32_exchange(ThreadState *thr, uptr cpc, uptr pc, u8 *a) {
   ATOMIC_RET(Exchange, *(a32*)(a+16), *(a32**)a, *(a32*)(a+8), mo_acq_rel);
diff --git a/zig/lib/tsan/tsan_mman.cpp b/zig/lib/tsan/tsan_mman.cpp
index 6f118e0979..0705365d77 100644
--- a/zig/lib/tsan/tsan_mman.cpp
+++ b/zig/lib/tsan/tsan_mman.cpp
@@ -9,17 +9,19 @@
 // This file is a part of ThreadSanitizer (TSan), a race detector.
 //
 //===----------------------------------------------------------------------===//
+#include "tsan_mman.h"
+
 #include "sanitizer_common/sanitizer_allocator_checks.h"
 #include "sanitizer_common/sanitizer_allocator_interface.h"
 #include "sanitizer_common/sanitizer_allocator_report.h"
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_errno.h"
 #include "sanitizer_common/sanitizer_placement_new.h"
+#include "sanitizer_common/sanitizer_stackdepot.h"
+#include "tsan_flags.h"
 #include "tsan_interface.h"
-#include "tsan_mman.h"
-#include "tsan_rtl.h"
 #include "tsan_report.h"
-#include "tsan_flags.h"
+#include "tsan_rtl.h"
 
 namespace __tsan {
 
@@ -52,7 +54,7 @@ struct MapUnmapCallback {
   }
 };
 
-static char allocator_placeholder[sizeof(Allocator)] ALIGNED(64);
+alignas(64) static char allocator_placeholder[sizeof(Allocator)];
 Allocator *allocator() {
   return reinterpret_cast<Allocator*>(&allocator_placeholder);
 }
@@ -73,7 +75,7 @@ struct GlobalProc {
         internal_alloc_mtx(MutexTypeInternalAlloc) {}
 };
 
-static char global_proc_placeholder[sizeof(GlobalProc)] ALIGNED(64);
+alignas(64) static char global_proc_placeholder[sizeof(GlobalProc)];
 GlobalProc *global_proc() {
   return reinterpret_cast<GlobalProc*>(&global_proc_placeholder);
 }
@@ -115,12 +117,21 @@ ScopedGlobalProcessor::~ScopedGlobalProcessor() {
   gp->mtx.Unlock();
 }
 
-void AllocatorLock() SANITIZER_NO_THREAD_SAFETY_ANALYSIS {
+void AllocatorLockBeforeFork() SANITIZER_NO_THREAD_SAFETY_ANALYSIS {
   global_proc()->internal_alloc_mtx.Lock();
   InternalAllocatorLock();
-}
-
-void AllocatorUnlock() SANITIZER_NO_THREAD_SAFETY_ANALYSIS {
+#if !SANITIZER_APPLE
+  // OS X allocates from hooks, see 6a3958247a.
+  allocator()->ForceLock();
+  StackDepotLockBeforeFork();
+#endif
+}
+
+void AllocatorUnlockAfterFork(bool child) SANITIZER_NO_THREAD_SAFETY_ANALYSIS {
+#if !SANITIZER_APPLE
+  StackDepotUnlockAfterFork(child);
+  allocator()->ForceUnlock();
+#endif
   InternalAllocatorUnlock();
   global_proc()->internal_alloc_mtx.Unlock();
 }
diff --git a/zig/lib/tsan/tsan_mman.h b/zig/lib/tsan/tsan_mman.h
index 2095f28c02..f01bbc4d15 100644
--- a/zig/lib/tsan/tsan_mman.h
+++ b/zig/lib/tsan/tsan_mman.h
@@ -24,8 +24,8 @@ void ReplaceSystemMalloc();
 void AllocatorProcStart(Processor *proc);
 void AllocatorProcFinish(Processor *proc);
 void AllocatorPrintStats();
-void AllocatorLock();
-void AllocatorUnlock();
+void AllocatorLockBeforeFork();
+void AllocatorUnlockAfterFork(bool child);
 void GlobalProcessorLock();
 void GlobalProcessorUnlock();
 
diff --git a/zig/lib/tsan/tsan_platform.h b/zig/lib/tsan/tsan_platform.h
index f0cdaf48ea..377f8aeb8d 100644
--- a/zig/lib/tsan/tsan_platform.h
+++ b/zig/lib/tsan/tsan_platform.h
@@ -46,17 +46,16 @@ enum {
 
 /*
 C/C++ on linux/x86_64 and freebsd/x86_64
-0000 0000 1000 - 0080 0000 0000: main binary and/or MAP_32BIT mappings (512GB)
-0040 0000 0000 - 0100 0000 0000: -
-0100 0000 0000 - 1000 0000 0000: shadow
-1000 0000 0000 - 3000 0000 0000: -
-3000 0000 0000 - 3400 0000 0000: metainfo (memory blocks and sync objects)
-3400 0000 0000 - 5500 0000 0000: -
-5500 0000 0000 - 5680 0000 0000: pie binaries without ASLR or on 4.1+ kernels
-5680 0000 0000 - 7d00 0000 0000: -
-7b00 0000 0000 - 7c00 0000 0000: heap
-7c00 0000 0000 - 7e80 0000 0000: -
-7e80 0000 0000 - 8000 0000 0000: modules and main thread stack
+0000 0000 1000 - 0200 0000 0000: main binary and/or MAP_32BIT mappings (2TB)
+0200 0000 0000 - 1000 0000 0000: -
+1000 0000 0000 - 3000 0000 0000: shadow (32TB)
+3000 0000 0000 - 3800 0000 0000: metainfo (memory blocks and sync objects; 8TB)
+3800 0000 0000 - 5500 0000 0000: -
+5500 0000 0000 - 5a00 0000 0000: pie binaries without ASLR or on 4.1+ kernels
+5a00 0000 0000 - 7200 0000 0000: -
+7200 0000 0000 - 7300 0000 0000: heap (1TB)
+7300 0000 0000 - 7a00 0000 0000: -
+7a00 0000 0000 - 8000 0000 0000: modules and main thread stack (6TB)
 
 C/C++ on netbsd/amd64 can reuse the same mapping:
  * The address space starts from 0x1000 (option with 0x0) and ends with
@@ -72,20 +71,20 @@ C/C++ on netbsd/amd64 can reuse the same mapping:
 */
 struct Mapping48AddressSpace {
   static const uptr kMetaShadowBeg = 0x300000000000ull;
-  static const uptr kMetaShadowEnd = 0x340000000000ull;
-  static const uptr kShadowBeg     = 0x010000000000ull;
-  static const uptr kShadowEnd = 0x100000000000ull;
-  static const uptr kHeapMemBeg    = 0x7b0000000000ull;
-  static const uptr kHeapMemEnd    = 0x7c0000000000ull;
+  static const uptr kMetaShadowEnd = 0x380000000000ull;
+  static const uptr kShadowBeg = 0x100000000000ull;
+  static const uptr kShadowEnd = 0x300000000000ull;
+  static const uptr kHeapMemBeg = 0x720000000000ull;
+  static const uptr kHeapMemEnd = 0x730000000000ull;
   static const uptr kLoAppMemBeg   = 0x000000001000ull;
-  static const uptr kLoAppMemEnd   = 0x008000000000ull;
+  static const uptr kLoAppMemEnd = 0x020000000000ull;
   static const uptr kMidAppMemBeg  = 0x550000000000ull;
-  static const uptr kMidAppMemEnd  = 0x568000000000ull;
-  static const uptr kHiAppMemBeg   = 0x7e8000000000ull;
+  static const uptr kMidAppMemEnd = 0x5a0000000000ull;
+  static const uptr kHiAppMemBeg = 0x7a0000000000ull;
   static const uptr kHiAppMemEnd   = 0x800000000000ull;
-  static const uptr kShadowMsk = 0x780000000000ull;
-  static const uptr kShadowXor = 0x040000000000ull;
-  static const uptr kShadowAdd = 0x000000000000ull;
+  static const uptr kShadowMsk = 0x700000000000ull;
+  static const uptr kShadowXor = 0x000000000000ull;
+  static const uptr kShadowAdd = 0x100000000000ull;
   static const uptr kVdsoBeg       = 0xf000000000000000ull;
 };
 
@@ -377,6 +376,71 @@ struct MappingPPC64_47 {
   static const uptr kMidAppMemEnd = 0;
 };
 
+/*
+C/C++ on linux/riscv64 (39-bit VMA)
+0000 0010 00 - 0200 0000 00: main binary                      ( 8 GB)
+0200 0000 00 - 1000 0000 00: -
+1000 0000 00 - 4000 0000 00: shadow memory                    (64 GB)
+4000 0000 00 - 4800 0000 00: metainfo                         (16 GB)
+4800 0000 00 - 5500 0000 00: -
+5500 0000 00 - 5a00 0000 00: main binary (PIE)                (~8 GB)
+5600 0000 00 - 7c00 0000 00: -
+7d00 0000 00 - 7fff ffff ff: libraries and main thread stack  ( 8 GB)
+
+mmap by default allocates from top downwards
+VDSO sits below loader and above dynamic libraries, within HiApp region.
+Heap starts after program region whose position depends on pie or non-pie.
+Disable tracking them since their locations are not fixed.
+*/
+struct MappingRiscv64_39 {
+  static const uptr kLoAppMemBeg = 0x0000001000ull;
+  static const uptr kLoAppMemEnd = 0x0200000000ull;
+  static const uptr kShadowBeg = 0x1000000000ull;
+  static const uptr kShadowEnd = 0x2000000000ull;
+  static const uptr kMetaShadowBeg = 0x2000000000ull;
+  static const uptr kMetaShadowEnd = 0x2400000000ull;
+  static const uptr kMidAppMemBeg = 0x2aaaaaa000ull;
+  static const uptr kMidAppMemEnd = 0x2c00000000ull;
+  static const uptr kHeapMemBeg = 0x2c00000000ull;
+  static const uptr kHeapMemEnd = 0x2c00000000ull;
+  static const uptr kHiAppMemBeg = 0x3c00000000ull;
+  static const uptr kHiAppMemEnd = 0x3fffffffffull;
+  static const uptr kShadowMsk = 0x3800000000ull;
+  static const uptr kShadowXor = 0x0800000000ull;
+  static const uptr kShadowAdd = 0x0000000000ull;
+  static const uptr kVdsoBeg = 0x4000000000ull;
+};
+
+/*
+C/C++ on linux/riscv64 (48-bit VMA)
+0000 0000 1000 - 0400 0000 0000: main binary                      ( 4 TB)
+0500 0000 0000 - 2000 0000 0000: -
+2000 0000 0000 - 4000 0000 0000: shadow memory                    (32 TB)
+4000 0000 0000 - 4800 0000 0000: metainfo                         ( 8 TB)
+4800 0000 0000 - 5555 5555 5000: -
+5555 5555 5000 - 5a00 0000 0000: main binary (PIE)                (~5 TB)
+5a00 0000 0000 - 7a00 0000 0000: -
+7a00 0000 0000 - 7fff ffff ffff: libraries and main thread stack  ( 6 TB)
+*/
+struct MappingRiscv64_48 {
+  static const uptr kLoAppMemBeg = 0x000000001000ull;
+  static const uptr kLoAppMemEnd = 0x040000000000ull;
+  static const uptr kShadowBeg = 0x200000000000ull;
+  static const uptr kShadowEnd = 0x400000000000ull;
+  static const uptr kMetaShadowBeg = 0x400000000000ull;
+  static const uptr kMetaShadowEnd = 0x480000000000ull;
+  static const uptr kMidAppMemBeg = 0x555555555000ull;
+  static const uptr kMidAppMemEnd = 0x5a0000000000ull;
+  static const uptr kHeapMemBeg = 0x5a0000000000ull;
+  static const uptr kHeapMemEnd = 0x5a0000000000ull;
+  static const uptr kHiAppMemBeg = 0x7a0000000000ull;
+  static const uptr kHiAppMemEnd = 0x7fffffffffffull;
+  static const uptr kShadowMsk = 0x700000000000ull;
+  static const uptr kShadowXor = 0x100000000000ull;
+  static const uptr kShadowAdd = 0x000000000000ull;
+  static const uptr kVdsoBeg = 0x800000000000ull;
+};
+
 /*
 C/C++ on linux/s390x
 While the kernel provides a 64-bit address space, we have to restrict ourselves
@@ -558,6 +622,35 @@ struct MappingGoAarch64 {
   static const uptr kShadowAdd = 0x200000000000ull;
 };
 
+/* Go on linux/loongarch64 (47-bit VMA)
+0000 0000 1000 - 0000 1000 0000: executable
+0000 1000 0000 - 00c0 0000 0000: -
+00c0 0000 0000 - 00e0 0000 0000: heap
+00e0 0000 0000 - 2000 0000 0000: -
+2000 0000 0000 - 2800 0000 0000: shadow
+2800 0000 0000 - 3000 0000 0000: -
+3000 0000 0000 - 3200 0000 0000: metainfo (memory blocks and sync objects)
+3200 0000 0000 - 8000 0000 0000: -
+*/
+struct MappingGoLoongArch64_47 {
+  static const uptr kMetaShadowBeg = 0x300000000000ull;
+  static const uptr kMetaShadowEnd = 0x320000000000ull;
+  static const uptr kShadowBeg = 0x200000000000ull;
+  static const uptr kShadowEnd = 0x280000000000ull;
+  static const uptr kLoAppMemBeg = 0x000000001000ull;
+  static const uptr kLoAppMemEnd = 0x00e000000000ull;
+  static const uptr kMidAppMemBeg = 0;
+  static const uptr kMidAppMemEnd = 0;
+  static const uptr kHiAppMemBeg = 0;
+  static const uptr kHiAppMemEnd = 0;
+  static const uptr kHeapMemBeg = 0;
+  static const uptr kHeapMemEnd = 0;
+  static const uptr kVdsoBeg = 0;
+  static const uptr kShadowMsk = 0;
+  static const uptr kShadowXor = 0;
+  static const uptr kShadowAdd = 0x200000000000ull;
+};
+
 /*
 Go on linux/mips64 (47-bit VMA)
 0000 0000 1000 - 0000 1000 0000: executable
@@ -633,6 +726,8 @@ ALWAYS_INLINE auto SelectMapping(Arg arg) {
   return Func::template Apply<MappingGoS390x>(arg);
 #  elif defined(__aarch64__)
   return Func::template Apply<MappingGoAarch64>(arg);
+#  elif defined(__loongarch_lp64)
+  return Func::template Apply<MappingGoLoongArch64_47>(arg);
 #  elif SANITIZER_WINDOWS
   return Func::template Apply<MappingGoWindows>(arg);
 #  else
@@ -665,6 +760,13 @@ ALWAYS_INLINE auto SelectMapping(Arg arg) {
   }
 #  elif defined(__mips64)
   return Func::template Apply<MappingMips64_40>(arg);
+#  elif SANITIZER_RISCV64
+  switch (vmaSize) {
+    case 39:
+      return Func::template Apply<MappingRiscv64_39>(arg);
+    case 48:
+      return Func::template Apply<MappingRiscv64_48>(arg);
+  }
 #  elif defined(__s390x__)
   return Func::template Apply<MappingS390x>(arg);
 #  else
@@ -686,12 +788,15 @@ void ForEachMapping() {
   Func::template Apply<MappingPPC64_44>();
   Func::template Apply<MappingPPC64_46>();
   Func::template Apply<MappingPPC64_47>();
+  Func::template Apply<MappingRiscv64_39>();
+  Func::template Apply<MappingRiscv64_48>();
   Func::template Apply<MappingS390x>();
   Func::template Apply<MappingGo48>();
   Func::template Apply<MappingGoWindows>();
   Func::template Apply<MappingGoPPC64_46>();
   Func::template Apply<MappingGoPPC64_47>();
   Func::template Apply<MappingGoAarch64>();
+  Func::template Apply<MappingGoLoongArch64_47>();
   Func::template Apply<MappingGoMips64_47>();
   Func::template Apply<MappingGoS390x>();
 }
@@ -919,7 +1024,7 @@ inline uptr RestoreAddr(uptr addr) {
 
 void InitializePlatform();
 void InitializePlatformEarly();
-void CheckAndProtect();
+bool CheckAndProtect(bool protect, bool ignore_heap, bool print_warnings);
 void InitializeShadowMemoryPlatform();
 void WriteMemoryProfile(char *buf, uptr buf_size, u64 uptime_ns);
 int ExtractResolvFDs(void *state, int *fds, int nfd);
diff --git a/zig/lib/tsan/tsan_platform_linux.cpp b/zig/lib/tsan/tsan_platform_linux.cpp
index 384a443c16..621c679a05 100644
--- a/zig/lib/tsan/tsan_platform_linux.cpp
+++ b/zig/lib/tsan/tsan_platform_linux.cpp
@@ -152,7 +152,7 @@ void WriteMemoryProfile(char *buf, uptr buf_size, u64 uptime_ns) {
 #if !SANITIZER_GO
 // Mark shadow for .rodata sections with the special Shadow::kRodata marker.
 // Accesses to .rodata can't race, so this saves time, memory and trace space.
-static void MapRodata() {
+static NOINLINE void MapRodata(char* buffer, uptr size) {
   // First create temp file.
   const char *tmpdir = GetEnv("TMPDIR");
   if (tmpdir == 0)
@@ -163,13 +163,12 @@ static void MapRodata() {
 #endif
   if (tmpdir == 0)
     return;
-  char name[256];
-  internal_snprintf(name, sizeof(name), "%s/tsan.rodata.%d",
+  internal_snprintf(buffer, size, "%s/tsan.rodata.%d",
                     tmpdir, (int)internal_getpid());
-  uptr openrv = internal_open(name, O_RDWR | O_CREAT | O_EXCL, 0600);
+  uptr openrv = internal_open(buffer, O_RDWR | O_CREAT | O_EXCL, 0600);
   if (internal_iserror(openrv))
     return;
-  internal_unlink(name);  // Unlink it now, so that we can reuse the buffer.
+  internal_unlink(buffer);  // Unlink it now, so that we can reuse the buffer.
   fd_t fd = openrv;
   // Fill the file with Shadow::kRodata.
   const uptr kMarkerSize = 512 * 1024 / sizeof(RawShadow);
@@ -188,8 +187,8 @@ static void MapRodata() {
   }
   // Map the file into shadow of .rodata sections.
   MemoryMappingLayout proc_maps(/*cache_enabled*/true);
-  // Reusing the buffer 'name'.
-  MemoryMappedSegment segment(name, ARRAY_SIZE(name));
+  // Reusing the buffer 'buffer'.
+  MemoryMappedSegment segment(buffer, size);
   while (proc_maps.Next(&segment)) {
     if (segment.filename[0] != 0 && segment.filename[0] != '[' &&
         segment.IsReadable() && segment.IsExecutable() &&
@@ -209,11 +208,103 @@ static void MapRodata() {
 }
 
 void InitializeShadowMemoryPlatform() {
-  MapRodata();
+  char buffer[256];  // Keep in a different frame.
+  MapRodata(buffer, sizeof(buffer));
 }
 
 #endif  // #if !SANITIZER_GO
 
+#  if !SANITIZER_GO
+static void ReExecIfNeeded(bool ignore_heap) {
+  // Go maps shadow memory lazily and works fine with limited address space.
+  // Unlimited stack is not a problem as well, because the executable
+  // is not compiled with -pie.
+  bool reexec = false;
+  // TSan doesn't play well with unlimited stack size (as stack
+  // overlaps with shadow memory). If we detect unlimited stack size,
+  // we re-exec the program with limited stack size as a best effort.
+  if (StackSizeIsUnlimited()) {
+    const uptr kMaxStackSize = 32 * 1024 * 1024;
+    VReport(1,
+            "Program is run with unlimited stack size, which wouldn't "
+            "work with ThreadSanitizer.\n"
+            "Re-execing with stack size limited to %zd bytes.\n",
+            kMaxStackSize);
+    SetStackSizeLimitInBytes(kMaxStackSize);
+    reexec = true;
+  }
+
+  if (!AddressSpaceIsUnlimited()) {
+    Report(
+        "WARNING: Program is run with limited virtual address space,"
+        " which wouldn't work with ThreadSanitizer.\n");
+    Report("Re-execing with unlimited virtual address space.\n");
+    SetAddressSpaceUnlimited();
+    reexec = true;
+  }
+
+#    if SANITIZER_LINUX
+#      if SANITIZER_ANDROID && (defined(__aarch64__) || defined(__x86_64__))
+  // ASLR personality check.
+  int old_personality = personality(0xffffffff);
+  bool aslr_on =
+      (old_personality != -1) && ((old_personality & ADDR_NO_RANDOMIZE) == 0);
+
+  // After patch "arm64: mm: support ARCH_MMAP_RND_BITS." is introduced in
+  // linux kernel, the random gap between stack and mapped area is increased
+  // from 128M to 36G on 39-bit aarch64. As it is almost impossible to cover
+  // this big range, we should disable randomized virtual space on aarch64.
+  if (aslr_on) {
+    VReport(1,
+            "WARNING: Program is run with randomized virtual address "
+            "space, which wouldn't work with ThreadSanitizer on Android.\n"
+            "Re-execing with fixed virtual address space.\n");
+    CHECK_NE(personality(old_personality | ADDR_NO_RANDOMIZE), -1);
+    reexec = true;
+  }
+#      endif
+
+  if (reexec) {
+    // Don't check the address space since we're going to re-exec anyway.
+  } else if (!CheckAndProtect(false, ignore_heap, false)) {
+    // ASLR personality check.
+    // N.B. 'personality' is sometimes forbidden by sandboxes, so we only call
+    // this as a last resort (when the memory mapping is incompatible and TSan
+    // would fail anyway).
+    int old_personality = personality(0xffffffff);
+    bool aslr_on =
+        (old_personality != -1) && ((old_personality & ADDR_NO_RANDOMIZE) == 0);
+
+    if (aslr_on) {
+      // Disable ASLR if the memory layout was incompatible.
+      // Alternatively, we could just keep re-execing until we get lucky
+      // with a compatible randomized layout, but the risk is that if it's
+      // not an ASLR-related issue, we will be stuck in an infinite loop of
+      // re-execing (unless we change ReExec to pass a parameter of the
+      // number of retries allowed.)
+      VReport(1,
+              "WARNING: ThreadSanitizer: memory layout is incompatible, "
+              "possibly due to high-entropy ASLR.\n"
+              "Re-execing with fixed virtual address space.\n"
+              "N.B. reducing ASLR entropy is preferable.\n");
+      CHECK_NE(personality(old_personality | ADDR_NO_RANDOMIZE), -1);
+      reexec = true;
+    } else {
+      Printf(
+          "FATAL: ThreadSanitizer: memory layout is incompatible, "
+          "even though ASLR is disabled.\n"
+          "Please file a bug.\n");
+      DumpProcessMap();
+      Die();
+    }
+  }
+#    endif  // SANITIZER_LINUX
+
+  if (reexec)
+    ReExec();
+}
+#  endif
+
 void InitializePlatformEarly() {
   vmaSize =
     (MostSignificantSetBitIndex(GET_CURRENT_FRAME()) + 1);
@@ -238,7 +329,13 @@ void InitializePlatformEarly() {
     Printf("FATAL: Found %zd - Supported 47\n", vmaSize);
     Die();
   }
-# endif
+#    else
+  if (vmaSize != 47) {
+    Printf("FATAL: ThreadSanitizer: unsupported VMA range\n");
+    Printf("FATAL: Found %zd - Supported 47\n", vmaSize);
+    Die();
+  }
+#    endif
 #elif defined(__powerpc64__)
 # if !SANITIZER_GO
   if (vmaSize != 44 && vmaSize != 46 && vmaSize != 47) {
@@ -267,7 +364,22 @@ void InitializePlatformEarly() {
     Die();
   }
 # endif
-#endif
+#  elif SANITIZER_RISCV64
+  // the bottom half of vma is allocated for userspace
+  vmaSize = vmaSize + 1;
+#    if !SANITIZER_GO
+  if (vmaSize != 39 && vmaSize != 48) {
+    Printf("FATAL: ThreadSanitizer: unsupported VMA range\n");
+    Printf("FATAL: Found %zd - Supported 39 and 48\n", vmaSize);
+    Die();
+  }
+#    endif
+#  endif
+
+#  if !SANITIZER_GO
+  // Heap has not been allocated yet
+  ReExecIfNeeded(false);
+#  endif
 }
 
 void InitializePlatform() {
@@ -278,52 +390,34 @@ void InitializePlatform() {
   // is not compiled with -pie.
 #if !SANITIZER_GO
   {
-    bool reexec = false;
-    // TSan doesn't play well with unlimited stack size (as stack
-    // overlaps with shadow memory). If we detect unlimited stack size,
-    // we re-exec the program with limited stack size as a best effort.
-    if (StackSizeIsUnlimited()) {
-      const uptr kMaxStackSize = 32 * 1024 * 1024;
-      VReport(1, "Program is run with unlimited stack size, which wouldn't "
-                 "work with ThreadSanitizer.\n"
-                 "Re-execing with stack size limited to %zd bytes.\n",
-              kMaxStackSize);
-      SetStackSizeLimitInBytes(kMaxStackSize);
-      reexec = true;
-    }
-
-    if (!AddressSpaceIsUnlimited()) {
-      Report("WARNING: Program is run with limited virtual address space,"
-             " which wouldn't work with ThreadSanitizer.\n");
-      Report("Re-execing with unlimited virtual address space.\n");
-      SetAddressSpaceUnlimited();
-      reexec = true;
-    }
-#if SANITIZER_ANDROID && (defined(__aarch64__) || defined(__x86_64__))
-    // After patch "arm64: mm: support ARCH_MMAP_RND_BITS." is introduced in
-    // linux kernel, the random gap between stack and mapped area is increased
-    // from 128M to 36G on 39-bit aarch64. As it is almost impossible to cover
-    // this big range, we should disable randomized virtual space on aarch64.
-    // ASLR personality check.
-    int old_personality = personality(0xffffffff);
-    if (old_personality != -1 && (old_personality & ADDR_NO_RANDOMIZE) == 0) {
-      VReport(1, "WARNING: Program is run with randomized virtual address "
-              "space, which wouldn't work with ThreadSanitizer.\n"
-              "Re-execing with fixed virtual address space.\n");
-      CHECK_NE(personality(old_personality | ADDR_NO_RANDOMIZE), -1);
-      reexec = true;
-    }
-
-#endif
-#if SANITIZER_LINUX && (defined(__aarch64__) || defined(__loongarch_lp64))
+#    if SANITIZER_LINUX && (defined(__aarch64__) || defined(__loongarch_lp64))
     // Initialize the xor key used in {sig}{set,long}jump.
     InitializeLongjmpXorKey();
-#endif
-    if (reexec)
-      ReExec();
+#    endif
+  }
+
+  // We called ReExecIfNeeded() in InitializePlatformEarly(), but there are
+  // intervening allocations that result in an edge case:
+  // 1) InitializePlatformEarly(): memory layout is compatible
+  // 2) Intervening allocations happen
+  // 3) InitializePlatform(): memory layout is incompatible and fails
+  //    CheckAndProtect()
+#    if !SANITIZER_GO
+  // Heap has already been allocated
+  ReExecIfNeeded(true);
+#    endif
+
+  // Earlier initialization steps already re-exec'ed until we got a compatible
+  // memory layout, so we don't expect any more issues here.
+  if (!CheckAndProtect(true, true, true)) {
+    Printf(
+        "FATAL: ThreadSanitizer: unexpectedly found incompatible memory "
+        "layout.\n");
+    Printf("FATAL: Please file a bug.\n");
+    DumpProcessMap();
+    Die();
   }
 
-  CheckAndProtect();
   InitTlsSize();
 #endif  // !SANITIZER_GO
 }
@@ -399,13 +493,15 @@ static uptr UnmangleLongJmpSp(uptr mangled_sp) {
   return mangled_sp ^ xor_key;
 #elif defined(__mips__)
   return mangled_sp;
-#elif defined(__s390x__)
+#    elif SANITIZER_RISCV64
+  return mangled_sp;
+#    elif defined(__s390x__)
   // tcbhead_t.stack_guard
   uptr xor_key = ((uptr *)__builtin_thread_pointer())[5];
   return mangled_sp ^ xor_key;
-#else
-  #error "Unknown platform"
-#endif
+#    else
+#      error "Unknown platform"
+#    endif
 }
 
 #if SANITIZER_NETBSD
@@ -429,11 +525,13 @@ static uptr UnmangleLongJmpSp(uptr mangled_sp) {
 #  define LONG_JMP_SP_ENV_SLOT 1
 # elif defined(__mips64)
 #  define LONG_JMP_SP_ENV_SLOT 1
-# elif defined(__s390x__)
-#  define LONG_JMP_SP_ENV_SLOT 9
-# else
-#  define LONG_JMP_SP_ENV_SLOT 6
-# endif
+#      elif SANITIZER_RISCV64
+#        define LONG_JMP_SP_ENV_SLOT 13
+#      elif defined(__s390x__)
+#        define LONG_JMP_SP_ENV_SLOT 9
+#      else
+#        define LONG_JMP_SP_ENV_SLOT 6
+#      endif
 #endif
 
 uptr ExtractLongJmpSp(uptr *env) {
diff --git a/zig/lib/tsan/tsan_platform_mac.cpp b/zig/lib/tsan/tsan_platform_mac.cpp
index 1aac0fb275..eb344df168 100644
--- a/zig/lib/tsan/tsan_platform_mac.cpp
+++ b/zig/lib/tsan/tsan_platform_mac.cpp
@@ -46,8 +46,8 @@
 namespace __tsan {
 
 #if !SANITIZER_GO
-static char main_thread_state[sizeof(ThreadState)] ALIGNED(
-    SANITIZER_CACHE_LINE_SIZE);
+alignas(SANITIZER_CACHE_LINE_SIZE) static char main_thread_state[sizeof(
+    ThreadState)];
 static ThreadState *dead_thread_state;
 static pthread_key_t thread_state_key;
 
@@ -239,7 +239,10 @@ static uptr longjmp_xor_key = 0;
 void InitializePlatform() {
   DisableCoreDumperIfNecessary();
 #if !SANITIZER_GO
-  CheckAndProtect();
+  if (!CheckAndProtect(true, true, true)) {
+    Printf("FATAL: ThreadSanitizer: found incompatible memory layout.\n");
+    Die();
+  }
 
   InitializeThreadStateStorage();
 
diff --git a/zig/lib/tsan/tsan_platform_posix.cpp b/zig/lib/tsan/tsan_platform_posix.cpp
index e7dcd664dc..7d5a992dc6 100644
--- a/zig/lib/tsan/tsan_platform_posix.cpp
+++ b/zig/lib/tsan/tsan_platform_posix.cpp
@@ -94,22 +94,51 @@ static void ProtectRange(uptr beg, uptr end) {
   }
 }
 
-void CheckAndProtect() {
+// CheckAndProtect will check if the memory layout is compatible with TSan.
+// Optionally (if 'protect' is true), it will set the memory regions between
+// app memory to be inaccessible.
+// 'ignore_heap' means it will not consider heap memory allocations to be a
+// conflict. Set this based on whether we are calling CheckAndProtect before
+// or after the allocator has initialized the heap.
+bool CheckAndProtect(bool protect, bool ignore_heap, bool print_warnings) {
   // Ensure that the binary is indeed compiled with -pie.
   MemoryMappingLayout proc_maps(true);
   MemoryMappedSegment segment;
   while (proc_maps.Next(&segment)) {
-    if (IsAppMem(segment.start)) continue;
+    if (segment.start >= HeapMemBeg() && segment.end <= HeapEnd()) {
+      if (ignore_heap) {
+        continue;
+      } else {
+        return false;
+      }
+    }
+
+    // Note: IsAppMem includes if it is heap memory, hence we must
+    // put this check after the heap bounds check.
+    if (IsAppMem(segment.start) && IsAppMem(segment.end - 1))
+      continue;
+
+    // Guard page after the heap end
     if (segment.start >= HeapMemEnd() && segment.start < HeapEnd()) continue;
+
     if (segment.protection == 0)  // Zero page or mprotected.
       continue;
+
     if (segment.start >= VdsoBeg())  // vdso
       break;
-    Printf("FATAL: ThreadSanitizer: unexpected memory mapping 0x%zx-0x%zx\n",
-           segment.start, segment.end);
-    Die();
+
+    // Debug output can break tests. Suppress this message in most cases.
+    if (print_warnings)
+      Printf(
+          "WARNING: ThreadSanitizer: unexpected memory mapping 0x%zx-0x%zx\n",
+          segment.start, segment.end);
+
+    return false;
   }
 
+  if (!protect)
+    return true;
+
 #    if SANITIZER_IOS && !SANITIZER_IOSSIM
   ProtectRange(HeapMemEnd(), ShadowBeg());
   ProtectRange(ShadowEnd(), MetaShadowBeg());
@@ -135,8 +164,10 @@ void CheckAndProtect() {
   // Older s390x kernels may not support 5-level page tables.
   TryProtectRange(user_addr_max_l4, user_addr_max_l5);
 #endif
+
+  return true;
 }
-#endif
+#  endif
 
 }  // namespace __tsan
 
diff --git a/zig/lib/tsan/tsan_preinit.cpp b/zig/lib/tsan/tsan_preinit.cpp
index 205bdbf93b..69700f2dde 100644
--- a/zig/lib/tsan/tsan_preinit.cpp
+++ b/zig/lib/tsan/tsan_preinit.cpp
@@ -16,11 +16,9 @@
 
 #if SANITIZER_CAN_USE_PREINIT_ARRAY
 
-// The symbol is called __local_tsan_preinit, because it's not intended to be
-// exported.
-// This code linked into the main executable when -fsanitize=thread is in
-// the link flags. It can only use exported interface functions.
-__attribute__((section(".preinit_array"), used))
-void (*__local_tsan_preinit)(void) = __tsan_init;
+// This section is linked into the main executable when -fsanitize=thread is
+// specified to perform initialization at a very early stage.
+__attribute__((section(".preinit_array"), used)) static auto preinit =
+    __tsan_init;
 
 #endif
diff --git a/zig/lib/tsan/tsan_report.cpp b/zig/lib/tsan/tsan_report.cpp
index 3ae666e121..22ba428cc5 100644
--- a/zig/lib/tsan/tsan_report.cpp
+++ b/zig/lib/tsan/tsan_report.cpp
@@ -93,7 +93,9 @@ static const char *ReportTypeString(ReportType typ, uptr tag) {
       return "signal handler spoils errno";
     case ReportTypeDeadlock:
       return "lock-order-inversion (potential deadlock)";
-    // No default case so compiler warns us if we miss one
+    case ReportTypeMutexHeldWrongContext:
+      return "mutex held in the wrong context";
+      // No default case so compiler warns us if we miss one
   }
   UNREACHABLE("missing case");
 }
@@ -106,10 +108,10 @@ void PrintStack(const ReportStack *ent) {
   SymbolizedStack *frame = ent->frames;
   for (int i = 0; frame && frame->info.address; frame = frame->next, i++) {
     InternalScopedString res;
-    RenderFrame(&res, common_flags()->stack_trace_format, i,
-                frame->info.address, &frame->info,
-                common_flags()->symbolize_vs_style,
-                common_flags()->strip_path_prefix);
+    StackTracePrinter::GetOrInit()->RenderFrame(
+        &res, common_flags()->stack_trace_format, i, frame->info.address,
+        &frame->info, common_flags()->symbolize_vs_style,
+        common_flags()->strip_path_prefix);
     Printf("%s\n", res.data());
   }
   Printf("\n");
@@ -271,26 +273,10 @@ static ReportStack *ChooseSummaryStack(const ReportDesc *rep) {
   return 0;
 }
 
-static bool FrameIsInternal(const SymbolizedStack *frame) {
-  if (frame == 0)
-    return false;
-  const char *file = frame->info.file;
-  const char *module = frame->info.module;
-  if (file != 0 &&
-      (internal_strstr(file, "tsan_interceptors_posix.cpp") ||
-       internal_strstr(file, "tsan_interceptors_memintrinsics.cpp") ||
-       internal_strstr(file, "sanitizer_common_interceptors.inc") ||
-       internal_strstr(file, "tsan_interface_")))
-    return true;
-  if (module != 0 && (internal_strstr(module, "libclang_rt.tsan_")))
-    return true;
-  return false;
-}
-
-static SymbolizedStack *SkipTsanInternalFrames(SymbolizedStack *frames) {
-  while (FrameIsInternal(frames) && frames->next)
-    frames = frames->next;
-  return frames;
+static const SymbolizedStack *SkipTsanInternalFrames(SymbolizedStack *frames) {
+  if (const SymbolizedStack *f = SkipInternalFrames(frames))
+    return f;
+  return frames;  // Fallback to the top frame.
 }
 
 void PrintReport(const ReportDesc *rep) {
@@ -364,7 +350,7 @@ void PrintReport(const ReportDesc *rep) {
     Printf("  And %d more similar thread leaks.\n\n", rep->count - 1);
 
   if (ReportStack *stack = ChooseSummaryStack(rep)) {
-    if (SymbolizedStack *frame = SkipTsanInternalFrames(stack->frames))
+    if (const SymbolizedStack *frame = SkipTsanInternalFrames(stack->frames))
       ReportErrorSummary(rep_typ_str, frame->info);
   }
 
diff --git a/zig/lib/tsan/tsan_report.h b/zig/lib/tsan/tsan_report.h
index 3c88864af1..bfe470797f 100644
--- a/zig/lib/tsan/tsan_report.h
+++ b/zig/lib/tsan/tsan_report.h
@@ -34,7 +34,8 @@ enum ReportType {
   ReportTypeMutexBadReadUnlock,
   ReportTypeSignalUnsafe,
   ReportTypeErrnoInSignal,
-  ReportTypeDeadlock
+  ReportTypeDeadlock,
+  ReportTypeMutexHeldWrongContext
 };
 
 struct ReportStack {
diff --git a/zig/lib/tsan/tsan_rtl.cpp b/zig/lib/tsan/tsan_rtl.cpp
index 6b1ec1d04f..bf29aa316f 100644
--- a/zig/lib/tsan/tsan_rtl.cpp
+++ b/zig/lib/tsan/tsan_rtl.cpp
@@ -35,8 +35,10 @@ extern "C" void __tsan_resume() {
   __tsan_resumed = 1;
 }
 
+#if SANITIZER_APPLE
 SANITIZER_WEAK_DEFAULT_IMPL
 void __tsan_test_only_on_fork() {}
+#endif
 
 namespace __tsan {
 
@@ -46,11 +48,10 @@ int (*on_finalize)(int);
 #endif
 
 #if !SANITIZER_GO && !SANITIZER_APPLE
-__attribute__((tls_model("initial-exec")))
-THREADLOCAL char cur_thread_placeholder[sizeof(ThreadState)] ALIGNED(
-    SANITIZER_CACHE_LINE_SIZE);
+alignas(SANITIZER_CACHE_LINE_SIZE) THREADLOCAL __attribute__((tls_model(
+    "initial-exec"))) char cur_thread_placeholder[sizeof(ThreadState)];
 #endif
-static char ctx_placeholder[sizeof(Context)] ALIGNED(SANITIZER_CACHE_LINE_SIZE);
+alignas(SANITIZER_CACHE_LINE_SIZE) static char ctx_placeholder[sizeof(Context)];
 Context *ctx;
 
 // Can be overriden by a front-end.
@@ -446,7 +447,7 @@ static bool InitializeMemoryProfiler() {
     ctx->memprof_fd = 2;
   } else {
     InternalScopedString filename;
-    filename.append("%s.%d", fname, (int)internal_getpid());
+    filename.AppendF("%s.%d", fname, (int)internal_getpid());
     ctx->memprof_fd = OpenFile(filename.data(), WrOnly);
     if (ctx->memprof_fd == kInvalidFd) {
       Printf("ThreadSanitizer: failed to open memory profile file '%s'\n",
@@ -813,7 +814,7 @@ void ForkBefore(ThreadState* thr, uptr pc) SANITIZER_NO_THREAD_SAFETY_ANALYSIS {
   ctx->thread_registry.Lock();
   ctx->slot_mtx.Lock();
   ScopedErrorReportLock::Lock();
-  AllocatorLock();
+  AllocatorLockBeforeFork();
   // Suppress all reports in the pthread_atfork callbacks.
   // Reports will deadlock on the report_mtx.
   // We could ignore sync operations as well,
@@ -828,14 +829,17 @@ void ForkBefore(ThreadState* thr, uptr pc) SANITIZER_NO_THREAD_SAFETY_ANALYSIS {
   // Disables memory write in OnUserAlloc/Free.
   thr->ignore_reads_and_writes++;
 
+#  if SANITIZER_APPLE
   __tsan_test_only_on_fork();
+#  endif
 }
 
-static void ForkAfter(ThreadState* thr) SANITIZER_NO_THREAD_SAFETY_ANALYSIS {
+static void ForkAfter(ThreadState* thr,
+                      bool child) SANITIZER_NO_THREAD_SAFETY_ANALYSIS {
   thr->suppress_reports--;  // Enabled in ForkBefore.
   thr->ignore_interceptors--;
   thr->ignore_reads_and_writes--;
-  AllocatorUnlock();
+  AllocatorUnlockAfterFork(child);
   ScopedErrorReportLock::Unlock();
   ctx->slot_mtx.Unlock();
   ctx->thread_registry.Unlock();
@@ -845,10 +849,10 @@ static void ForkAfter(ThreadState* thr) SANITIZER_NO_THREAD_SAFETY_ANALYSIS {
   GlobalProcessorUnlock();
 }
 
-void ForkParentAfter(ThreadState* thr, uptr pc) { ForkAfter(thr); }
+void ForkParentAfter(ThreadState* thr, uptr pc) { ForkAfter(thr, false); }
 
 void ForkChildAfter(ThreadState* thr, uptr pc, bool start_thread) {
-  ForkAfter(thr);
+  ForkAfter(thr, true);
   u32 nthread = ctx->thread_registry.OnFork(thr->tid);
   VPrintf(1,
           "ThreadSanitizer: forked new process with pid %d,"
diff --git a/zig/lib/tsan/tsan_rtl.h b/zig/lib/tsan/tsan_rtl.h
index a5606dbc7f..f48be8e0a4 100644
--- a/zig/lib/tsan/tsan_rtl.h
+++ b/zig/lib/tsan/tsan_rtl.h
@@ -56,8 +56,8 @@ namespace __tsan {
 
 #if !SANITIZER_GO
 struct MapUnmapCallback;
-#if defined(__mips64) || defined(__aarch64__) || defined(__loongarch__) || \
-    defined(__powerpc__)
+#  if defined(__mips64) || defined(__aarch64__) || defined(__loongarch__) || \
+      defined(__powerpc__) || SANITIZER_RISCV64
 
 struct AP32 {
   static const uptr kSpaceBeg = 0;
@@ -136,7 +136,7 @@ struct TidEpoch {
   Epoch epoch;
 };
 
-struct TidSlot {
+struct alignas(SANITIZER_CACHE_LINE_SIZE) TidSlot {
   Mutex mtx;
   Sid sid;
   atomic_uint32_t raw_epoch;
@@ -153,10 +153,10 @@ struct TidSlot {
   }
 
   TidSlot();
-} ALIGNED(SANITIZER_CACHE_LINE_SIZE);
+};
 
 // This struct is stored in TLS.
-struct ThreadState {
+struct alignas(SANITIZER_CACHE_LINE_SIZE) ThreadState {
   FastState fast_state;
   int ignore_sync;
 #if !SANITIZER_GO
@@ -234,7 +234,7 @@ struct ThreadState {
   const ReportDesc *current_report;
 
   explicit ThreadState(Tid tid);
-} ALIGNED(SANITIZER_CACHE_LINE_SIZE);
+};
 
 #if !SANITIZER_GO
 #if SANITIZER_APPLE || SANITIZER_ANDROID
diff --git a/zig/lib/tsan/tsan_rtl_aarch64.S b/zig/lib/tsan/tsan_rtl_aarch64.S
index c6162659b8..7d920bee4a 100644
--- a/zig/lib/tsan/tsan_rtl_aarch64.S
+++ b/zig/lib/tsan/tsan_rtl_aarch64.S
@@ -2,6 +2,7 @@
 #if defined(__aarch64__)
 
 #include "sanitizer_common/sanitizer_asm.h"
+#include "builtins/assembly.h"
 
 #if !defined(__APPLE__)
 .section .text
@@ -16,6 +17,7 @@ ASM_HIDDEN(__tsan_setjmp)
 ASM_TYPE_FUNCTION(ASM_SYMBOL_INTERCEPTOR(setjmp))
 ASM_SYMBOL_INTERCEPTOR(setjmp):
   CFI_STARTPROC
+  BTI_C
 
   // Save frame/link register
   stp     x29, x30, [sp, -32]!
@@ -66,6 +68,7 @@ ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(setjmp))
 ASM_TYPE_FUNCTION(ASM_SYMBOL_INTERCEPTOR(_setjmp))
 ASM_SYMBOL_INTERCEPTOR(_setjmp):
   CFI_STARTPROC
+  BTI_C
 
   // Save frame/link register
   stp     x29, x30, [sp, -32]!
@@ -116,6 +119,7 @@ ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(_setjmp))
 ASM_TYPE_FUNCTION(ASM_SYMBOL_INTERCEPTOR(sigsetjmp))
 ASM_SYMBOL_INTERCEPTOR(sigsetjmp):
   CFI_STARTPROC
+  BTI_C
 
   // Save frame/link register
   stp     x29, x30, [sp, -32]!
@@ -168,6 +172,7 @@ ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(sigsetjmp))
 ASM_TYPE_FUNCTION(ASM_SYMBOL_INTERCEPTOR(__sigsetjmp))
 ASM_SYMBOL_INTERCEPTOR(__sigsetjmp):
   CFI_STARTPROC
+  BTI_C
 
   // Save frame/link register
   stp     x29, x30, [sp, -32]!
@@ -217,4 +222,6 @@ ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(__sigsetjmp))
 
 NO_EXEC_STACK_DIRECTIVE
 
+GNU_PROPERTY_BTI_PAC
+
 #endif
diff --git a/zig/lib/tsan/tsan_rtl_access.cpp b/zig/lib/tsan/tsan_rtl_access.cpp
index 8b20984a01..cf07686d96 100644
--- a/zig/lib/tsan/tsan_rtl_access.cpp
+++ b/zig/lib/tsan/tsan_rtl_access.cpp
@@ -672,22 +672,28 @@ void MemoryAccessRangeT(ThreadState* thr, uptr pc, uptr addr, uptr size) {
 
 #if SANITIZER_DEBUG
   if (!IsAppMem(addr)) {
-    Printf("Access to non app mem %zx\n", addr);
+    Printf("Access to non app mem start: %p\n", (void*)addr);
     DCHECK(IsAppMem(addr));
   }
   if (!IsAppMem(addr + size - 1)) {
-    Printf("Access to non app mem %zx\n", addr + size - 1);
+    Printf("Access to non app mem end: %p\n", (void*)(addr + size - 1));
     DCHECK(IsAppMem(addr + size - 1));
   }
   if (!IsShadowMem(shadow_mem)) {
-    Printf("Bad shadow addr %p (%zx)\n", static_cast<void*>(shadow_mem), addr);
+    Printf("Bad shadow start addr: %p (%p)\n", shadow_mem, (void*)addr);
     DCHECK(IsShadowMem(shadow_mem));
   }
-  if (!IsShadowMem(shadow_mem + size * kShadowCnt - 1)) {
-    Printf("Bad shadow addr %p (%zx)\n",
-           static_cast<void*>(shadow_mem + size * kShadowCnt - 1),
-           addr + size - 1);
-    DCHECK(IsShadowMem(shadow_mem + size * kShadowCnt - 1));
+
+  RawShadow* shadow_mem_end = reinterpret_cast<RawShadow*>(
+      reinterpret_cast<uptr>(shadow_mem) + size * kShadowMultiplier - 1);
+  if (!IsShadowMem(shadow_mem_end)) {
+    Printf("Bad shadow end addr: %p (%p)\n", shadow_mem_end,
+           (void*)(addr + size - 1));
+    Printf(
+        "Shadow start addr (ok): %p (%p); size: 0x%zx; kShadowMultiplier: "
+        "%zx\n",
+        shadow_mem, (void*)addr, size, kShadowMultiplier);
+    DCHECK(IsShadowMem(shadow_mem_end));
   }
 #endif
 
diff --git a/zig/lib/tsan/tsan_rtl_loongarch64.S b/zig/lib/tsan/tsan_rtl_loongarch64.S
new file mode 100644
index 0000000000..12856bd110
--- /dev/null
+++ b/zig/lib/tsan/tsan_rtl_loongarch64.S
@@ -0,0 +1,196 @@
+#include "sanitizer_common/sanitizer_asm.h"
+
+.section .text
+
+ASM_HIDDEN(__tsan_setjmp)
+.comm _ZN14__interception11real_setjmpE,8,8
+.globl ASM_SYMBOL_INTERCEPTOR(setjmp)
+ASM_TYPE_FUNCTION(ASM_SYMBOL_INTERCEPTOR(setjmp))
+ASM_SYMBOL_INTERCEPTOR(setjmp):
+  CFI_STARTPROC
+
+  // Save frame pointer and return address register
+  addi.d $sp, $sp, -32
+  st.d $ra, $sp, 24
+  st.d $fp, $sp, 16
+  CFI_DEF_CFA_OFFSET (32)
+  CFI_OFFSET (1, -8)
+  CFI_OFFSET (22, -16)
+
+  // Adjust the SP for previous frame
+  addi.d $fp, $sp, 32
+  CFI_DEF_CFA_REGISTER (22)
+
+  // Save env parameter
+  st.d $a0, $sp, 8
+  CFI_OFFSET (4, -24)
+
+  // Obtain SP, first argument to `void __tsan_setjmp(uptr sp)`
+  addi.d  $a0, $fp, 0
+
+  // call tsan interceptor
+  bl      ASM_SYMBOL(__tsan_setjmp)
+
+  // Restore env parameter
+  ld.d $a0, $sp, 8
+  CFI_RESTORE (4)
+
+  // Restore frame/link register
+  ld.d $fp, $sp, 16
+  ld.d $ra, $sp, 24
+  addi.d $sp, $sp, 32
+  CFI_RESTORE (22)
+  CFI_RESTORE (1)
+  CFI_DEF_CFA (3, 0)
+
+  // tail jump to libc setjmp
+  la.local $a1, _ZN14__interception11real_setjmpE
+  ld.d $a1, $a1, 0
+  jr $a1
+
+  CFI_ENDPROC
+ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(setjmp))
+
+.comm _ZN14__interception12real__setjmpE,8,8
+.globl ASM_SYMBOL_INTERCEPTOR(_setjmp)
+ASM_TYPE_FUNCTION(ASM_SYMBOL_INTERCEPTOR(_setjmp))
+ASM_SYMBOL_INTERCEPTOR(_setjmp):
+  CFI_STARTPROC
+
+  // Save frame pointer and return address register
+  addi.d $sp, $sp, -32
+  st.d $ra, $sp, 24
+  st.d $fp, $sp, 16
+  CFI_DEF_CFA_OFFSET (32)
+  CFI_OFFSET (1, -8)
+  CFI_OFFSET (22, -16)
+
+  // Adjust the SP for previous frame
+  addi.d $fp, $sp, 32
+  CFI_DEF_CFA_REGISTER (22)
+
+  // Save env parameter
+  st.d $a0, $sp, 8
+  CFI_OFFSET (4, -24)
+
+  // Obtain SP, first argument to `void __tsan_setjmp(uptr sp)`
+  addi.d  $a0, $fp, 0
+
+  // call tsan interceptor
+  bl      ASM_SYMBOL(__tsan_setjmp)
+
+  // Restore env parameter
+  ld.d $a0, $sp, 8
+  CFI_RESTORE (4)
+
+  // Restore frame/link register
+  ld.d $fp, $sp, 16
+  ld.d $ra, $sp, 24
+  addi.d $sp, $sp, 32
+  CFI_RESTORE (22)
+  CFI_RESTORE (1)
+  CFI_DEF_CFA (3, 0)
+
+  // tail jump to libc setjmp
+  la.local $a1, _ZN14__interception12real__setjmpE
+  ld.d $a1, $a1, 0
+  jr $a1
+
+  CFI_ENDPROC
+ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(_setjmp))
+
+.comm _ZN14__interception14real_sigsetjmpE,8,8
+.globl ASM_SYMBOL_INTERCEPTOR(sigsetjmp)
+ASM_TYPE_FUNCTION(ASM_SYMBOL_INTERCEPTOR(sigsetjmp))
+ASM_SYMBOL_INTERCEPTOR(sigsetjmp):
+  CFI_STARTPROC
+
+  // Save frame pointer and return address register
+  addi.d $sp, $sp, -32
+  st.d $ra, $sp, 24
+  st.d $fp, $sp, 16
+  CFI_DEF_CFA_OFFSET (32)
+  CFI_OFFSET (1, -8)
+  CFI_OFFSET (22, -16)
+
+  // Adjust the SP for previous frame
+  addi.d $fp, $sp, 32
+  CFI_DEF_CFA_REGISTER (22)
+
+  // Save env parameter
+  st.d $a0, $sp, 8
+  CFI_OFFSET (4, -24)
+
+  // Obtain SP, first argument to `void __tsan_setjmp(uptr sp)`
+  addi.d  $a0, $fp, 0
+
+  // call tsan interceptor
+  bl      ASM_SYMBOL(__tsan_setjmp)
+
+  // Restore env parameter
+  ld.d $a0, $sp, 8
+  CFI_RESTORE (4)
+
+  // Restore frame/link register
+  ld.d $fp, $sp, 16
+  ld.d $ra, $sp, 24
+  addi.d $sp, $sp, 32
+  CFI_RESTORE (22)
+  CFI_RESTORE (1)
+  CFI_DEF_CFA (3, 0)
+
+  // tail jump to libc setjmp
+  la.local $a1, _ZN14__interception14real_sigsetjmpE
+  ld.d $a1, $a1, 0
+  jr $a1
+
+  CFI_ENDPROC
+ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(sigsetjmp))
+
+.comm _ZN14__interception16real___sigsetjmpE,8,8
+.globl ASM_SYMBOL_INTERCEPTOR(__sigsetjmp)
+ASM_TYPE_FUNCTION(ASM_SYMBOL_INTERCEPTOR(__sigsetjmp))
+ASM_SYMBOL_INTERCEPTOR(__sigsetjmp):
+  CFI_STARTPROC
+
+  // Save frame pointer and return address register
+  addi.d $sp, $sp, -32
+  st.d $ra, $sp, 24
+  st.d $fp, $sp, 16
+  CFI_DEF_CFA_OFFSET (32)
+  CFI_OFFSET (1, -8)
+  CFI_OFFSET (22, -16)
+
+  // Adjust the SP for previous frame
+  addi.d $fp, $sp, 32
+  CFI_DEF_CFA_REGISTER (22)
+
+  // Save env parameter
+  st.d $a0, $sp, 8
+  CFI_OFFSET (4, -24)
+
+  // Obtain SP, first argument to `void __tsan_setjmp(uptr sp)`
+  addi.d  $a0, $fp, 0
+
+  // call tsan interceptor
+  bl      ASM_SYMBOL(__tsan_setjmp)
+
+  // Restore env parameter
+  ld.d $a0, $sp, 8
+  CFI_RESTORE (4)
+
+  // Restore frame/link register
+  ld.d $fp, $sp, 16
+  ld.d $ra, $sp, 24
+  addi.d $sp, $sp, 32
+  CFI_RESTORE (22)
+  CFI_RESTORE (1)
+  CFI_DEF_CFA (3, 0)
+
+  // tail jump to libc setjmp
+  la.local $a1, _ZN14__interception16real___sigsetjmpE
+  ld.d $a1, $a1, 0
+  jr $a1
+
+  CFI_ENDPROC
+ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(__sigsetjmp))
diff --git a/zig/lib/tsan/tsan_rtl_mutex.cpp b/zig/lib/tsan/tsan_rtl_mutex.cpp
index 2e978852ea..2a8aa1915c 100644
--- a/zig/lib/tsan/tsan_rtl_mutex.cpp
+++ b/zig/lib/tsan/tsan_rtl_mutex.cpp
@@ -446,9 +446,9 @@ void Acquire(ThreadState *thr, uptr pc, uptr addr) {
   if (!s)
     return;
   SlotLocker locker(thr);
+  ReadLock lock(&s->mtx);
   if (!s->clock)
     return;
-  ReadLock lock(&s->mtx);
   thr->clock.Acquire(s->clock);
 }
 
diff --git a/zig/lib/tsan/tsan_rtl_riscv64.S b/zig/lib/tsan/tsan_rtl_riscv64.S
new file mode 100644
index 0000000000..8e6b9b9432
--- /dev/null
+++ b/zig/lib/tsan/tsan_rtl_riscv64.S
@@ -0,0 +1,203 @@
+#include "sanitizer_common/sanitizer_asm.h"
+
+.section .text
+
+.comm _ZN14__interception11real_setjmpE,8,8
+.globl ASM_SYMBOL_INTERCEPTOR(setjmp)
+ASM_TYPE_FUNCTION(ASM_SYMBOL_INTERCEPTOR(setjmp))
+ASM_SYMBOL_INTERCEPTOR(setjmp):
+  CFI_STARTPROC
+
+  // Save frame pointer and return address register
+  addi sp, sp, -32
+  sd ra, 24(sp)
+  sd s0, 16(sp)
+  CFI_DEF_CFA_OFFSET (32)
+  CFI_OFFSET (1, -8)
+  CFI_OFFSET (8, -16)
+
+  // Adjust the SP for previous frame
+  addi s0, sp, 32
+  CFI_DEF_CFA_REGISTER (8)
+
+  // Save env parameter
+  sd a0, 8(sp)
+  CFI_OFFSET (10, -24)
+
+  // Obtain SP, first argument to `void __tsan_setjmp(uptr sp)`
+  addi  a0, s0, 0
+
+  // call tsan interceptor
+  call ASM_SYMBOL(__tsan_setjmp)
+
+  // Restore env parameter
+  ld a0, 8(sp)
+  CFI_RESTORE (10)
+
+  // Restore frame/link register
+  ld s0, 16(sp)
+  ld ra, 24(sp)
+  addi sp, sp, 32
+  CFI_RESTORE (8)
+  CFI_RESTORE (1)
+  CFI_DEF_CFA (2, 0)
+
+  // tail jump to libc setjmp
+  la t1, _ZN14__interception11real_setjmpE
+  ld t1, 0(t1)
+  jr t1
+
+  CFI_ENDPROC
+ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(setjmp))
+
+.comm _ZN14__interception12real__setjmpE,8,8
+.globl ASM_SYMBOL_INTERCEPTOR(_setjmp)
+ASM_TYPE_FUNCTION(ASM_SYMBOL_INTERCEPTOR(_setjmp))
+ASM_SYMBOL_INTERCEPTOR(_setjmp):
+  CFI_STARTPROC
+
+  // Save frame pointer and return address register
+  addi sp, sp, -32
+  sd ra, 24(sp)
+  sd s0, 16(sp)
+  CFI_DEF_CFA_OFFSET (32)
+  CFI_OFFSET (1, -8)
+  CFI_OFFSET (8, -16)
+
+  // Adjust the SP for previous frame
+  addi s0, sp, 32
+  CFI_DEF_CFA_REGISTER (8)
+
+  // Save env parameter
+  sd a0, 8(sp)
+  CFI_OFFSET (10, -24)
+
+  // Obtain SP, first argument to `void __tsan_setjmp(uptr sp)`
+  addi  a0, s0, 0
+
+  // call tsan interceptor
+  call ASM_SYMBOL(__tsan_setjmp)
+
+  // Restore env parameter
+  ld a0, 8(sp)
+  CFI_RESTORE (10)
+
+  // Restore frame/link register
+  ld s0, 16(sp)
+  ld ra, 24(sp)
+  addi sp, sp, 32
+  CFI_RESTORE (8)
+  CFI_RESTORE (1)
+  CFI_DEF_CFA (2, 0)
+
+  // tail jump to libc setjmp
+  la t1, _ZN14__interception12real__setjmpE
+  ld t1, 0(t1)
+  jr t1
+
+  CFI_ENDPROC
+ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(_setjmp))
+
+.comm _ZN14__interception14real_sigsetjmpE,8,8
+.globl ASM_SYMBOL_INTERCEPTOR(sigsetjmp)
+ASM_TYPE_FUNCTION(ASM_SYMBOL_INTERCEPTOR(sigsetjmp))
+ASM_SYMBOL_INTERCEPTOR(sigsetjmp):
+  CFI_STARTPROC
+
+  // Save frame pointer and return address register
+  addi sp, sp, -32
+  sd ra, 24(sp)
+  sd s0, 16(sp)
+  CFI_DEF_CFA_OFFSET (32)
+  CFI_OFFSET (1, -8)
+  CFI_OFFSET (8, -16)
+
+  // Adjust the SP for previous frame
+  addi s0, sp, 32
+  CFI_DEF_CFA_REGISTER (8)
+
+  // Save env parameter
+  sd a0, 8(sp)
+  sd a1, 0(sp)
+  CFI_OFFSET (10, -24)
+  CFI_OFFSET (11, -32)
+
+  // Obtain SP, first argument to `void __tsan_setjmp(uptr sp)`
+  addi  a0, s0, 0
+
+  // call tsan interceptor
+  call      ASM_SYMBOL(__tsan_setjmp)
+
+  // Restore env parameter
+  ld a0, 8(sp)
+  ld a1, 0(sp)
+  CFI_RESTORE (10)
+  CFI_RESTORE (11)
+
+  // Restore frame/link register
+  ld s0, 16(sp)
+  ld ra, 24(sp)
+  addi sp, sp, 32
+  CFI_RESTORE (8)
+  CFI_RESTORE (1)
+  CFI_DEF_CFA (2, 0)
+
+  // tail jump to libc setjmp
+  la t1, _ZN14__interception14real_sigsetjmpE
+  ld t1, 0(t1)
+  jr t1
+
+  CFI_ENDPROC
+ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(sigsetjmp))
+
+.comm _ZN14__interception16real___sigsetjmpE,8,8
+.globl ASM_SYMBOL_INTERCEPTOR(__sigsetjmp)
+ASM_TYPE_FUNCTION(ASM_SYMBOL_INTERCEPTOR(__sigsetjmp))
+ASM_SYMBOL_INTERCEPTOR(__sigsetjmp):
+  CFI_STARTPROC
+
+  // Save frame pointer and return address register
+  addi sp, sp, -32
+  sd ra, 24(sp)
+  sd s0, 16(sp)
+  CFI_DEF_CFA_OFFSET (32)
+  CFI_OFFSET (1, -8)
+  CFI_OFFSET (8, -16)
+
+  // Adjust the SP for previous frame
+  addi s0, sp, 32
+  CFI_DEF_CFA_REGISTER (8)
+
+  // Save env parameter
+  sd a0, 8(sp)
+  sd a1, 0(sp)
+  CFI_OFFSET (10, -24)
+  CFI_OFFSET (11, -32)
+
+  // Obtain SP, first argument to `void __tsan_setjmp(uptr sp)`
+  addi  a0, s0, 0
+
+  // call tsan interceptor
+  call      ASM_SYMBOL(__tsan_setjmp)
+
+  // Restore env parameter
+  ld a0, 8(sp)
+  ld a1, 0(sp)
+  CFI_RESTORE (10)
+  CFI_RESTORE (11)
+
+  // Restore frame/link register
+  ld s0, 16(sp)
+  ld ra, 24(sp)
+  addi sp, sp, 32
+  CFI_RESTORE (8)
+  CFI_RESTORE (1)
+  CFI_DEF_CFA (2, 0)
+
+  // tail jump to libc setjmp
+  la t1, _ZN14__interception16real___sigsetjmpE
+  ld t1, 0(t1)
+  jr t1
+
+  CFI_ENDPROC
+ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(__sigsetjmp))
diff --git a/zig/lib/tsan/tsan_rtl_s390x.S b/zig/lib/tsan/tsan_rtl_s390x.S
new file mode 100644
index 0000000000..2f445e8f1b
--- /dev/null
+++ b/zig/lib/tsan/tsan_rtl_s390x.S
@@ -0,0 +1,49 @@
+#include "sanitizer_common/sanitizer_asm.h"
+
+#define CFA_OFFSET 160
+#define R2_REL_OFFSET 16
+#define R3_REL_OFFSET 24
+#define R14_REL_OFFSET 112
+#define R15_REL_OFFSET 120
+#define FRAME_SIZE 160
+
+.text
+
+ASM_HIDDEN(__tsan_setjmp)
+
+.macro intercept symbol, real
+.comm \real, 8, 8
+.globl ASM_SYMBOL_INTERCEPTOR(\symbol)
+ASM_TYPE_FUNCTION(ASM_SYMBOL_INTERCEPTOR(\symbol))
+ASM_SYMBOL_INTERCEPTOR(\symbol):
+  CFI_STARTPROC
+  stmg %r2, %r3, R2_REL_OFFSET(%r15)
+  CFI_REL_OFFSET(%r2, R2_REL_OFFSET)
+  CFI_REL_OFFSET(%r3, R3_REL_OFFSET)
+  stmg %r14, %r15, R14_REL_OFFSET(%r15)
+  CFI_REL_OFFSET(%r14, R14_REL_OFFSET)
+  CFI_REL_OFFSET(%r15, R15_REL_OFFSET)
+  aghi %r15, -FRAME_SIZE
+  CFI_ADJUST_CFA_OFFSET(FRAME_SIZE)
+  la %r2, FRAME_SIZE(%r15)
+  brasl %r14, ASM_SYMBOL(__tsan_setjmp)
+  lmg %r14, %r15, FRAME_SIZE + R14_REL_OFFSET(%r15)
+  CFI_RESTORE(%r14)
+  CFI_RESTORE(%r15)
+  CFI_DEF_CFA_OFFSET(CFA_OFFSET)
+  lmg %r2, %r3, R2_REL_OFFSET(%r15)
+  CFI_RESTORE(%r2)
+  CFI_RESTORE(%r3)
+  larl %r1, \real
+  lg %r1, 0(%r1)
+  br %r1
+  CFI_ENDPROC
+  ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(\symbol))
+.endm
+
+intercept setjmp, _ZN14__interception11real_setjmpE
+intercept _setjmp, _ZN14__interception12real__setjmpE
+intercept sigsetjmp, _ZN14__interception14real_sigsetjmpE
+intercept __sigsetjmp, _ZN14__interception16real___sigsetjmpE
+
+NO_EXEC_STACK_DIRECTIVE
diff --git a/zig/lib/tsan/tsan_rtl_thread.cpp b/zig/lib/tsan/tsan_rtl_thread.cpp
index 77488f8432..5316a7862e 100644
--- a/zig/lib/tsan/tsan_rtl_thread.cpp
+++ b/zig/lib/tsan/tsan_rtl_thread.cpp
@@ -160,6 +160,10 @@ void ThreadStart(ThreadState *thr, Tid tid, tid_t os_id,
   }
   Free(thr->tctx->sync);
 
+#if !SANITIZER_GO
+  thr->is_inited = true;
+#endif
+
   uptr stk_addr = 0;
   uptr stk_size = 0;
   uptr tls_addr = 0;
@@ -200,15 +204,11 @@ void ThreadStart(ThreadState *thr, Tid tid, tid_t os_id,
 }
 
 void ThreadContext::OnStarted(void *arg) {
-  thr = static_cast<ThreadState *>(arg);
   DPrintf("#%d: ThreadStart\n", tid);
-  new (thr) ThreadState(tid);
+  thr = new (arg) ThreadState(tid);
   if (common_flags()->detect_deadlocks)
     thr->dd_lt = ctx->dd->CreateLogicalThread(tid);
   thr->tctx = this;
-#if !SANITIZER_GO
-  thr->is_inited = true;
-#endif
 }
 
 void ThreadFinish(ThreadState *thr) {
diff --git a/zig/lib/tsan/tsan_suppressions.cpp b/zig/lib/tsan/tsan_suppressions.cpp
index 9cdfa32a93..0559df06e7 100644
--- a/zig/lib/tsan/tsan_suppressions.cpp
+++ b/zig/lib/tsan/tsan_suppressions.cpp
@@ -42,7 +42,7 @@ const char *__tsan_default_suppressions() {
 
 namespace __tsan {
 
-ALIGNED(64) static char suppression_placeholder[sizeof(SuppressionContext)];
+alignas(64) static char suppression_placeholder[sizeof(SuppressionContext)];
 static SuppressionContext *suppression_ctx = nullptr;
 static const char *kSuppressionTypes[] = {
     kSuppressionRace,   kSuppressionRaceTop, kSuppressionMutex,
@@ -81,6 +81,7 @@ static const char *conv(ReportType typ) {
     case ReportTypeMutexBadUnlock:
     case ReportTypeMutexBadReadLock:
     case ReportTypeMutexBadReadUnlock:
+    case ReportTypeMutexHeldWrongContext:
       return kSuppressionMutex;
     case ReportTypeSignalUnsafe:
     case ReportTypeErrnoInSignal:
diff --git a/zig/lib/tsan/tsan_vector_clock.h b/zig/lib/tsan/tsan_vector_clock.h
index 63b2063021..51d98113d8 100644
--- a/zig/lib/tsan/tsan_vector_clock.h
+++ b/zig/lib/tsan/tsan_vector_clock.h
@@ -34,7 +34,7 @@ class VectorClock {
   VectorClock& operator=(const VectorClock& other);
 
  private:
-  Epoch clk_[kThreadSlotCount] VECTOR_ALIGNED;
+  VECTOR_ALIGNED Epoch clk_[kThreadSlotCount];
 };
 
 ALWAYS_INLINE Epoch VectorClock::Get(Sid sid) const {
diff --git a/zig/lib/zig.h b/zig/lib/zig.h
index 05529feec7..2f2575fdcf 100644
--- a/zig/lib/zig.h
+++ b/zig/lib/zig.h
@@ -248,37 +248,55 @@ typedef char bool;
 
 #if zig_has_builtin(trap)
 #define zig_trap() __builtin_trap()
-#elif _MSC_VER && (_M_IX86 || _M_X64)
+#elif defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_X64))
 #define zig_trap() __ud2()
-#elif _MSC_VER
-#define zig_trap() __fastfail(0)
-#elif defined(__i386__) || defined(__x86_64__)
-#define zig_trap() __asm__ volatile("ud2");
+#elif defined(_MSC_VER)
+#define zig_trap() __fastfail(7)
+#elif defined(__thumb__)
+#define zig_trap() __asm__ volatile("udf #0xfe")
 #elif defined(__arm__) || defined(__aarch64__)
-#define zig_trap() __asm__ volatile("udf #0");
+#define zig_trap() __asm__ volatile("udf #0xfdee")
+#elif defined(__loongarch__) || defined(__powerpc__)
+#define zig_trap() __asm__ volatile(".word 0x0")
+#elif defined(__mips__)
+#define zig_trap() __asm__ volatile(".word 0x3d")
+#elif defined(__riscv)
+#define zig_trap() __asm__ volatile("unimp")
+#elif defined(__s390__)
+#define zig_trap() __asm__ volatile("j 0x2")
+#elif defined(__sparc__)
+#define zig_trap() __asm__ volatile("illtrap")
+#elif defined(__i386__) || defined(__x86_64__)
+#define zig_trap() __asm__ volatile("ud2")
 #else
-#include <stdlib.h>
-#define zig_trap() abort()
+#define zig_trap() zig_trap_unavailable
 #endif
 
 #if zig_has_builtin(debugtrap)
 #define zig_breakpoint() __builtin_debugtrap()
 #elif defined(_MSC_VER) || defined(__MINGW32__) || defined(__MINGW64__)
 #define zig_breakpoint() __debugbreak()
-#elif defined(__i386__) || defined(__x86_64__)
-#define zig_breakpoint() __asm__ volatile("int $0x03");
 #elif defined(__arm__)
-#define zig_breakpoint() __asm__ volatile("bkpt #0");
+#define zig_breakpoint() __asm__ volatile("bkpt #0x0")
 #elif defined(__aarch64__)
-#define zig_breakpoint() __asm__ volatile("brk #0");
-#else
-#include <signal.h>
-#if defined(SIGTRAP)
-#define zig_breakpoint() raise(SIGTRAP)
+#define zig_breakpoint() __asm__ volatile("brk #0xf000")
+#elif defined(__loongarch__)
+#define zig_breakpoint() __asm__ volatile("break 0x0")
+#elif defined(__mips__)
+#define zig_breakpoint() __asm__ volatile("break")
+#elif defined(__powerpc__)
+#define zig_breakpoint() __asm__ volatile("trap")
+#elif defined(__riscv)
+#define zig_breakpoint() __asm__ volatile("ebreak")
+#elif defined(__s390__)
+#define zig_breakpoint() __asm__ volatile("j 0x6")
+#elif defined(__sparc__)
+#define zig_breakpoint() __asm__ volatile("ta 0x1")
+#elif defined(__i386__) || defined(__x86_64__)
+#define zig_breakpoint() __asm__ volatile("int $0x3")
 #else
 #define zig_breakpoint() zig_breakpoint_unavailable
 #endif
-#endif
 
 #if zig_has_builtin(return_address) || defined(zig_gnuc)
 #define zig_return_address() __builtin_extract_return_addr(__builtin_return_address(0))
@@ -3592,7 +3610,6 @@ typedef enum memory_order zig_memory_order;
 #define zig_atomicrmw_add_float zig_atomicrmw_add
 #undef  zig_atomicrmw_sub_float
 #define zig_atomicrmw_sub_float zig_atomicrmw_sub
-#define zig_fence(order) atomic_thread_fence(order)
 #elif defined(__GNUC__)
 typedef int zig_memory_order;
 #define zig_memory_order_relaxed __ATOMIC_RELAXED
@@ -3616,7 +3633,6 @@ typedef int zig_memory_order;
 #define    zig_atomic_load(res, obj,      order, Type, ReprType)       __atomic_load      (obj, &(res), order)
 #undef  zig_atomicrmw_xchg_float
 #define zig_atomicrmw_xchg_float zig_atomicrmw_xchg
-#define zig_fence(order) __atomic_thread_fence(order)
 #elif _MSC_VER && (_M_IX86 || _M_X64)
 #define zig_memory_order_relaxed 0
 #define zig_memory_order_acquire 2
@@ -3637,11 +3653,6 @@ typedef int zig_memory_order;
 #define  zig_atomicrmw_max(res, obj, arg, order, Type, ReprType) res = zig_msvc_atomicrmw_max_ ##Type(obj, arg)
 #define   zig_atomic_store(     obj, arg, order, Type, ReprType)       zig_msvc_atomic_store_  ##Type(obj, arg)
 #define    zig_atomic_load(res, obj,      order, Type, ReprType) res = zig_msvc_atomic_load_   ##order##_##Type(obj)
-#if _M_X64
-#define zig_fence(order) __faststorefence()
-#else
-#define zig_fence(order) zig_msvc_atomic_barrier()
-#endif
 /* TODO: _MSC_VER && (_M_ARM || _M_ARM64) */
 #else
 #define zig_memory_order_relaxed 0
@@ -3663,7 +3674,6 @@ typedef int zig_memory_order;
 #define  zig_atomicrmw_max(res, obj, arg, order, Type, ReprType) zig_atomics_unavailable
 #define   zig_atomic_store(     obj, arg, order, Type, ReprType) zig_atomics_unavailable
 #define    zig_atomic_load(res, obj,      order, Type, ReprType) zig_atomics_unavailable
-#define zig_fence(order) zig_fence_unavailable
 #endif
 
 #if _MSC_VER && (_M_IX86 || _M_X64)
diff --git a/zig/src/Air.zig b/zig/src/Air.zig
index 343694a906..c58020daaa 100644
--- a/zig/src/Air.zig
+++ b/zig/src/Air.zig
@@ -734,10 +734,6 @@ pub const Inst = struct {
         cmpxchg_weak,
         /// Uses the `ty_pl` field with payload `Cmpxchg`.
         cmpxchg_strong,
-        /// Lowers to a memory fence instruction.
-        /// Result type is always void.
-        /// Uses the `fence` field.
-        fence,
         /// Atomically load from a pointer.
         /// Result type is the element type of the pointer.
         /// Uses the `atomic_load` field.
@@ -1066,7 +1062,6 @@ pub const Inst = struct {
             line: u32,
             column: u32,
         },
-        fence: std.builtin.AtomicOrder,
         atomic_load: struct {
             ptr: Ref,
             order: std.builtin.AtomicOrder,
@@ -1478,7 +1473,6 @@ pub fn typeOfIndex(air: *const Air, inst: Air.Inst.Index, ip: *const InternPool)
         .dbg_arg_inline,
         .store,
         .store_safe,
-        .fence,
         .atomic_store_unordered,
         .atomic_store_monotonic,
         .atomic_store_release,
@@ -1653,7 +1647,6 @@ pub fn mustLower(air: Air, inst: Air.Inst.Index, ip: *const InternPool) bool {
         .memcpy,
         .cmpxchg_weak,
         .cmpxchg_strong,
-        .fence,
         .atomic_store_unordered,
         .atomic_store_monotonic,
         .atomic_store_release,
diff --git a/zig/src/Air/types_resolved.zig b/zig/src/Air/types_resolved.zig
index 717729ff1d..5a149b08d2 100644
--- a/zig/src/Air/types_resolved.zig
+++ b/zig/src/Air/types_resolved.zig
@@ -416,7 +416,6 @@ fn checkBody(air: Air, body: []const Air.Inst.Index, zcu: *Zcu) bool {
             .work_item_id,
             .work_group_size,
             .work_group_id,
-            .fence,
             .dbg_stmt,
             .err_return_trace,
             .save_err_return_trace_index,
diff --git a/zig/src/Compilation.zig b/zig/src/Compilation.zig
index 3ca4d376e9..8d276980ea 100644
--- a/zig/src/Compilation.zig
+++ b/zig/src/Compilation.zig
@@ -195,7 +195,6 @@ job_queued_compiler_rt_obj: bool = false,
 job_queued_fuzzer_lib: bool = false,
 job_queued_update_builtin_zig: bool,
 alloc_failure_occurred: bool = false,
-formatted_panics: bool = false,
 last_update_was_cache_hit: bool = false,
 
 c_source_files: []const CSourceFile,
@@ -218,37 +217,37 @@ thread_pool: *ThreadPool,
 
 /// Populated when we build the libc++ static library. A Job to build this is placed in the queue
 /// and resolved before calling linker.flush().
-libcxx_static_lib: ?CRTFile = null,
+libcxx_static_lib: ?CrtFile = null,
 /// Populated when we build the libc++abi static library. A Job to build this is placed in the queue
 /// and resolved before calling linker.flush().
-libcxxabi_static_lib: ?CRTFile = null,
+libcxxabi_static_lib: ?CrtFile = null,
 /// Populated when we build the libunwind static library. A Job to build this is placed in the queue
 /// and resolved before calling linker.flush().
-libunwind_static_lib: ?CRTFile = null,
+libunwind_static_lib: ?CrtFile = null,
 /// Populated when we build the TSAN library. A Job to build this is placed in the queue
 /// and resolved before calling linker.flush().
-tsan_lib: ?CRTFile = null,
+tsan_lib: ?CrtFile = null,
 /// Populated when we build the libc static library. A Job to build this is placed in the queue
 /// and resolved before calling linker.flush().
-libc_static_lib: ?CRTFile = null,
+libc_static_lib: ?CrtFile = null,
 /// Populated when we build the libcompiler_rt static library. A Job to build this is indicated
 /// by setting `job_queued_compiler_rt_lib` and resolved before calling linker.flush().
-compiler_rt_lib: ?CRTFile = null,
+compiler_rt_lib: ?CrtFile = null,
 /// Populated when we build the compiler_rt_obj object. A Job to build this is indicated
 /// by setting `job_queued_compiler_rt_obj` and resolved before calling linker.flush().
-compiler_rt_obj: ?CRTFile = null,
+compiler_rt_obj: ?CrtFile = null,
 /// Populated when we build the libfuzzer static library. A Job to build this
 /// is indicated by setting `job_queued_fuzzer_lib` and resolved before
 /// calling linker.flush().
-fuzzer_lib: ?CRTFile = null,
+fuzzer_lib: ?CrtFile = null,
 
 glibc_so_files: ?glibc.BuiltSharedObjects = null,
-wasi_emulated_libs: []const wasi_libc.CRTFile,
+wasi_emulated_libs: []const wasi_libc.CrtFile,
 
 /// For example `Scrt1.o` and `libc_nonshared.a`. These are populated after building libc from source,
 /// The set of needed CRT (C runtime) files differs depending on the target and compilation settings.
 /// The key is the basename, and the value is the absolute path to the completed build artifact.
-crt_files: std.StringHashMapUnmanaged(CRTFile) = .empty,
+crt_files: std.StringHashMapUnmanaged(CrtFile) = .empty,
 
 /// How many lines of reference trace should be included per compile error.
 /// Null means only show snippet on first error.
@@ -277,13 +276,20 @@ digest: ?[Cache.bin_digest_len]u8 = null,
 pub const default_stack_protector_buffer_size = target_util.default_stack_protector_buffer_size;
 pub const SemaError = Zcu.SemaError;
 
-pub const CRTFile = struct {
+pub const CrtFile = struct {
     lock: Cache.Lock,
-    full_object_path: []const u8,
+    full_object_path: Path,
 
-    pub fn deinit(self: *CRTFile, gpa: Allocator) void {
+    pub fn isObject(cf: CrtFile) bool {
+        return switch (classifyFileExt(cf.full_object_path.sub_path)) {
+            .object => true,
+            else => false,
+        };
+    }
+
+    pub fn deinit(self: *CrtFile, gpa: Allocator) void {
         self.lock.release();
-        gpa.free(self.full_object_path);
+        gpa.free(self.full_object_path.sub_path);
         self.* = undefined;
     }
 };
@@ -363,13 +369,13 @@ const Job = union(enum) {
     resolve_type_fully: InternPool.Index,
 
     /// one of the glibc static objects
-    glibc_crt_file: glibc.CRTFile,
+    glibc_crt_file: glibc.CrtFile,
     /// all of the glibc shared objects
     glibc_shared_objects,
     /// one of the musl static objects
-    musl_crt_file: musl.CRTFile,
+    musl_crt_file: musl.CrtFile,
     /// one of the mingw-w64 static objects
-    mingw_crt_file: mingw.CRTFile,
+    mingw_crt_file: mingw.CrtFile,
     /// libunwind.a, usually needed when linking libc
     libunwind: void,
     libcxx: void,
@@ -379,7 +385,7 @@ const Job = union(enum) {
     /// calls to, for example, memcpy and memset.
     zig_libc: void,
     /// one of WASI libc static objects
-    wasi_libc_crt_file: wasi_libc.CRTFile,
+    wasi_libc_crt_file: wasi_libc.CrtFile,
 
     /// The value is the index into `system_libs`.
     windows_import_lib: usize,
@@ -416,8 +422,8 @@ pub const CObject = struct {
     status: union(enum) {
         new,
         success: struct {
-            /// The outputted result. Owned by gpa.
-            object_path: []u8,
+            /// The outputted result. `sub_path` owned by gpa.
+            object_path: Path,
             /// This is a file system lock on the cache hash manifest representing this
             /// object. It prevents other invocations of the Zig compiler from interfering
             /// with this object until released.
@@ -713,7 +719,7 @@ pub const CObject = struct {
                 return true;
             },
             .success => |*success| {
-                gpa.free(success.object_path);
+                gpa.free(success.object_path.sub_path);
                 success.lock.release();
                 self.status = .new;
                 return false;
@@ -1012,13 +1018,20 @@ const CacheUse = union(CacheMode) {
 };
 
 pub const LinkObject = struct {
-    path: []const u8,
+    path: Path,
     must_link: bool = false,
     // When the library is passed via a positional argument, it will be
     // added as a full path. If it's `-l<lib>`, then just the basename.
     //
     // Consistent with `withLOption` variable name in lld ELF driver.
     loption: bool = false,
+
+    pub fn isObject(lo: LinkObject) bool {
+        return switch (classifyFileExt(lo.path.sub_path)) {
+            .object => true,
+            else => false,
+        };
+    }
 };
 
 pub const CreateOptions = struct {
@@ -1082,13 +1095,12 @@ pub const CreateOptions = struct {
     /// * getpid
     /// * mman
     /// * signal
-    wasi_emulated_libs: []const wasi_libc.CRTFile = &.{},
+    wasi_emulated_libs: []const wasi_libc.CrtFile = &.{},
     /// This means that if the output mode is an executable it will be a
     /// Position Independent Executable. If the output mode is not an
     /// executable this field is ignored.
     want_compiler_rt: ?bool = null,
     want_lto: ?bool = null,
-    formatted_panics: ?bool = null,
     function_sections: bool = false,
     data_sections: bool = false,
     no_builtin: bool = false,
@@ -1357,9 +1369,6 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil
             }
         }
 
-        // TODO: https://github.com/ziglang/zig/issues/17969
-        const formatted_panics = options.formatted_panics orelse (options.root_mod.optimize_mode == .Debug);
-
         const error_limit = options.error_limit orelse (std.math.maxInt(u16) - 1);
 
         // We put everything into the cache hash that *cannot be modified
@@ -1520,7 +1529,6 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil
             .verbose_link = options.verbose_link,
             .disable_c_depfile = options.disable_c_depfile,
             .reference_trace = options.reference_trace,
-            .formatted_panics = formatted_panics,
             .time_report = options.time_report,
             .stack_report = options.stack_report,
             .test_filters = options.test_filters,
@@ -1638,7 +1646,6 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil
                 hash.addListOfBytes(options.test_filters);
                 hash.addOptionalBytes(options.test_name_prefix);
                 hash.add(options.skip_linker_dependencies);
-                hash.add(formatted_panics);
                 hash.add(options.emit_h != null);
                 hash.add(error_limit);
 
@@ -2295,7 +2302,7 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) !void {
         try pt.processExports();
     }
 
-    if (try comp.totalErrorCount() != 0) {
+    if (anyErrors(comp)) {
         // Skip flushing and keep source files loaded for error reporting.
         comp.link_error_flags = .{};
         return;
@@ -2385,6 +2392,10 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) !void {
                 .sub_path = o_sub_path,
             }, .main, main_progress_node);
 
+            // Calling `flush` may have produced errors, in which case the
+            // cache manifest must not be written.
+            if (anyErrors(comp)) return;
+
             // Failure here only means an unnecessary cache miss.
             man.writeManifest() catch |err| {
                 log.warn("failed to write cache manifest: {s}", .{@errorName(err)});
@@ -2440,7 +2451,7 @@ fn flush(
     if (comp.bin_file) |lf| {
         // This is needed before reading the error flags.
         lf.flush(arena, tid, prog_node) catch |err| switch (err) {
-            error.FlushFailure => {}, // error reported through link_error_flags
+            error.FlushFailure, error.LinkFailure => {}, // error reported through link_error_flags
             error.LLDReportedFailure => {}, // error reported via lockAndParseLldStderr
             else => |e| return e,
         };
@@ -2564,7 +2575,6 @@ fn addNonIncrementalStuffToCacheManifest(
         man.hash.addListOfBytes(comp.test_filters);
         man.hash.addOptionalBytes(comp.test_name_prefix);
         man.hash.add(comp.skip_linker_dependencies);
-        man.hash.add(comp.formatted_panics);
         //man.hash.add(mod.emit_h != null);
         man.hash.add(mod.error_limit);
     } else {
@@ -2572,7 +2582,7 @@ fn addNonIncrementalStuffToCacheManifest(
     }
 
     for (comp.objects) |obj| {
-        _ = try man.addFile(obj.path, null);
+        _ = try man.addFilePath(obj.path, null);
         man.hash.add(obj.must_link);
         man.hash.add(obj.loption);
     }
@@ -2639,7 +2649,7 @@ fn addNonIncrementalStuffToCacheManifest(
         const target = comp.root_mod.resolved_target.result;
         if (comp.libc_installation) |libc_installation| {
             man.hash.addOptionalBytes(libc_installation.crt_dir);
-            if (target.abi == .msvc) {
+            if (target.abi == .msvc or target.abi == .itanium) {
                 man.hash.addOptionalBytes(libc_installation.msvc_lib_dir);
                 man.hash.addOptionalBytes(libc_installation.kernel32_lib_dir);
             }
@@ -2697,9 +2707,8 @@ fn emitOthers(comp: *Compilation) void {
         return;
     }
     const obj_path = comp.c_object_table.keys()[0].status.success.object_path;
-    const cwd = std.fs.cwd();
-    const ext = std.fs.path.extension(obj_path);
-    const basename = obj_path[0 .. obj_path.len - ext.len];
+    const ext = std.fs.path.extension(obj_path.sub_path);
+    const dirname = obj_path.sub_path[0 .. obj_path.sub_path.len - ext.len];
     // This obj path always ends with the object file extension, but if we change the
     // extension to .ll, .bc, or .s, then it will be the path to those things.
     const outs = [_]struct {
@@ -2714,13 +2723,13 @@ fn emitOthers(comp: *Compilation) void {
         if (out.emit) |loc| {
             if (loc.directory) |directory| {
                 const src_path = std.fmt.allocPrint(comp.gpa, "{s}{s}", .{
-                    basename, out.ext,
+                    dirname, out.ext,
                 }) catch |err| {
-                    log.err("unable to copy {s}{s}: {s}", .{ basename, out.ext, @errorName(err) });
+                    log.err("unable to copy {s}{s}: {s}", .{ dirname, out.ext, @errorName(err) });
                     continue;
                 };
                 defer comp.gpa.free(src_path);
-                cwd.copyFile(src_path, directory.handle, loc.basename, .{}) catch |err| {
+                obj_path.root_dir.handle.copyFile(src_path, directory.handle, loc.basename, .{}) catch |err| {
                     log.err("unable to copy {s}: {s}", .{ src_path, @errorName(err) });
                 };
             }
@@ -3286,6 +3295,10 @@ pub fn getAllErrorsAlloc(comp: *Compilation) !ErrorBundle {
     return bundle.toOwnedBundle(compile_log_text);
 }
 
+fn anyErrors(comp: *Compilation) bool {
+    return (totalErrorCount(comp) catch return true) != 0;
+}
+
 fn totalErrorCount(comp: *Compilation) !u32 {
     var errors = try comp.getAllErrorsAlloc();
     defer errors.deinit(comp.gpa);
@@ -3768,7 +3781,7 @@ fn processOneJob(tid: usize, comp: *Compilation, job: Job, prog_node: std.Progre
             const named_frame = tracy.namedFrame("glibc_crt_file");
             defer named_frame.end();
 
-            glibc.buildCRTFile(comp, crt_file, prog_node) catch |err| {
+            glibc.buildCrtFile(comp, crt_file, prog_node) catch |err| {
                 // TODO Surface more error details.
                 comp.lockAndSetMiscFailure(.glibc_crt_file, "unable to build glibc CRT file: {s}", .{
                     @errorName(err),
@@ -3792,7 +3805,7 @@ fn processOneJob(tid: usize, comp: *Compilation, job: Job, prog_node: std.Progre
             const named_frame = tracy.namedFrame("musl_crt_file");
             defer named_frame.end();
 
-            musl.buildCRTFile(comp, crt_file, prog_node) catch |err| {
+            musl.buildCrtFile(comp, crt_file, prog_node) catch |err| {
                 // TODO Surface more error details.
                 comp.lockAndSetMiscFailure(
                     .musl_crt_file,
@@ -3805,7 +3818,7 @@ fn processOneJob(tid: usize, comp: *Compilation, job: Job, prog_node: std.Progre
             const named_frame = tracy.namedFrame("mingw_crt_file");
             defer named_frame.end();
 
-            mingw.buildCRTFile(comp, crt_file, prog_node) catch |err| {
+            mingw.buildCrtFile(comp, crt_file, prog_node) catch |err| {
                 // TODO Surface more error details.
                 comp.lockAndSetMiscFailure(
                     .mingw_crt_file,
@@ -3888,7 +3901,7 @@ fn processOneJob(tid: usize, comp: *Compilation, job: Job, prog_node: std.Progre
             const named_frame = tracy.namedFrame("wasi_libc_crt_file");
             defer named_frame.end();
 
-            wasi_libc.buildCRTFile(comp, crt_file, prog_node) catch |err| {
+            wasi_libc.buildCrtFile(comp, crt_file, prog_node) catch |err| {
                 // TODO Surface more error details.
                 comp.lockAndSetMiscFailure(
                     .wasi_libc_crt_file,
@@ -4596,7 +4609,7 @@ fn buildRt(
     root_source_name: []const u8,
     misc_task: MiscTask,
     output_mode: std.builtin.OutputMode,
-    out: *?CRTFile,
+    out: *?CrtFile,
     prog_node: std.Progress.Node,
 ) void {
     comp.buildOutputFromZig(
@@ -4697,7 +4710,9 @@ fn updateCObject(comp: *Compilation, c_object: *CObject, c_obj_prog_node: std.Pr
 
     log.debug("updating C object: {s}", .{c_object.src.src_path});
 
-    if (c_object.clearStatus(comp.gpa)) {
+    const gpa = comp.gpa;
+
+    if (c_object.clearStatus(gpa)) {
         // There was previous failure.
         comp.mutex.lock();
         defer comp.mutex.unlock();
@@ -4716,7 +4731,7 @@ fn updateCObject(comp: *Compilation, c_object: *CObject, c_obj_prog_node: std.Pr
 
     try cache_helpers.hashCSource(&man, c_object.src);
 
-    var arena_allocator = std.heap.ArenaAllocator.init(comp.gpa);
+    var arena_allocator = std.heap.ArenaAllocator.init(gpa);
     defer arena_allocator.deinit();
     const arena = arena_allocator.allocator();
 
@@ -4738,7 +4753,7 @@ fn updateCObject(comp: *Compilation, c_object: *CObject, c_obj_prog_node: std.Pr
     const target = comp.getTarget();
     const o_ext = target.ofmt.fileExt(target.cpu.arch);
     const digest = if (!comp.disable_c_depfile and try man.hit()) man.final() else blk: {
-        var argv = std.ArrayList([]const u8).init(comp.gpa);
+        var argv = std.ArrayList([]const u8).init(gpa);
         defer argv.deinit();
 
         // In case we are doing passthrough mode, we need to detect -S and -emit-llvm.
@@ -4902,7 +4917,7 @@ fn updateCObject(comp: *Compilation, c_object: *CObject, c_obj_prog_node: std.Pr
 
                 switch (term) {
                     .Exited => |code| if (code != 0) if (out_diag_path) |diag_file_path| {
-                        const bundle = CObject.Diag.Bundle.parse(comp.gpa, diag_file_path) catch |err| {
+                        const bundle = CObject.Diag.Bundle.parse(gpa, diag_file_path) catch |err| {
                             log.err("{}: failed to parse clang diagnostics: {s}", .{ err, stderr });
                             return comp.failCObj(c_object, "clang exited with code {d}", .{code});
                         };
@@ -4976,9 +4991,10 @@ fn updateCObject(comp: *Compilation, c_object: *CObject, c_obj_prog_node: std.Pr
 
     c_object.status = .{
         .success = .{
-            .object_path = try comp.local_cache_directory.join(comp.gpa, &[_][]const u8{
-                "o", &digest, o_basename,
-            }),
+            .object_path = .{
+                .root_dir = comp.local_cache_directory,
+                .sub_path = try std.fs.path.join(gpa, &.{ "o", &digest, o_basename }),
+            },
             .lock = man.toOwnedLock(),
         },
     };
@@ -6086,18 +6102,23 @@ test "classifyFileExt" {
     try std.testing.expectEqual(FileExt.zig, classifyFileExt("foo.zig"));
 }
 
-pub fn get_libc_crt_file(comp: *Compilation, arena: Allocator, basename: []const u8) ![]const u8 {
-    if (comp.wantBuildGLibCFromSource() or
-        comp.wantBuildMuslFromSource() or
-        comp.wantBuildMinGWFromSource() or
-        comp.wantBuildWasiLibcFromSource())
-    {
-        return comp.crt_files.get(basename).?.full_object_path;
-    }
-    const lci = comp.libc_installation orelse return error.LibCInstallationNotAvailable;
-    const crt_dir_path = lci.crt_dir orelse return error.LibCInstallationMissingCRTDir;
-    const full_path = try std.fs.path.join(arena, &[_][]const u8{ crt_dir_path, basename });
-    return full_path;
+pub fn get_libc_crt_file(comp: *Compilation, arena: Allocator, basename: []const u8) !Path {
+    return (try crtFilePath(comp, basename)) orelse {
+        const lci = comp.libc_installation orelse return error.LibCInstallationNotAvailable;
+        const crt_dir_path = lci.crt_dir orelse return error.LibCInstallationMissingCrtDir;
+        const full_path = try std.fs.path.join(arena, &[_][]const u8{ crt_dir_path, basename });
+        return Path.initCwd(full_path);
+    };
+}
+
+pub fn crtFileAsString(comp: *Compilation, arena: Allocator, basename: []const u8) ![]const u8 {
+    const path = try get_libc_crt_file(comp, arena, basename);
+    return path.toString(arena);
+}
+
+pub fn crtFilePath(comp: *Compilation, basename: []const u8) Allocator.Error!?Path {
+    const crt_file = comp.crt_files.get(basename) orelse return null;
+    return crt_file.full_object_path;
 }
 
 fn wantBuildLibCFromSource(comp: Compilation) bool {
@@ -6308,7 +6329,7 @@ fn buildOutputFromZig(
     comp: *Compilation,
     src_basename: []const u8,
     output_mode: std.builtin.OutputMode,
-    out: *?CRTFile,
+    out: *?CrtFile,
     misc_task_tag: MiscTask,
     prog_node: std.Progress.Node,
 ) !void {
@@ -6536,15 +6557,39 @@ pub fn build_crt_file(
     comp.crt_files.putAssumeCapacityNoClobber(basename, try sub_compilation.toCrtFile());
 }
 
-pub fn toCrtFile(comp: *Compilation) Allocator.Error!CRTFile {
+pub fn toCrtFile(comp: *Compilation) Allocator.Error!CrtFile {
     return .{
-        .full_object_path = try comp.local_cache_directory.join(comp.gpa, &.{
-            comp.cache_use.whole.bin_sub_path.?,
-        }),
+        .full_object_path = .{
+            .root_dir = comp.local_cache_directory,
+            .sub_path = try comp.gpa.dupe(u8, comp.cache_use.whole.bin_sub_path.?),
+        },
         .lock = comp.cache_use.whole.moveLock(),
     };
 }
 
+pub fn getCrtPaths(
+    comp: *Compilation,
+    arena: Allocator,
+) error{ OutOfMemory, LibCInstallationMissingCrtDir }!LibCInstallation.CrtPaths {
+    const target = comp.root_mod.resolved_target.result;
+    const basenames = LibCInstallation.CrtBasenames.get(.{
+        .target = target,
+        .link_libc = comp.config.link_libc,
+        .output_mode = comp.config.output_mode,
+        .link_mode = comp.config.link_mode,
+        .pie = comp.config.pie,
+    });
+    if (comp.libc_installation) |lci| return lci.resolveCrtPaths(arena, basenames, target);
+
+    return .{
+        .crt0 = if (basenames.crt0) |basename| try comp.crtFilePath(basename) else null,
+        .crti = if (basenames.crti) |basename| try comp.crtFilePath(basename) else null,
+        .crtbegin = if (basenames.crtbegin) |basename| try comp.crtFilePath(basename) else null,
+        .crtend = if (basenames.crtend) |basename| try comp.crtFilePath(basename) else null,
+        .crtn = if (basenames.crtn) |basename| try comp.crtFilePath(basename) else null,
+    };
+}
+
 pub fn addLinkLib(comp: *Compilation, lib_name: []const u8) !void {
     // Avoid deadlocking on building import libs such as kernel32.lib
     // This can happen when the user uses `build-exe foo.obj -lkernel32` and
diff --git a/zig/src/Compilation/Config.zig b/zig/src/Compilation/Config.zig
index 6be2ae80f8..b18cd4dd08 100644
--- a/zig/src/Compilation/Config.zig
+++ b/zig/src/Compilation/Config.zig
@@ -440,7 +440,7 @@ pub fn resolve(options: Options) ResolveError!Config {
                 .windows, .uefi => .code_view,
                 else => .{ .dwarf = .@"32" },
             },
-            .spirv, .nvptx, .dxcontainer, .hex, .raw, .plan9 => .strip,
+            .spirv, .nvptx, .hex, .raw, .plan9 => .strip,
         };
     };
 
diff --git a/zig/src/InternPool.zig b/zig/src/InternPool.zig
index 6b20f79561..f41f780e0a 100644
--- a/zig/src/InternPool.zig
+++ b/zig/src/InternPool.zig
@@ -7353,6 +7353,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, tid: Zcu.PerThread.Id, key: Key) All
         .func_type => unreachable, // use getFuncType() instead
         .@"extern" => unreachable, // use getExtern() instead
         .func => unreachable, // use getFuncInstance() or getFuncDecl() instead
+        .un => unreachable, // use getUnion instead
 
         .variable => |variable| {
             const has_init = variable.init != .none;
@@ -7968,15 +7969,6 @@ pub fn get(ip: *InternPool, gpa: Allocator, tid: Zcu.PerThread.Id, key: Key) All
             if (sentinel != .none) extra.appendAssumeCapacity(.{@intFromEnum(sentinel)});
         },
 
-        .un => |un| {
-            assert(un.ty != .none);
-            assert(un.val != .none);
-            items.appendAssumeCapacity(.{
-                .tag = .union_value,
-                .data = try addExtra(extra, un),
-            });
-        },
-
         .memoized_call => |memoized_call| {
             for (memoized_call.arg_values) |arg| assert(arg != .none);
             try extra.ensureUnusedCapacity(@typeInfo(MemoizedCall).@"struct".fields.len +
@@ -7996,6 +7988,30 @@ pub fn get(ip: *InternPool, gpa: Allocator, tid: Zcu.PerThread.Id, key: Key) All
     return gop.put();
 }
 
+pub fn getUnion(
+    ip: *InternPool,
+    gpa: Allocator,
+    tid: Zcu.PerThread.Id,
+    un: Key.Union,
+) Allocator.Error!Index {
+    var gop = try ip.getOrPutKey(gpa, tid, .{ .un = un });
+    defer gop.deinit();
+    if (gop == .existing) return gop.existing;
+    const local = ip.getLocal(tid);
+    const items = local.getMutableItems(gpa);
+    const extra = local.getMutableExtra(gpa);
+    try items.ensureUnusedCapacity(1);
+
+    assert(un.ty != .none);
+    assert(un.val != .none);
+    items.appendAssumeCapacity(.{
+        .tag = .union_value,
+        .data = try addExtra(extra, un),
+    });
+
+    return gop.put();
+}
+
 pub const UnionTypeInit = struct {
     flags: packed struct {
         runtime_tag: LoadedUnionType.RuntimeTag,
diff --git a/zig/src/Liveness.zig b/zig/src/Liveness.zig
index abada07492..b5bffc6a48 100644
--- a/zig/src/Liveness.zig
+++ b/zig/src/Liveness.zig
@@ -346,8 +346,6 @@ pub fn categorizeOperand(
         .work_group_id,
         => return .none,
 
-        .fence => return .write,
-
         .not,
         .bitcast,
         .load,
@@ -975,7 +973,6 @@ fn analyzeInst(
         .ret_ptr,
         .breakpoint,
         .dbg_stmt,
-        .fence,
         .ret_addr,
         .frame_addr,
         .wasm_memory_size,
diff --git a/zig/src/Liveness/Verify.zig b/zig/src/Liveness/Verify.zig
index b6b7d40893..aa2239793a 100644
--- a/zig/src/Liveness/Verify.zig
+++ b/zig/src/Liveness/Verify.zig
@@ -56,7 +56,6 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void {
             .ret_ptr,
             .breakpoint,
             .dbg_stmt,
-            .fence,
             .ret_addr,
             .frame_addr,
             .wasm_memory_size,
diff --git a/zig/src/Package/Manifest.zig b/zig/src/Package/Manifest.zig
index eb82ef039d..4eed6cc386 100644
--- a/zig/src/Package/Manifest.zig
+++ b/zig/src/Package/Manifest.zig
@@ -18,8 +18,10 @@ pub const MultiHashHexDigest = [multihash_hex_digest_len]u8;
 pub const Dependency = struct {
     location: Location,
     location_tok: Ast.TokenIndex,
+    location_node: Ast.Node.Index,
     hash: ?[]const u8,
     hash_tok: Ast.TokenIndex,
+    hash_node: Ast.Node.Index,
     node: Ast.Node.Index,
     name_tok: Ast.TokenIndex,
     lazy: bool,
@@ -293,8 +295,10 @@ const Parse = struct {
         var dep: Dependency = .{
             .location = undefined,
             .location_tok = 0,
+            .location_node = undefined,
             .hash = null,
             .hash_tok = 0,
+            .hash_node = undefined,
             .node = node,
             .name_tok = 0,
             .lazy = false,
@@ -320,6 +324,7 @@ const Parse = struct {
                 };
                 has_location = true;
                 dep.location_tok = main_tokens[field_init];
+                dep.location_node = field_init;
             } else if (mem.eql(u8, field_name, "path")) {
                 if (has_location) {
                     return fail(p, main_tokens[field_init], "dependency should specify only one of 'url' and 'path' fields.", .{});
@@ -332,12 +337,14 @@ const Parse = struct {
                 };
                 has_location = true;
                 dep.location_tok = main_tokens[field_init];
+                dep.location_node = field_init;
             } else if (mem.eql(u8, field_name, "hash")) {
                 dep.hash = parseHash(p, field_init) catch |err| switch (err) {
                     error.ParseFailure => continue,
                     else => |e| return e,
                 };
                 dep.hash_tok = main_tokens[field_init];
+                dep.hash_node = field_init;
             } else if (mem.eql(u8, field_name, "lazy")) {
                 dep.lazy = parseBool(p, field_init) catch |err| switch (err) {
                     error.ParseFailure => continue,
diff --git a/zig/src/Sema.zig b/zig/src/Sema.zig
index fdf5eca764..1de0d73808 100644
--- a/zig/src/Sema.zig
+++ b/zig/src/Sema.zig
@@ -1087,7 +1087,7 @@ fn analyzeBodyInner(
             .elem_val_imm                 => try sema.zirElemValImm(block, inst),
             .elem_type                    => try sema.zirElemType(block, inst),
             .indexable_ptr_elem_type      => try sema.zirIndexablePtrElemType(block, inst),
-            .vector_elem_type             => try sema.zirVectorElemType(block, inst),
+            .vec_arr_elem_type            => try sema.zirVecArrElemType(block, inst),
             .enum_literal                 => try sema.zirEnumLiteral(block, inst),
             .decl_literal                 => try sema.zirDeclLiteral(block, inst, true),
             .decl_literal_no_coerce       => try sema.zirDeclLiteral(block, inst, false),
@@ -1321,11 +1321,6 @@ fn analyzeBodyInner(
                     .closure_get        => try sema.zirClosureGet(        block, extended),
                     // zig fmt: on
 
-                    .fence => {
-                        try sema.zirFence(block, extended);
-                        i += 1;
-                        continue;
-                    },
                     .set_float_mode => {
                         try sema.zirSetFloatMode(block, extended);
                         i += 1;
@@ -2051,7 +2046,7 @@ fn genericPoisonReason(sema: *Sema, block: *Block, ref: Zir.Inst.Ref) GenericPoi
                 const bin = sema.code.instructions.items(.data)[@intFromEnum(inst)].bin;
                 cur = bin.lhs;
             },
-            .indexable_ptr_elem_type, .vector_elem_type => {
+            .indexable_ptr_elem_type, .vec_arr_elem_type => {
                 const un_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
                 cur = un_node.operand;
             },
@@ -2141,7 +2136,7 @@ pub fn setupErrorReturnTrace(sema: *Sema, block: *Block, last_arg_index: usize)
     const addrs_ptr = try err_trace_block.addTy(.alloc, try pt.singleMutPtrType(addr_arr_ty));
 
     // var st: StackTrace = undefined;
-    const stack_trace_ty = try pt.getBuiltinType("StackTrace");
+    const stack_trace_ty = try sema.getBuiltinType("StackTrace");
     try stack_trace_ty.resolveFields(pt);
     const st_ptr = try err_trace_block.addTy(.alloc, try pt.singleMutPtrType(stack_trace_ty));
 
@@ -2279,15 +2274,20 @@ pub fn resolveFinalDeclValue(
     src: LazySrcLoc,
     air_ref: Air.Inst.Ref,
 ) CompileError!Value {
+    const zcu = sema.pt.zcu;
+
     const val = try sema.resolveValueAllowVariables(air_ref) orelse {
         return sema.failWithNeededComptime(block, src, .{
             .needed_comptime_reason = "global variable initializer must be comptime-known",
         });
     };
     if (val.isGenericPoison()) return error.GenericPoison;
-    if (val.canMutateComptimeVarState(sema.pt.zcu)) {
+
+    const init_val: Value = if (val.getVariable(zcu)) |v| .fromInterned(v.init) else val;
+    if (init_val.canMutateComptimeVarState(zcu)) {
         return sema.fail(block, src, "global variable contains reference to comptime var", .{});
     }
+
     return val;
 }
 
@@ -4854,11 +4854,11 @@ fn validateUnionInit(
         }
         block.instructions.shrinkRetainingCapacity(block_index);
 
-        const union_val = try pt.intern(.{ .un = .{
+        const union_val = try pt.internUnion(.{
             .ty = union_ty.toIntern(),
             .tag = tag_val.toIntern(),
             .val = val.toIntern(),
-        } });
+        });
         const union_init = Air.internedToRef(union_val);
         try sema.storePtr2(block, init_src, union_ptr, init_src, union_init, init_src, .store);
         return;
@@ -5428,6 +5428,9 @@ fn zirValidateDestructure(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Comp
             const msg = try sema.errMsg(src, "type '{}' cannot be destructured", .{operand_ty.fmt(pt)});
             errdefer msg.destroy(sema.gpa);
             try sema.errNote(destructure_src, msg, "result destructured here", .{});
+            if (operand_ty.zigTypeTag(pt.zcu) == .error_union) {
+                try sema.errNote(src, msg, "consider using 'try', 'catch', or 'if'", .{});
+            }
             break :msg msg;
         });
     }
@@ -5700,27 +5703,7 @@ fn addStrLit(sema: *Sema, string: InternPool.String, len: u64) CompileError!Air.
 }
 
 fn uavRef(sema: *Sema, val: InternPool.Index) CompileError!Air.Inst.Ref {
-    return Air.internedToRef(try sema.refValue(val));
-}
-
-fn refValue(sema: *Sema, val: InternPool.Index) CompileError!InternPool.Index {
-    const pt = sema.pt;
-    const ptr_ty = (try pt.ptrTypeSema(.{
-        .child = pt.zcu.intern_pool.typeOf(val),
-        .flags = .{
-            .alignment = .none,
-            .is_const = true,
-            .address_space = .generic,
-        },
-    })).toIntern();
-    return pt.intern(.{ .ptr = .{
-        .ty = ptr_ty,
-        .base_addr = .{ .uav = .{
-            .val = val,
-            .orig_ty = ptr_ty,
-        } },
-        .byte_offset = 0,
-    } });
+    return Air.internedToRef(try sema.pt.refValue(val));
 }
 
 fn zirInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
@@ -6457,15 +6440,7 @@ fn zirExport(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
             if (ptr_info.byte_offset != 0) {
                 return sema.fail(block, ptr_src, "TODO: export pointer in middle of value", .{});
             }
-            try sema.ensureNavResolved(src, nav);
-            // Make sure to export the owner Nav if applicable.
-            const exported_nav = switch (ip.indexToKey(ip.getNav(nav).status.resolved.val)) {
-                .variable => |v| v.owner_nav,
-                .@"extern" => |e| e.owner_nav,
-                .func => |f| f.owner_nav,
-                else => nav,
-            };
-            try sema.analyzeExport(block, src, options, exported_nav);
+            try sema.analyzeExport(block, src, options, nav);
         },
     }
 }
@@ -6475,7 +6450,7 @@ pub fn analyzeExport(
     block: *Block,
     src: LazySrcLoc,
     options: Zcu.Export.Options,
-    exported_nav_index: InternPool.Nav.Index,
+    orig_nav_index: InternPool.Nav.Index,
 ) !void {
     const gpa = sema.gpa;
     const pt = sema.pt;
@@ -6485,7 +6460,15 @@ pub fn analyzeExport(
     if (options.linkage == .internal)
         return;
 
-    try sema.ensureNavResolved(src, exported_nav_index);
+    try sema.ensureNavResolved(src, orig_nav_index);
+
+    const exported_nav_index = switch (ip.indexToKey(ip.getNav(orig_nav_index).status.resolved.val)) {
+        .variable => |v| v.owner_nav,
+        .@"extern" => |e| e.owner_nav,
+        .func => |f| f.owner_nav,
+        else => orig_nav_index,
+    };
+
     const exported_nav = ip.getNav(exported_nav_index);
     const export_ty = Type.fromInterned(exported_nav.typeOf(ip));
 
@@ -6573,25 +6556,6 @@ fn zirSetRuntimeSafety(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compile
     });
 }
 
-fn zirFence(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) CompileError!void {
-    if (block.is_comptime) return;
-
-    const extra = sema.code.extraData(Zir.Inst.UnNode, extended.operand).data;
-    const order_src = block.builtinCallArgSrc(extra.node, 0);
-    const order = try sema.resolveAtomicOrder(block, order_src, extra.operand, .{
-        .needed_comptime_reason = "atomic order of @fence must be comptime-known",
-    });
-
-    if (@intFromEnum(order) < @intFromEnum(std.builtin.AtomicOrder.acquire)) {
-        return sema.fail(block, order_src, "atomic ordering must be acquire or stricter", .{});
-    }
-
-    _ = try block.addInst(.{
-        .tag = .fence,
-        .data = .{ .fence = order },
-    });
-}
-
 fn zirBreak(sema: *Sema, start_block: *Block, inst: Zir.Inst.Index) CompileError!void {
     const tracy = trace(@src());
     defer tracy.end();
@@ -6962,7 +6926,7 @@ pub fn analyzeSaveErrRetIndex(sema: *Sema, block: *Block) SemaError!Air.Inst.Ref
 
     if (!block.ownerModule().error_tracing) return .none;
 
-    const stack_trace_ty = try pt.getBuiltinType("StackTrace");
+    const stack_trace_ty = try sema.getBuiltinType("StackTrace");
     try stack_trace_ty.resolveFields(pt);
     const field_name = try zcu.intern_pool.getOrPutString(gpa, pt.tid, "index", .no_embedded_nulls);
     const field_index = sema.structFieldIndex(block, stack_trace_ty, field_name, LazySrcLoc.unneeded) catch |err| switch (err) {
@@ -7004,7 +6968,7 @@ fn popErrorReturnTrace(
         // AstGen determined this result does not go to an error-handling expr (try/catch/return etc.), or
         // the result is comptime-known to be a non-error. Either way, pop unconditionally.
 
-        const stack_trace_ty = try pt.getBuiltinType("StackTrace");
+        const stack_trace_ty = try sema.getBuiltinType("StackTrace");
         try stack_trace_ty.resolveFields(pt);
         const ptr_stack_trace_ty = try pt.singleMutPtrType(stack_trace_ty);
         const err_return_trace = try block.addTy(.err_return_trace, ptr_stack_trace_ty);
@@ -7030,7 +6994,7 @@ fn popErrorReturnTrace(
         defer then_block.instructions.deinit(gpa);
 
         // If non-error, then pop the error return trace by restoring the index.
-        const stack_trace_ty = try pt.getBuiltinType("StackTrace");
+        const stack_trace_ty = try sema.getBuiltinType("StackTrace");
         try stack_trace_ty.resolveFields(pt);
         const ptr_stack_trace_ty = try pt.singleMutPtrType(stack_trace_ty);
         const err_return_trace = try then_block.addTy(.err_return_trace, ptr_stack_trace_ty);
@@ -7173,7 +7137,7 @@ fn zirCall(
         // If any input is an error-type, we might need to pop any trace it generated. Otherwise, we only
         // need to clean-up our own trace if we were passed to a non-error-handling expression.
         if (input_is_error or (pop_error_return_trace and return_ty.isError(zcu))) {
-            const stack_trace_ty = try pt.getBuiltinType("StackTrace");
+            const stack_trace_ty = try sema.getBuiltinType("StackTrace");
             try stack_trace_ty.resolveFields(pt);
             const field_name = try zcu.intern_pool.getOrPutString(sema.gpa, pt.tid, "index", .no_embedded_nulls);
             const field_index = try sema.structFieldIndex(block, stack_trace_ty, field_name, call_src);
@@ -8639,7 +8603,7 @@ fn zirIndexablePtrElemType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com
     return Air.internedToRef(elem_ty.toIntern());
 }
 
-fn zirVectorElemType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
+fn zirVecArrElemType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
     const zcu = pt.zcu;
     const un_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
@@ -8651,8 +8615,9 @@ fn zirVectorElemType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileEr
         error.GenericPoison => return .generic_poison_type,
         else => |e| return e,
     };
-    if (!vec_ty.isVector(zcu)) {
-        return sema.fail(block, block.nodeOffset(un_node.src_node), "expected vector type, found '{}'", .{vec_ty.fmt(pt)});
+    switch (vec_ty.zigTypeTag(zcu)) {
+        .array, .vector => {},
+        else => return sema.fail(block, block.nodeOffset(un_node.src_node), "expected array or vector type, found '{}'", .{vec_ty.fmt(pt)}),
     }
     return Air.internedToRef(vec_ty.childType(zcu).toIntern());
 }
@@ -9324,7 +9289,7 @@ fn analyzeErrUnionPayload(
     if (safety_check and block.wantSafety() and
         !err_union_ty.errorUnionSet(zcu).errorSetIsEmpty(zcu))
     {
-        try sema.panicUnwrapError(block, src, operand, .unwrap_errunion_err, .is_non_err);
+        try sema.addSafetyCheckUnwrapError(block, src, operand, .unwrap_errunion_err, .is_non_err);
     }
 
     return block.addTyOp(.unwrap_errunion_payload, payload_ty, operand);
@@ -9408,7 +9373,7 @@ fn analyzeErrUnionPayloadPtr(
     if (safety_check and block.wantSafety() and
         !err_union_ty.errorUnionSet(zcu).errorSetIsEmpty(zcu))
     {
-        try sema.panicUnwrapError(block, src, operand, .unwrap_errunion_err_ptr, .is_non_err_ptr);
+        try sema.addSafetyCheckUnwrapError(block, src, operand, .unwrap_errunion_err_ptr, .is_non_err_ptr);
     }
 
     if (initializing) {
@@ -10228,7 +10193,7 @@ fn finishFunc(
     if (!final_is_generic and sema.wantErrorReturnTracing(return_type)) {
         // Make sure that StackTrace's fields are resolved so that the backend can
         // lower this fn type.
-        const unresolved_stack_trace_ty = try pt.getBuiltinType("StackTrace");
+        const unresolved_stack_trace_ty = try sema.getBuiltinType("StackTrace");
         try unresolved_stack_trace_ty.resolveFields(pt);
     }
 
@@ -14187,7 +14152,6 @@ fn maybeErrorUnwrap(
 ) !bool {
     const pt = sema.pt;
     const zcu = pt.zcu;
-    if (!zcu.backendSupportsFeature(.panic_unwrap_error)) return false;
 
     const tags = sema.code.instructions.items(.tag);
     for (body) |inst| {
@@ -14220,25 +14184,17 @@ fn maybeErrorUnwrap(
             .as_node => try sema.zirAsNode(block, inst),
             .field_val => try sema.zirFieldVal(block, inst),
             .@"unreachable" => {
-                if (!zcu.comp.formatted_panics) {
-                    try sema.safetyPanic(block, operand_src, .unwrap_error);
-                    return true;
-                }
-
-                const panic_fn = try pt.getBuiltin("panicUnwrapError");
-                const err_return_trace = try sema.getErrorReturnTrace(block);
-                const args: [2]Air.Inst.Ref = .{ err_return_trace, operand };
-                try sema.callBuiltin(block, operand_src, panic_fn, .auto, &args, .@"safety check");
+                try safetyPanicUnwrapError(sema, block, operand_src, operand);
                 return true;
             },
             .panic => {
                 const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
                 const msg_inst = try sema.resolveInst(inst_data.operand);
 
-                const panic_fn = try pt.getBuiltin("panic");
+                const panic_fn = try getPanicInnerFn(sema, block, operand_src, "call");
                 const err_return_trace = try sema.getErrorReturnTrace(block);
                 const args: [3]Air.Inst.Ref = .{ msg_inst, err_return_trace, .null_value };
-                try sema.callBuiltin(block, operand_src, panic_fn, .auto, &args, .@"safety check");
+                try sema.callBuiltin(block, operand_src, Air.internedToRef(panic_fn), .auto, &args, .@"safety check");
                 return true;
             },
             else => unreachable,
@@ -18272,7 +18228,7 @@ fn zirBuiltinSrc(
         } });
     };
 
-    const src_loc_ty = try pt.getBuiltinType("SourceLocation");
+    const src_loc_ty = try sema.getBuiltinType("SourceLocation");
     const fields = .{
         // module: [:0]const u8,
         module_name_val,
@@ -18299,7 +18255,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
     const ty = try sema.resolveType(block, src, inst_data.operand);
-    const type_info_ty = try pt.getBuiltinType("Type");
+    const type_info_ty = try sema.getBuiltinType("Type");
     const type_info_tag_ty = type_info_ty.unionTagType(zcu).?;
 
     if (ty.typeDeclInst(zcu)) |type_decl_inst| {
@@ -18316,29 +18272,11 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
         .undefined,
         .null,
         .enum_literal,
-        => |type_info_tag| return Air.internedToRef((try pt.intern(.{ .un = .{
-            .ty = type_info_ty.toIntern(),
-            .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(type_info_tag))).toIntern(),
-            .val = .void_value,
-        } }))),
-        .@"fn" => {
-            const fn_info_nav = try sema.namespaceLookup(
-                block,
-                src,
-                type_info_ty.getNamespaceIndex(zcu),
-                try ip.getOrPutString(gpa, pt.tid, "Fn", .no_embedded_nulls),
-            ) orelse @panic("std.builtin.Type is corrupt");
-            try sema.ensureNavResolved(src, fn_info_nav);
-            const fn_info_ty = Type.fromInterned(ip.getNav(fn_info_nav).status.resolved.val);
+        => |type_info_tag| return unionInitFromEnumTag(sema, block, src, type_info_ty, @intFromEnum(type_info_tag), .void_value),
 
-            const param_info_nav = try sema.namespaceLookup(
-                block,
-                src,
-                fn_info_ty.getNamespaceIndex(zcu),
-                try ip.getOrPutString(gpa, pt.tid, "Param", .no_embedded_nulls),
-            ) orelse @panic("std.builtin.Type is corrupt");
-            try sema.ensureNavResolved(src, param_info_nav);
-            const param_info_ty = Type.fromInterned(ip.getNav(param_info_nav).status.resolved.val);
+        .@"fn" => {
+            const fn_info_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "Fn");
+            const param_info_ty = try getBuiltinInnerType(sema, block, src, fn_info_ty, "Type.Fn", "Param");
 
             const func_ty_info = zcu.typeToFunc(ty).?;
             const param_vals = try sema.arena.alloc(InternPool.Index, func_ty_info.param_types.len);
@@ -18408,7 +18346,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                     func_ty_info.return_type,
             } });
 
-            const callconv_ty = try pt.getBuiltinType("CallingConvention");
+            const callconv_ty = try sema.getBuiltinType("CallingConvention");
 
             const field_values = .{
                 // calling_convention: CallingConvention,
@@ -18422,26 +18360,18 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 // args: []const Fn.Param,
                 args_val,
             };
-            return Air.internedToRef((try pt.intern(.{ .un = .{
+            return Air.internedToRef((try pt.internUnion(.{
                 .ty = type_info_ty.toIntern(),
                 .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.@"fn"))).toIntern(),
                 .val = try pt.intern(.{ .aggregate = .{
                     .ty = fn_info_ty.toIntern(),
                     .storage = .{ .elems = &field_values },
                 } }),
-            } })));
+            })));
         },
         .int => {
-            const int_info_nav = try sema.namespaceLookup(
-                block,
-                src,
-                type_info_ty.getNamespaceIndex(zcu),
-                try ip.getOrPutString(gpa, pt.tid, "Int", .no_embedded_nulls),
-            ) orelse @panic("std.builtin.Type is corrupt");
-            try sema.ensureNavResolved(src, int_info_nav);
-            const int_info_ty = Type.fromInterned(ip.getNav(int_info_nav).status.resolved.val);
-
-            const signedness_ty = try pt.getBuiltinType("Signedness");
+            const int_info_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "Int");
+            const signedness_ty = try sema.getBuiltinType("Signedness");
             const info = ty.intInfo(zcu);
             const field_values = .{
                 // signedness: Signedness,
@@ -18449,37 +18379,30 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 // bits: u16,
                 (try pt.intValue(Type.u16, info.bits)).toIntern(),
             };
-            return Air.internedToRef((try pt.intern(.{ .un = .{
+            return Air.internedToRef((try pt.internUnion(.{
                 .ty = type_info_ty.toIntern(),
                 .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.int))).toIntern(),
                 .val = try pt.intern(.{ .aggregate = .{
                     .ty = int_info_ty.toIntern(),
                     .storage = .{ .elems = &field_values },
                 } }),
-            } })));
+            })));
         },
         .float => {
-            const float_info_nav = try sema.namespaceLookup(
-                block,
-                src,
-                type_info_ty.getNamespaceIndex(zcu),
-                try ip.getOrPutString(gpa, pt.tid, "Float", .no_embedded_nulls),
-            ) orelse @panic("std.builtin.Type is corrupt");
-            try sema.ensureNavResolved(src, float_info_nav);
-            const float_info_ty = Type.fromInterned(ip.getNav(float_info_nav).status.resolved.val);
+            const float_info_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "Float");
 
             const field_vals = .{
                 // bits: u16,
                 (try pt.intValue(Type.u16, ty.bitSize(zcu))).toIntern(),
             };
-            return Air.internedToRef((try pt.intern(.{ .un = .{
+            return Air.internedToRef((try pt.internUnion(.{
                 .ty = type_info_ty.toIntern(),
                 .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.float))).toIntern(),
                 .val = try pt.intern(.{ .aggregate = .{
                     .ty = float_info_ty.toIntern(),
                     .storage = .{ .elems = &field_vals },
                 } }),
-            } })));
+            })));
         },
         .pointer => {
             const info = ty.ptrInfo(zcu);
@@ -18488,27 +18411,9 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             else
                 try Type.fromInterned(info.child).lazyAbiAlignment(pt);
 
-            const addrspace_ty = try pt.getBuiltinType("AddressSpace");
-            const pointer_ty = t: {
-                const nav = try sema.namespaceLookup(
-                    block,
-                    src,
-                    (try pt.getBuiltinType("Type")).getNamespaceIndex(zcu),
-                    try ip.getOrPutString(gpa, pt.tid, "Pointer", .no_embedded_nulls),
-                ) orelse @panic("std.builtin.Type is corrupt");
-                try sema.ensureNavResolved(src, nav);
-                break :t Type.fromInterned(ip.getNav(nav).status.resolved.val);
-            };
-            const ptr_size_ty = t: {
-                const nav = try sema.namespaceLookup(
-                    block,
-                    src,
-                    pointer_ty.getNamespaceIndex(zcu),
-                    try ip.getOrPutString(gpa, pt.tid, "Size", .no_embedded_nulls),
-                ) orelse @panic("std.builtin.Type is corrupt");
-                try sema.ensureNavResolved(src, nav);
-                break :t Type.fromInterned(ip.getNav(nav).status.resolved.val);
-            };
+            const addrspace_ty = try sema.getBuiltinType("AddressSpace");
+            const pointer_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "Pointer");
+            const ptr_size_ty = try getBuiltinInnerType(sema, block, src, pointer_ty, "Type.Pointer", "Size");
 
             const field_values = .{
                 // size: Size,
@@ -18531,26 +18436,17 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                     else => Value.fromInterned(info.sentinel),
                 })).toIntern(),
             };
-            return Air.internedToRef((try pt.intern(.{ .un = .{
+            return Air.internedToRef((try pt.internUnion(.{
                 .ty = type_info_ty.toIntern(),
                 .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.pointer))).toIntern(),
                 .val = try pt.intern(.{ .aggregate = .{
                     .ty = pointer_ty.toIntern(),
                     .storage = .{ .elems = &field_values },
                 } }),
-            } })));
+            })));
         },
         .array => {
-            const array_field_ty = t: {
-                const nav = try sema.namespaceLookup(
-                    block,
-                    src,
-                    type_info_ty.getNamespaceIndex(zcu),
-                    try ip.getOrPutString(gpa, pt.tid, "Array", .no_embedded_nulls),
-                ) orelse @panic("std.builtin.Type is corrupt");
-                try sema.ensureNavResolved(src, nav);
-                break :t Type.fromInterned(ip.getNav(nav).status.resolved.val);
-            };
+            const array_field_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "Array");
 
             const info = ty.arrayInfo(zcu);
             const field_values = .{
@@ -18561,26 +18457,17 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 // sentinel: ?*const anyopaque,
                 (try sema.optRefValue(info.sentinel)).toIntern(),
             };
-            return Air.internedToRef((try pt.intern(.{ .un = .{
+            return Air.internedToRef((try pt.internUnion(.{
                 .ty = type_info_ty.toIntern(),
                 .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.array))).toIntern(),
                 .val = try pt.intern(.{ .aggregate = .{
                     .ty = array_field_ty.toIntern(),
                     .storage = .{ .elems = &field_values },
                 } }),
-            } })));
+            })));
         },
         .vector => {
-            const vector_field_ty = t: {
-                const nav = try sema.namespaceLookup(
-                    block,
-                    src,
-                    type_info_ty.getNamespaceIndex(zcu),
-                    try ip.getOrPutString(gpa, pt.tid, "Vector", .no_embedded_nulls),
-                ) orelse @panic("std.builtin.Type is corrupt");
-                try sema.ensureNavResolved(src, nav);
-                break :t Type.fromInterned(ip.getNav(nav).status.resolved.val);
-            };
+            const vector_field_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "Vector");
 
             const info = ty.arrayInfo(zcu);
             const field_values = .{
@@ -18589,52 +18476,34 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 // child: type,
                 info.elem_type.toIntern(),
             };
-            return Air.internedToRef((try pt.intern(.{ .un = .{
+            return Air.internedToRef((try pt.internUnion(.{
                 .ty = type_info_ty.toIntern(),
                 .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.vector))).toIntern(),
                 .val = try pt.intern(.{ .aggregate = .{
                     .ty = vector_field_ty.toIntern(),
                     .storage = .{ .elems = &field_values },
                 } }),
-            } })));
+            })));
         },
         .optional => {
-            const optional_field_ty = t: {
-                const nav = try sema.namespaceLookup(
-                    block,
-                    src,
-                    type_info_ty.getNamespaceIndex(zcu),
-                    try ip.getOrPutString(gpa, pt.tid, "Optional", .no_embedded_nulls),
-                ) orelse @panic("std.builtin.Type is corrupt");
-                try sema.ensureNavResolved(src, nav);
-                break :t Type.fromInterned(ip.getNav(nav).status.resolved.val);
-            };
+            const optional_field_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "Optional");
 
             const field_values = .{
                 // child: type,
                 ty.optionalChild(zcu).toIntern(),
             };
-            return Air.internedToRef((try pt.intern(.{ .un = .{
+            return Air.internedToRef((try pt.internUnion(.{
                 .ty = type_info_ty.toIntern(),
                 .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.optional))).toIntern(),
                 .val = try pt.intern(.{ .aggregate = .{
                     .ty = optional_field_ty.toIntern(),
                     .storage = .{ .elems = &field_values },
                 } }),
-            } })));
+            })));
         },
         .error_set => {
             // Get the Error type
-            const error_field_ty = t: {
-                const nav = try sema.namespaceLookup(
-                    block,
-                    src,
-                    type_info_ty.getNamespaceIndex(zcu),
-                    try ip.getOrPutString(gpa, pt.tid, "Error", .no_embedded_nulls),
-                ) orelse @panic("std.builtin.Type is corrupt");
-                try sema.ensureNavResolved(src, nav);
-                break :t Type.fromInterned(ip.getNav(nav).status.resolved.val);
-            };
+            const error_field_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "Error");
 
             // Build our list of Error values
             // Optional value is only null if anyerror
@@ -18723,23 +18592,14 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             } });
 
             // Construct Type{ .error_set = errors_val }
-            return Air.internedToRef((try pt.intern(.{ .un = .{
+            return Air.internedToRef((try pt.internUnion(.{
                 .ty = type_info_ty.toIntern(),
                 .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.error_set))).toIntern(),
                 .val = errors_val,
-            } })));
+            })));
         },
         .error_union => {
-            const error_union_field_ty = t: {
-                const nav = try sema.namespaceLookup(
-                    block,
-                    src,
-                    type_info_ty.getNamespaceIndex(zcu),
-                    try ip.getOrPutString(gpa, pt.tid, "ErrorUnion", .no_embedded_nulls),
-                ) orelse @panic("std.builtin.Type is corrupt");
-                try sema.ensureNavResolved(src, nav);
-                break :t Type.fromInterned(ip.getNav(nav).status.resolved.val);
-            };
+            const error_union_field_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "ErrorUnion");
 
             const field_values = .{
                 // error_set: type,
@@ -18747,28 +18607,19 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 // payload: type,
                 ty.errorUnionPayload(zcu).toIntern(),
             };
-            return Air.internedToRef((try pt.intern(.{ .un = .{
+            return Air.internedToRef((try pt.internUnion(.{
                 .ty = type_info_ty.toIntern(),
                 .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.error_union))).toIntern(),
                 .val = try pt.intern(.{ .aggregate = .{
                     .ty = error_union_field_ty.toIntern(),
                     .storage = .{ .elems = &field_values },
                 } }),
-            } })));
+            })));
         },
         .@"enum" => {
             const is_exhaustive = Value.makeBool(ip.loadEnumType(ty.toIntern()).tag_mode != .nonexhaustive);
 
-            const enum_field_ty = t: {
-                const nav = try sema.namespaceLookup(
-                    block,
-                    src,
-                    type_info_ty.getNamespaceIndex(zcu),
-                    try ip.getOrPutString(gpa, pt.tid, "EnumField", .no_embedded_nulls),
-                ) orelse @panic("std.builtin.Type is corrupt");
-                try sema.ensureNavResolved(src, nav);
-                break :t Type.fromInterned(ip.getNav(nav).status.resolved.val);
-            };
+            const enum_field_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "EnumField");
 
             const enum_field_vals = try sema.arena.alloc(InternPool.Index, ip.loadEnumType(ty.toIntern()).names.len);
             for (enum_field_vals, 0..) |*field_val, tag_index| {
@@ -18855,16 +18706,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
 
             const decls_val = try sema.typeInfoDecls(block, src, type_info_ty, ip.loadEnumType(ty.toIntern()).namespace.toOptional());
 
-            const type_enum_ty = t: {
-                const nav = try sema.namespaceLookup(
-                    block,
-                    src,
-                    type_info_ty.getNamespaceIndex(zcu),
-                    try ip.getOrPutString(gpa, pt.tid, "Enum", .no_embedded_nulls),
-                ) orelse @panic("std.builtin.Type is corrupt");
-                try sema.ensureNavResolved(src, nav);
-                break :t Type.fromInterned(ip.getNav(nav).status.resolved.val);
-            };
+            const type_enum_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "Enum");
 
             const field_values = .{
                 // tag_type: type,
@@ -18876,37 +18718,18 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 // is_exhaustive: bool,
                 is_exhaustive.toIntern(),
             };
-            return Air.internedToRef((try pt.intern(.{ .un = .{
+            return Air.internedToRef((try pt.internUnion(.{
                 .ty = type_info_ty.toIntern(),
                 .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.@"enum"))).toIntern(),
                 .val = try pt.intern(.{ .aggregate = .{
                     .ty = type_enum_ty.toIntern(),
                     .storage = .{ .elems = &field_values },
                 } }),
-            } })));
+            })));
         },
         .@"union" => {
-            const type_union_ty = t: {
-                const nav = try sema.namespaceLookup(
-                    block,
-                    src,
-                    type_info_ty.getNamespaceIndex(zcu),
-                    try ip.getOrPutString(gpa, pt.tid, "Union", .no_embedded_nulls),
-                ) orelse @panic("std.builtin.Type is corrupt");
-                try sema.ensureNavResolved(src, nav);
-                break :t Type.fromInterned(ip.getNav(nav).status.resolved.val);
-            };
-
-            const union_field_ty = t: {
-                const nav = try sema.namespaceLookup(
-                    block,
-                    src,
-                    type_info_ty.getNamespaceIndex(zcu),
-                    try ip.getOrPutString(gpa, pt.tid, "UnionField", .no_embedded_nulls),
-                ) orelse @panic("std.builtin.Type is corrupt");
-                try sema.ensureNavResolved(src, nav);
-                break :t Type.fromInterned(ip.getNav(nav).status.resolved.val);
-            };
+            const type_union_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "Union");
+            const union_field_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "UnionField");
 
             try ty.resolveLayout(pt); // Getting alignment requires type layout
             const union_obj = zcu.typeToUnion(ty).?;
@@ -19001,16 +18824,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 .val = if (ty.unionTagType(zcu)) |tag_ty| tag_ty.toIntern() else .none,
             } });
 
-            const container_layout_ty = t: {
-                const nav = try sema.namespaceLookup(
-                    block,
-                    src,
-                    (try pt.getBuiltinType("Type")).getNamespaceIndex(zcu),
-                    try ip.getOrPutString(gpa, pt.tid, "ContainerLayout", .no_embedded_nulls),
-                ) orelse @panic("std.builtin.Type is corrupt");
-                try sema.ensureNavResolved(src, nav);
-                break :t Type.fromInterned(ip.getNav(nav).status.resolved.val);
-            };
+            const container_layout_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "ContainerLayout");
 
             const field_values = .{
                 // layout: ContainerLayout,
@@ -19023,37 +18837,18 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 // decls: []const Declaration,
                 decls_val,
             };
-            return Air.internedToRef((try pt.intern(.{ .un = .{
+            return Air.internedToRef((try pt.internUnion(.{
                 .ty = type_info_ty.toIntern(),
                 .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.@"union"))).toIntern(),
                 .val = try pt.intern(.{ .aggregate = .{
                     .ty = type_union_ty.toIntern(),
                     .storage = .{ .elems = &field_values },
                 } }),
-            } })));
+            })));
         },
         .@"struct" => {
-            const type_struct_ty = t: {
-                const nav = try sema.namespaceLookup(
-                    block,
-                    src,
-                    type_info_ty.getNamespaceIndex(zcu),
-                    try ip.getOrPutString(gpa, pt.tid, "Struct", .no_embedded_nulls),
-                ) orelse @panic("std.builtin.Type is corrupt");
-                try sema.ensureNavResolved(src, nav);
-                break :t Type.fromInterned(ip.getNav(nav).status.resolved.val);
-            };
-
-            const struct_field_ty = t: {
-                const nav = try sema.namespaceLookup(
-                    block,
-                    src,
-                    type_info_ty.getNamespaceIndex(zcu),
-                    try ip.getOrPutString(gpa, pt.tid, "StructField", .no_embedded_nulls),
-                ) orelse @panic("std.builtin.Type is corrupt");
-                try sema.ensureNavResolved(src, nav);
-                break :t Type.fromInterned(ip.getNav(nav).status.resolved.val);
-            };
+            const type_struct_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "Struct");
+            const struct_field_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "StructField");
 
             try ty.resolveLayout(pt); // Getting alignment requires type layout
 
@@ -19230,16 +19025,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 } else .none,
             } });
 
-            const container_layout_ty = t: {
-                const nav = try sema.namespaceLookup(
-                    block,
-                    src,
-                    (try pt.getBuiltinType("Type")).getNamespaceIndex(zcu),
-                    try ip.getOrPutString(gpa, pt.tid, "ContainerLayout", .no_embedded_nulls),
-                ) orelse @panic("std.builtin.Type is corrupt");
-                try sema.ensureNavResolved(src, nav);
-                break :t Type.fromInterned(ip.getNav(nav).status.resolved.val);
-            };
+            const container_layout_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "ContainerLayout");
 
             const layout = ty.containerLayout(zcu);
 
@@ -19255,26 +19041,17 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 // is_tuple: bool,
                 Value.makeBool(ty.isTuple(zcu)).toIntern(),
             };
-            return Air.internedToRef((try pt.intern(.{ .un = .{
+            return Air.internedToRef((try pt.internUnion(.{
                 .ty = type_info_ty.toIntern(),
                 .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.@"struct"))).toIntern(),
                 .val = try pt.intern(.{ .aggregate = .{
                     .ty = type_struct_ty.toIntern(),
                     .storage = .{ .elems = &field_values },
                 } }),
-            } })));
+            })));
         },
         .@"opaque" => {
-            const type_opaque_ty = t: {
-                const nav = try sema.namespaceLookup(
-                    block,
-                    src,
-                    type_info_ty.getNamespaceIndex(zcu),
-                    try ip.getOrPutString(gpa, pt.tid, "Opaque", .no_embedded_nulls),
-                ) orelse @panic("std.builtin.Type is corrupt");
-                try sema.ensureNavResolved(src, nav);
-                break :t Type.fromInterned(ip.getNav(nav).status.resolved.val);
-            };
+            const type_opaque_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "Opaque");
 
             try ty.resolveFields(pt);
             const decls_val = try sema.typeInfoDecls(block, src, type_info_ty, ty.getNamespace(zcu));
@@ -19283,14 +19060,14 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 // decls: []const Declaration,
                 decls_val,
             };
-            return Air.internedToRef((try pt.intern(.{ .un = .{
+            return Air.internedToRef((try pt.internUnion(.{
                 .ty = type_info_ty.toIntern(),
                 .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.@"opaque"))).toIntern(),
                 .val = try pt.intern(.{ .aggregate = .{
                     .ty = type_opaque_ty.toIntern(),
                     .storage = .{ .elems = &field_values },
                 } }),
-            } })));
+            })));
         },
         .frame => return sema.failWithUseOfAsync(block, src),
         .@"anyframe" => return sema.failWithUseOfAsync(block, src),
@@ -19306,19 +19083,9 @@ fn typeInfoDecls(
 ) CompileError!InternPool.Index {
     const pt = sema.pt;
     const zcu = pt.zcu;
-    const ip = &zcu.intern_pool;
     const gpa = sema.gpa;
 
-    const declaration_ty = t: {
-        const nav = try sema.namespaceLookup(
-            block,
-            src,
-            type_info_ty.getNamespaceIndex(zcu),
-            try ip.getOrPutString(gpa, pt.tid, "Declaration", .no_embedded_nulls),
-        ) orelse @panic("std.builtin.Type is corrupt");
-        try sema.ensureNavResolved(src, nav);
-        break :t Type.fromInterned(ip.getNav(nav).status.resolved.val);
-    };
+    const declaration_ty = try getBuiltinInnerType(sema, block, src, type_info_ty, "Type", "Declaration");
 
     var decl_vals = std.ArrayList(InternPool.Index).init(gpa);
     defer decl_vals.deinit();
@@ -19738,6 +19505,14 @@ fn checkNullableType(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type) !voi
     return sema.failWithExpectedOptionalType(block, src, ty);
 }
 
+fn checkSentinelType(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type) !void {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    if (!ty.isSelfComparable(zcu, true)) {
+        return sema.fail(block, src, "non-scalar sentinel type '{}'", .{ty.fmt(pt)});
+    }
+}
+
 fn zirIsNonNull(
     sema: *Sema,
     block: *Block,
@@ -20254,11 +20029,11 @@ fn retWithErrTracing(
         else => true,
     };
     const gpa = sema.gpa;
-    const stack_trace_ty = try pt.getBuiltinType("StackTrace");
+    const stack_trace_ty = try sema.getBuiltinType("StackTrace");
     try stack_trace_ty.resolveFields(pt);
     const ptr_stack_trace_ty = try pt.singleMutPtrType(stack_trace_ty);
     const err_return_trace = try block.addTy(.err_return_trace, ptr_stack_trace_ty);
-    const return_err_fn = try pt.getBuiltin("returnError");
+    const return_err_fn = try sema.getBuiltin("returnError");
     const args: [1]Air.Inst.Ref = .{err_return_trace};
 
     if (!need_check) {
@@ -20539,6 +20314,7 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
         const val = try sema.resolveConstDefinedValue(block, sentinel_src, coerced, .{
             .needed_comptime_reason = "pointer sentinel value must be comptime-known",
         });
+        try checkSentinelType(sema, block, sentinel_src, elem_ty);
         break :blk val.toIntern();
     } else .none;
 
@@ -20793,19 +20569,32 @@ fn unionInit(
     const field_index = try sema.unionFieldIndex(block, union_ty, field_name, field_src);
     const field_ty = Type.fromInterned(zcu.typeToUnion(union_ty).?.field_types.get(ip)[field_index]);
     const init = try sema.coerce(block, field_ty, uncasted_init, init_src);
+    _ = union_ty_src;
+    return unionInitFromEnumTag(sema, block, init_src, union_ty, field_index, init);
+}
+
+fn unionInitFromEnumTag(
+    sema: *Sema,
+    block: *Block,
+    init_src: LazySrcLoc,
+    union_ty: Type,
+    field_index: u32,
+    init: Air.Inst.Ref,
+) !Air.Inst.Ref {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
 
     if (try sema.resolveValue(init)) |init_val| {
         const tag_ty = union_ty.unionTagTypeHypothetical(zcu);
         const tag_val = try pt.enumValueFieldIndex(tag_ty, field_index);
-        return Air.internedToRef((try pt.intern(.{ .un = .{
+        return Air.internedToRef((try pt.internUnion(.{
             .ty = union_ty.toIntern(),
             .tag = tag_val.toIntern(),
             .val = init_val.toIntern(),
-        } })));
+        })));
     }
 
     try sema.requireRuntimeBlock(block, init_src, null);
-    _ = union_ty_src;
     return block.addUnionInit(union_ty, field_index, init);
 }
 
@@ -20937,11 +20726,11 @@ fn zirStructInit(
         const init_inst = try sema.coerce(block, field_ty, uncoerced_init_inst, field_src);
 
         if (try sema.resolveValue(init_inst)) |val| {
-            const struct_val = Value.fromInterned(try pt.intern(.{ .un = .{
+            const struct_val = Value.fromInterned(try pt.internUnion(.{
                 .ty = resolved_ty.toIntern(),
                 .tag = tag_val.toIntern(),
                 .val = val.toIntern(),
-            } }));
+            }));
             const final_val_inst = try sema.coerce(block, result_ty, Air.internedToRef(struct_val.toIntern()), src);
             const final_val = (try sema.resolveValue(final_val_inst)).?;
             return sema.addConstantMaybeRef(final_val.toIntern(), is_ref);
@@ -21648,7 +21437,7 @@ fn getErrorReturnTrace(sema: *Sema, block: *Block) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
-    const stack_trace_ty = try pt.getBuiltinType("StackTrace");
+    const stack_trace_ty = try sema.getBuiltinType("StackTrace");
     try stack_trace_ty.resolveFields(pt);
     const ptr_stack_trace_ty = try pt.singleMutPtrType(stack_trace_ty);
     const opt_ptr_stack_trace_ty = try pt.optionalType(ptr_stack_trace_ty.toIntern());
@@ -21861,7 +21650,6 @@ fn zirTagName(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
     const pt = sema.pt;
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
-
     try operand_ty.resolveLayout(pt);
     const enum_ty = switch (operand_ty.zigTypeTag(zcu)) {
         .enum_literal => {
@@ -21938,7 +21726,7 @@ fn zirReify(
             },
         },
     };
-    const type_info_ty = try pt.getBuiltinType("Type");
+    const type_info_ty = try sema.getBuiltinType("Type");
     const uncasted_operand = try sema.resolveInst(extra.operand);
     const type_info = try sema.coerce(block, type_info_ty, uncasted_operand, operand_src);
     const val = try sema.resolveConstDefinedValue(block, operand_src, type_info, .{
@@ -23140,7 +22928,7 @@ fn reifyStruct(
 
 fn resolveVaListRef(sema: *Sema, block: *Block, src: LazySrcLoc, zir_ref: Zir.Inst.Ref) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const va_list_ty = try pt.getBuiltinType("VaList");
+    const va_list_ty = try sema.getBuiltinType("VaList");
     const va_list_ptr = try pt.singleMutPtrType(va_list_ty);
 
     const inst = try sema.resolveInst(zir_ref);
@@ -23179,7 +22967,7 @@ fn zirCVaCopy(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData)
     const va_list_src = block.builtinCallArgSrc(extra.node, 0);
 
     const va_list_ref = try sema.resolveVaListRef(block, va_list_src, extra.operand);
-    const va_list_ty = try sema.pt.getBuiltinType("VaList");
+    const va_list_ty = try sema.getBuiltinType("VaList");
 
     try sema.requireRuntimeBlock(block, src, null);
     return block.addTyOp(.c_va_copy, va_list_ty, va_list_ref);
@@ -23199,7 +22987,7 @@ fn zirCVaEnd(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) C
 fn zirCVaStart(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) CompileError!Air.Inst.Ref {
     const src = block.nodeOffset(@bitCast(extended.operand));
 
-    const va_list_ty = try sema.pt.getBuiltinType("VaList");
+    const va_list_ty = try sema.getBuiltinType("VaList");
     try sema.requireRuntimeBlock(block, src, null);
     return block.addInst(.{
         .tag = .c_va_start,
@@ -24811,7 +24599,7 @@ fn resolveExportOptions(
     const zcu = pt.zcu;
     const gpa = sema.gpa;
     const ip = &zcu.intern_pool;
-    const export_options_ty = try pt.getBuiltinType("ExportOptions");
+    const export_options_ty = try sema.getBuiltinType("ExportOptions");
     const air_ref = try sema.resolveInst(zir_ref);
     const options = try sema.coerce(block, export_options_ty, air_ref, src);
 
@@ -24875,7 +24663,7 @@ fn resolveBuiltinEnum(
     reason: NeededComptimeReason,
 ) CompileError!@field(std.builtin, name) {
     const pt = sema.pt;
-    const ty = try pt.getBuiltinType(name);
+    const ty = try sema.getBuiltinType(name);
     const air_ref = try sema.resolveInst(zir_ref);
     const coerced = try sema.coerce(block, ty, air_ref, src);
     const val = try sema.resolveConstDefinedValue(block, src, coerced, reason);
@@ -25017,26 +24805,66 @@ fn zirSplat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.I
     const scalar_src = block.builtinCallArgSrc(inst_data.src_node, 0);
     const dest_ty = try sema.resolveDestType(block, src, extra.lhs, .remove_eu_opt, "@splat");
 
-    if (!dest_ty.isVector(zcu)) return sema.fail(block, src, "expected vector type, found '{}'", .{dest_ty.fmt(pt)});
+    switch (dest_ty.zigTypeTag(zcu)) {
+        .array, .vector => {},
+        else => return sema.fail(block, src, "expected array or vector type, found '{}'", .{dest_ty.fmt(pt)}),
+    }
 
-    if (!dest_ty.hasRuntimeBits(zcu)) {
+    const operand = try sema.resolveInst(extra.rhs);
+    const scalar_ty = dest_ty.childType(zcu);
+    const scalar = try sema.coerce(block, scalar_ty, operand, scalar_src);
+
+    const len = try sema.usizeCast(block, src, dest_ty.arrayLen(zcu));
+
+    // `len == 0` because `[0:s]T` always has a comptime-known splat.
+    if (!dest_ty.hasRuntimeBits(zcu) or len == 0) {
         const empty_aggregate = try pt.intern(.{ .aggregate = .{
             .ty = dest_ty.toIntern(),
-            .storage = .{ .elems = &[_]InternPool.Index{} },
+            .storage = .{ .elems = &.{} },
         } });
         return Air.internedToRef(empty_aggregate);
     }
 
-    const operand = try sema.resolveInst(extra.rhs);
-    const scalar_ty = dest_ty.childType(zcu);
-    const scalar = try sema.coerce(block, scalar_ty, operand, scalar_src);
+    const maybe_sentinel = dest_ty.sentinel(zcu);
+
     if (try sema.resolveValue(scalar)) |scalar_val| {
-        if (scalar_val.isUndef(zcu)) return pt.undefRef(dest_ty);
-        return Air.internedToRef((try sema.splat(dest_ty, scalar_val)).toIntern());
+        if (scalar_val.isUndef(zcu) and maybe_sentinel == null) {
+            return pt.undefRef(dest_ty);
+        }
+        // TODO: I didn't want to put `.aggregate` on a separate line here; `zig fmt` bugs have forced my hand
+        return Air.internedToRef(try pt.intern(.{
+            .aggregate = .{
+                .ty = dest_ty.toIntern(),
+                .storage = s: {
+                    full: {
+                        if (dest_ty.zigTypeTag(zcu) == .vector) break :full;
+                        const sentinel = maybe_sentinel orelse break :full;
+                        if (sentinel.toIntern() == scalar_val.toIntern()) break :full;
+                        // This is a array with non-zero length and a sentinel which does not match the element.
+                        // We have to use the full `elems` representation.
+                        const elems = try sema.arena.alloc(InternPool.Index, len + 1);
+                        @memset(elems[0..len], scalar_val.toIntern());
+                        elems[len] = sentinel.toIntern();
+                        break :s .{ .elems = elems };
+                    }
+                    break :s .{ .repeated_elem = scalar_val.toIntern() };
+                },
+            },
+        }));
     }
 
     try sema.requireRuntimeBlock(block, src, scalar_src);
-    return block.addTyOp(.splat, dest_ty, scalar);
+
+    switch (dest_ty.zigTypeTag(zcu)) {
+        .array => {
+            const elems = try sema.arena.alloc(Air.Inst.Ref, len + @intFromBool(maybe_sentinel != null));
+            @memset(elems[0..len], scalar);
+            if (maybe_sentinel) |s| elems[len] = Air.internedToRef(s.toIntern());
+            return block.addAggregateInit(dest_ty, elems);
+        },
+        .vector => return block.addTyOp(.splat, dest_ty, scalar),
+        else => unreachable,
+    }
 }
 
 fn zirReduce(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
@@ -25644,7 +25472,7 @@ fn zirBuiltinCall(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
     const extra = sema.code.extraData(Zir.Inst.BuiltinCall, inst_data.payload_index).data;
     const func = try sema.resolveInst(extra.callee);
 
-    const modifier_ty = try pt.getBuiltinType("CallModifier");
+    const modifier_ty = try sema.getBuiltinType("CallModifier");
     const air_ref = try sema.resolveInst(extra.modifier);
     const modifier_ref = try sema.coerce(block, modifier_ty, air_ref, modifier_src);
     const modifier_val = try sema.resolveConstDefinedValue(block, modifier_src, modifier_ref, .{
@@ -26411,6 +26239,8 @@ fn zirMemcpy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
     }
 
     try sema.requireRuntimeBlock(block, src, runtime_src);
+    try sema.validateRuntimeValue(block, dest_src, dest_ptr);
+    try sema.validateRuntimeValue(block, src_src, src_ptr);
 
     // Aliasing safety check.
     if (block.wantSafety()) {
@@ -26539,6 +26369,9 @@ fn zirMemset(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
     };
 
     try sema.requireRuntimeBlock(block, src, runtime_src);
+    try sema.validateRuntimeValue(block, dest_src, dest_ptr);
+    try sema.validateRuntimeValue(block, value_src, elem);
+
     _ = try block.addInst(.{
         .tag = if (block.wantSafety()) .memset_safe else .memset,
         .data = .{ .bin_op = .{
@@ -26770,7 +26603,7 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
         const body = sema.code.bodySlice(extra_index, body_len);
         extra_index += body.len;
 
-        const addrspace_ty = try pt.getBuiltinType("AddressSpace");
+        const addrspace_ty = try sema.getBuiltinType("AddressSpace");
         const val = try sema.resolveGenericBody(block, addrspace_src, body, inst, addrspace_ty, .{
             .needed_comptime_reason = "addrspace must be comptime-known",
         });
@@ -26781,7 +26614,7 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
     } else if (extra.data.bits.has_addrspace_ref) blk: {
         const addrspace_ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_index]);
         extra_index += 1;
-        const addrspace_ty = try pt.getBuiltinType("AddressSpace");
+        const addrspace_ty = try sema.getBuiltinType("AddressSpace");
         const uncoerced_addrspace = sema.resolveInst(addrspace_ref) catch |err| switch (err) {
             error.GenericPoison => break :blk null,
             else => |e| return e,
@@ -26835,7 +26668,7 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
         const body = sema.code.bodySlice(extra_index, body_len);
         extra_index += body.len;
 
-        const cc_ty = try pt.getBuiltinType("CallingConvention");
+        const cc_ty = try sema.getBuiltinType("CallingConvention");
         const val = try sema.resolveGenericBody(block, cc_src, body, inst, cc_ty, .{
             .needed_comptime_reason = "calling convention must be comptime-known",
         });
@@ -26846,7 +26679,7 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
     } else if (extra.data.bits.has_cc_ref) blk: {
         const cc_ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_index]);
         extra_index += 1;
-        const cc_ty = try pt.getBuiltinType("CallingConvention");
+        const cc_ty = try sema.getBuiltinType("CallingConvention");
         const uncoerced_cc = sema.resolveInst(cc_ref) catch |err| switch (err) {
             error.GenericPoison => break :blk null,
             else => |e| return e,
@@ -27063,7 +26896,7 @@ fn resolvePrefetchOptions(
     const zcu = pt.zcu;
     const gpa = sema.gpa;
     const ip = &zcu.intern_pool;
-    const options_ty = try pt.getBuiltinType("PrefetchOptions");
+    const options_ty = try sema.getBuiltinType("PrefetchOptions");
     const options = try sema.coerce(block, options_ty, try sema.resolveInst(zir_ref), src);
 
     const rw_src = block.src(.{ .init_field_rw = src.offset.node_offset_builtin_call_arg.builtin_call_node });
@@ -27136,7 +26969,7 @@ fn resolveExternOptions(
     const gpa = sema.gpa;
     const ip = &zcu.intern_pool;
     const options_inst = try sema.resolveInst(zir_ref);
-    const extern_options_ty = try pt.getBuiltinType("ExternOptions");
+    const extern_options_ty = try sema.getBuiltinType("ExternOptions");
     const options = try sema.coerce(block, extern_options_ty, options_inst, src);
 
     const name_src = block.src(.{ .init_field_name = src.offset.node_offset_builtin_call_arg.builtin_call_node });
@@ -27323,7 +27156,7 @@ fn zirBuiltinValue(sema: *Sema, extended: Zir.Inst.Extended.InstData) CompileErr
 
         // Values are handled here.
         .calling_convention_c => {
-            const callconv_ty = try pt.getBuiltinType("CallingConvention");
+            const callconv_ty = try sema.getBuiltinType("CallingConvention");
             comptime assert(@intFromEnum(std.builtin.CallingConvention.C) == 1);
             const val = try pt.intern(.{ .enum_tag = .{
                 .ty = callconv_ty.toIntern(),
@@ -27332,7 +27165,7 @@ fn zirBuiltinValue(sema: *Sema, extended: Zir.Inst.Extended.InstData) CompileErr
             return Air.internedToRef(val);
         },
         .calling_convention_inline => {
-            const callconv_ty = try pt.getBuiltinType("CallingConvention");
+            const callconv_ty = try sema.getBuiltinType("CallingConvention");
             comptime assert(@intFromEnum(std.builtin.CallingConvention.Inline) == 4);
             const val = try pt.intern(.{ .enum_tag = .{
                 .ty = callconv_ty.toIntern(),
@@ -27341,7 +27174,7 @@ fn zirBuiltinValue(sema: *Sema, extended: Zir.Inst.Extended.InstData) CompileErr
             return Air.internedToRef(val);
         },
     };
-    const ty = try pt.getBuiltinType(type_name);
+    const ty = try sema.getBuiltinType(type_name);
     return Air.internedToRef(ty.toIntern());
 }
 
@@ -27380,7 +27213,7 @@ fn zirBranchHint(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstDat
     const uncoerced_hint = try sema.resolveInst(extra.operand);
     const operand_src = block.builtinCallArgSrc(extra.node, 0);
 
-    const hint_ty = try pt.getBuiltinType("BranchHint");
+    const hint_ty = try sema.getBuiltinType("BranchHint");
     const coerced_hint = try sema.coerce(block, hint_ty, uncoerced_hint, operand_src);
     const hint_val = try sema.resolveConstDefinedValue(block, operand_src, coerced_hint, .{
         .needed_comptime_reason = "operand to '@branchHint' must be comptime-known",
@@ -27833,18 +27666,14 @@ fn prepareSimplePanic(sema: *Sema, block: *Block, src: LazySrcLoc) !void {
     const zcu = pt.zcu;
 
     if (zcu.panic_func_index == .none) {
-        const fn_ref = try sema.analyzeNavVal(block, src, try pt.getBuiltinNav("panic"));
-        const fn_val = try sema.resolveConstValue(block, src, fn_ref, .{
-            .needed_comptime_reason = "panic handler must be comptime-known",
-        });
-        assert(fn_val.typeOf(zcu).zigTypeTag(zcu) == .@"fn");
-        assert(try fn_val.typeOf(zcu).fnHasRuntimeBitsSema(pt));
-        try zcu.ensureFuncBodyAnalysisQueued(fn_val.toIntern());
-        zcu.panic_func_index = fn_val.toIntern();
+        zcu.panic_func_index = try sema.getPanicInnerFn(block, src, "call");
+        // Here, function body analysis must be queued up so that backends can
+        // make calls to this function.
+        try zcu.ensureFuncBodyAnalysisQueued(zcu.panic_func_index);
     }
 
     if (zcu.null_stack_trace == .none) {
-        const stack_trace_ty = try pt.getBuiltinType("StackTrace");
+        const stack_trace_ty = try sema.getBuiltinType("StackTrace");
         try stack_trace_ty.resolveFields(pt);
         const target = zcu.getTarget();
         const ptr_stack_trace_ty = try pt.ptrTypeSema(.{
@@ -27872,14 +27701,15 @@ fn preparePanicId(sema: *Sema, block: *Block, src: LazySrcLoc, panic_id: Zcu.Pan
 
     try sema.prepareSimplePanic(block, src);
 
-    const panic_messages_ty = try pt.getBuiltinType("panic_messages");
+    const panic_ty = try sema.getBuiltinType("Panic");
+    const panic_messages_ty = try sema.getBuiltinInnerType(block, src, panic_ty, "Panic", "messages");
     const msg_nav_index = (sema.namespaceLookup(
         block,
         LazySrcLoc.unneeded,
         panic_messages_ty.getNamespaceIndex(zcu),
         try zcu.intern_pool.getOrPutString(gpa, pt.tid, @tagName(panic_id), .no_embedded_nulls),
     ) catch |err| switch (err) {
-        error.AnalysisFail => @panic("std.builtin.panic_messages is corrupt"),
+        error.AnalysisFail => return error.AnalysisFail,
         error.GenericPoison, error.ComptimeReturn, error.ComptimeBreak => unreachable,
         error.OutOfMemory => |e| return e,
     }).?;
@@ -28003,7 +27833,7 @@ fn panicWithMsg(sema: *Sema, block: *Block, src: LazySrcLoc, msg_inst: Air.Inst.
     try sema.callBuiltin(block, src, panic_fn, .auto, &.{ msg_inst, null_stack_trace, null_ret_addr }, operation);
 }
 
-fn panicUnwrapError(
+fn addSafetyCheckUnwrapError(
     sema: *Sema,
     parent_block: *Block,
     src: LazySrcLoc,
@@ -28011,12 +27841,8 @@ fn panicUnwrapError(
     unwrap_err_tag: Air.Inst.Tag,
     is_non_err_tag: Air.Inst.Tag,
 ) !void {
-    const pt = sema.pt;
     assert(!parent_block.is_comptime);
     const ok = try parent_block.addUnOp(is_non_err_tag, operand);
-    if (!pt.zcu.comp.formatted_panics) {
-        return sema.addSafetyCheck(parent_block, src, ok, .unwrap_error);
-    }
     const gpa = sema.gpa;
 
     var fail_block: Block = .{
@@ -28032,21 +27858,26 @@ fn panicUnwrapError(
 
     defer fail_block.instructions.deinit(gpa);
 
-    {
-        if (!pt.zcu.backendSupportsFeature(.panic_unwrap_error)) {
-            _ = try fail_block.addNoOp(.trap);
-        } else {
-            const panic_fn = try sema.pt.getBuiltin("panicUnwrapError");
-            const err = try fail_block.addTyOp(unwrap_err_tag, Type.anyerror, operand);
-            const err_return_trace = try sema.getErrorReturnTrace(&fail_block);
-            const args: [2]Air.Inst.Ref = .{ err_return_trace, err };
-            try sema.callBuiltin(&fail_block, src, panic_fn, .auto, &args, .@"safety check");
-        }
-    }
+    const err = try fail_block.addTyOp(unwrap_err_tag, Type.anyerror, operand);
+    try safetyPanicUnwrapError(sema, &fail_block, src, err);
+
     try sema.addSafetyCheckExtra(parent_block, ok, &fail_block);
 }
 
-fn panicIndexOutOfBounds(
+fn safetyPanicUnwrapError(sema: *Sema, block: *Block, src: LazySrcLoc, err: Air.Inst.Ref) !void {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    if (!zcu.backendSupportsFeature(.panic_fn)) {
+        _ = try block.addNoOp(.trap);
+    } else {
+        const panic_fn = try getPanicInnerFn(sema, block, src, "unwrapError");
+        const err_return_trace = try sema.getErrorReturnTrace(block);
+        const args: [2]Air.Inst.Ref = .{ err_return_trace, err };
+        try sema.callBuiltin(block, src, Air.internedToRef(panic_fn), .auto, &args, .@"safety check");
+    }
+}
+
+fn addSafetyCheckIndexOob(
     sema: *Sema,
     parent_block: *Block,
     src: LazySrcLoc,
@@ -28056,13 +27887,10 @@ fn panicIndexOutOfBounds(
 ) !void {
     assert(!parent_block.is_comptime);
     const ok = try parent_block.addBinOp(cmp_op, index, len);
-    if (!sema.pt.zcu.comp.formatted_panics) {
-        return sema.addSafetyCheck(parent_block, src, ok, .index_out_of_bounds);
-    }
-    try sema.safetyCheckFormatted(parent_block, src, ok, "panicOutOfBounds", &.{ index, len });
+    return addSafetyCheckCall(sema, parent_block, src, ok, "outOfBounds", &.{ index, len });
 }
 
-fn panicInactiveUnionField(
+fn addSafetyCheckInactiveUnionField(
     sema: *Sema,
     parent_block: *Block,
     src: LazySrcLoc,
@@ -28071,13 +27899,10 @@ fn panicInactiveUnionField(
 ) !void {
     assert(!parent_block.is_comptime);
     const ok = try parent_block.addBinOp(.cmp_eq, active_tag, wanted_tag);
-    if (!sema.pt.zcu.comp.formatted_panics) {
-        return sema.addSafetyCheck(parent_block, src, ok, .inactive_union_field);
-    }
-    try sema.safetyCheckFormatted(parent_block, src, ok, "panicInactiveUnionField", &.{ active_tag, wanted_tag });
+    return addSafetyCheckCall(sema, parent_block, src, ok, "inactiveUnionField", &.{ active_tag, wanted_tag });
 }
 
-fn panicSentinelMismatch(
+fn addSafetyCheckSentinelMismatch(
     sema: *Sema,
     parent_block: *Block,
     src: LazySrcLoc,
@@ -28102,8 +27927,7 @@ fn panicSentinelMismatch(
     };
 
     const ok = if (sentinel_ty.zigTypeTag(zcu) == .vector) ok: {
-        const eql =
-            try parent_block.addCmpVector(expected_sentinel, actual_sentinel, .eq);
+        const eql = try parent_block.addCmpVector(expected_sentinel, actual_sentinel, .eq);
         break :ok try parent_block.addInst(.{
             .tag = .reduce,
             .data = .{ .reduce = .{
@@ -28111,33 +27935,28 @@ fn panicSentinelMismatch(
                 .operation = .And,
             } },
         });
-    } else if (sentinel_ty.isSelfComparable(zcu, true))
-        try parent_block.addBinOp(.cmp_eq, expected_sentinel, actual_sentinel)
-    else {
-        const panic_fn = try pt.getBuiltin("checkNonScalarSentinel");
-        const args: [2]Air.Inst.Ref = .{ expected_sentinel, actual_sentinel };
-        try sema.callBuiltin(parent_block, src, panic_fn, .auto, &args, .@"safety check");
-        return;
+    } else ok: {
+        assert(sentinel_ty.isSelfComparable(zcu, true));
+        break :ok try parent_block.addBinOp(.cmp_eq, expected_sentinel, actual_sentinel);
     };
 
-    if (!pt.zcu.comp.formatted_panics) {
-        return sema.addSafetyCheck(parent_block, src, ok, .sentinel_mismatch);
-    }
-    try sema.safetyCheckFormatted(parent_block, src, ok, "panicSentinelMismatch", &.{ expected_sentinel, actual_sentinel });
+    return addSafetyCheckCall(sema, parent_block, src, ok, "sentinelMismatch", &.{
+        expected_sentinel, actual_sentinel,
+    });
 }
 
-fn safetyCheckFormatted(
+fn addSafetyCheckCall(
     sema: *Sema,
     parent_block: *Block,
     src: LazySrcLoc,
     ok: Air.Inst.Ref,
-    func: []const u8,
+    func_name: []const u8,
     args: []const Air.Inst.Ref,
-) CompileError!void {
+) !void {
+    assert(!parent_block.is_comptime);
+    const gpa = sema.gpa;
     const pt = sema.pt;
     const zcu = pt.zcu;
-    assert(zcu.comp.formatted_panics);
-    const gpa = sema.gpa;
 
     var fail_block: Block = .{
         .parent = parent_block,
@@ -28152,12 +27971,13 @@ fn safetyCheckFormatted(
 
     defer fail_block.instructions.deinit(gpa);
 
-    if (!zcu.backendSupportsFeature(.safety_check_formatted)) {
+    if (!zcu.backendSupportsFeature(.panic_fn)) {
         _ = try fail_block.addNoOp(.trap);
     } else {
-        const panic_fn = try pt.getBuiltin(func);
-        try sema.callBuiltin(&fail_block, src, panic_fn, .auto, args, .@"safety check");
+        const panic_fn = try getPanicInnerFn(sema, &fail_block, src, func_name);
+        try sema.callBuiltin(&fail_block, src, Air.internedToRef(panic_fn), .auto, args, .@"safety check");
     }
+
     try sema.addSafetyCheckExtra(parent_block, ok, &fail_block);
 }
 
@@ -29221,7 +29041,7 @@ fn unionFieldPtr(
         // TODO would it be better if get_union_tag supported pointers to unions?
         const union_val = try block.addTyOp(.load, union_ty, union_ptr);
         const active_tag = try block.addTyOp(.get_union_tag, Type.fromInterned(union_obj.enum_tag_ty), union_val);
-        try sema.panicInactiveUnionField(block, src, active_tag, wanted_tag);
+        try sema.addSafetyCheckInactiveUnionField(block, src, active_tag, wanted_tag);
     }
     if (field_ty.zigTypeTag(zcu) == .noreturn) {
         _ = try block.addNoOp(.unreach);
@@ -29296,7 +29116,7 @@ fn unionFieldVal(
         const wanted_tag_val = try pt.enumValueFieldIndex(Type.fromInterned(union_obj.enum_tag_ty), enum_field_index);
         const wanted_tag = Air.internedToRef(wanted_tag_val.toIntern());
         const active_tag = try block.addTyOp(.get_union_tag, Type.fromInterned(union_obj.enum_tag_ty), union_byval);
-        try sema.panicInactiveUnionField(block, src, active_tag, wanted_tag);
+        try sema.addSafetyCheckInactiveUnionField(block, src, active_tag, wanted_tag);
     }
     if (field_ty.zigTypeTag(zcu) == .noreturn) {
         _ = try block.addNoOp(.unreach);
@@ -29660,11 +29480,11 @@ fn elemValArray(
 
     const runtime_src = if (maybe_undef_array_val != null) elem_index_src else array_src;
     if (oob_safety and block.wantSafety()) {
-        // Runtime check is only needed if unable to comptime check
+        // Runtime check is only needed if unable to comptime check.
         if (maybe_index_val == null) {
             const len_inst = try pt.intRef(Type.usize, array_len);
             const cmp_op: Air.Inst.Tag = if (array_sent != null) .cmp_lte else .cmp_lt;
-            try sema.panicIndexOutOfBounds(block, src, elem_index, len_inst, cmp_op);
+            try sema.addSafetyCheckIndexOob(block, src, elem_index, len_inst, cmp_op);
         }
     }
 
@@ -29732,7 +29552,7 @@ fn elemPtrArray(
     if (oob_safety and block.wantSafety() and offset == null) {
         const len_inst = try pt.intRef(Type.usize, array_len);
         const cmp_op: Air.Inst.Tag = if (array_sent) .cmp_lte else .cmp_lt;
-        try sema.panicIndexOutOfBounds(block, src, elem_index, len_inst, cmp_op);
+        try sema.addSafetyCheckIndexOob(block, src, elem_index, len_inst, cmp_op);
     }
 
     return block.addPtrElemPtr(array_ptr, elem_index, elem_ptr_ty);
@@ -29791,7 +29611,7 @@ fn elemValSlice(
         else
             try block.addTyOp(.slice_len, Type.usize, slice);
         const cmp_op: Air.Inst.Tag = if (slice_sent) .cmp_lte else .cmp_lt;
-        try sema.panicIndexOutOfBounds(block, src, elem_index, len_inst, cmp_op);
+        try sema.addSafetyCheckIndexOob(block, src, elem_index, len_inst, cmp_op);
     }
     return block.addBinOp(.slice_elem_val, slice, elem_index);
 }
@@ -29851,7 +29671,7 @@ fn elemPtrSlice(
             break :len try block.addTyOp(.slice_len, Type.usize, slice);
         };
         const cmp_op: Air.Inst.Tag = if (slice_sent) .cmp_lte else .cmp_lt;
-        try sema.panicIndexOutOfBounds(block, src, elem_index, len_inst, cmp_op);
+        try sema.addSafetyCheckIndexOob(block, src, elem_index, len_inst, cmp_op);
     }
     return block.addSliceElemPtr(slice, elem_index, elem_ptr_ty);
 }
@@ -32883,7 +32703,7 @@ fn optRefValue(sema: *Sema, opt_val: ?Value) !Value {
     return Value.fromInterned(try pt.intern(.{ .opt = .{
         .ty = (try pt.optionalType(ptr_anyopaque_ty.toIntern())).toIntern(),
         .val = if (opt_val) |val| (try pt.getCoerced(
-            Value.fromInterned(try sema.refValue(val.toIntern())),
+            Value.fromInterned(try pt.refValue(val.toIntern())),
             ptr_anyopaque_ty,
         )).toIntern() else .none,
     } }));
@@ -33570,6 +33390,7 @@ fn analyzeSlice(
     const sentinel = s: {
         if (sentinel_opt != .none) {
             const casted = try sema.coerce(block, elem_ty, sentinel_opt, sentinel_src);
+            try checkSentinelType(sema, block, sentinel_src, elem_ty);
             break :s try sema.resolveConstDefinedValue(block, sentinel_src, casted, .{
                 .needed_comptime_reason = "slice sentinel must be comptime-known",
             });
@@ -33658,11 +33479,7 @@ fn analyzeSlice(
         assert(!block.is_comptime);
         try sema.requireRuntimeBlock(block, src, runtime_src.?);
         const ok = try block.addBinOp(.cmp_lte, start, end);
-        if (!pt.zcu.comp.formatted_panics) {
-            try sema.addSafetyCheck(block, src, ok, .start_index_greater_than_end);
-        } else {
-            try sema.safetyCheckFormatted(block, src, ok, "panicStartGreaterThanEnd", &.{ start, end });
-        }
+        try sema.addSafetyCheckCall(block, src, ok, "startGreaterThanEnd", &.{ start, end });
     }
     const new_len = if (by_length)
         try sema.coerce(block, Type.usize, uncasted_end_opt, end_src)
@@ -33717,11 +33534,11 @@ fn analyzeSlice(
                     else
                         end;
 
-                    try sema.panicIndexOutOfBounds(block, src, actual_end, actual_len, .cmp_lte);
+                    try sema.addSafetyCheckIndexOob(block, src, actual_end, actual_len, .cmp_lte);
                 }
 
                 // requirement: result[new_len] == slice_sentinel
-                try sema.panicSentinelMismatch(block, src, slice_sentinel, elem_ty, result, new_len);
+                try sema.addSafetyCheckSentinelMismatch(block, src, slice_sentinel, elem_ty, result, new_len);
             }
             return result;
         };
@@ -33780,11 +33597,11 @@ fn analyzeSlice(
                 try sema.analyzeArithmetic(block, .add, end, .one, src, end_src, end_src, true)
             else
                 end;
-            try sema.panicIndexOutOfBounds(block, src, actual_end, len_inst, .cmp_lte);
+            try sema.addSafetyCheckIndexOob(block, src, actual_end, len_inst, .cmp_lte);
         }
 
         // requirement: start <= end
-        try sema.panicIndexOutOfBounds(block, src, start, end, .cmp_lte);
+        try sema.addSafetyCheckIndexOob(block, src, start, end, .cmp_lte);
     }
     const result = try block.addInst(.{
         .tag = .slice,
@@ -33798,7 +33615,7 @@ fn analyzeSlice(
     });
     if (block.wantSafety()) {
         // requirement: result[new_len] == slice_sentinel
-        try sema.panicSentinelMismatch(block, src, slice_sentinel, elem_ty, result, new_len);
+        try sema.addSafetyCheckSentinelMismatch(block, src, slice_sentinel, elem_ty, result, new_len);
     }
     return result;
 }
@@ -35811,7 +35628,7 @@ pub fn resolveFnTypes(sema: *Sema, fn_ty: Type) CompileError!void {
         Type.fromInterned(fn_ty_info.return_type).isError(zcu))
     {
         // Ensure the type exists so that backends can assume that.
-        _ = try pt.getBuiltinType("StackTrace");
+        _ = try sema.getBuiltinType("StackTrace");
     }
 
     for (0..fn_ty_info.param_types.len) |i| {
@@ -37679,11 +37496,11 @@ pub fn typeHasOnePossibleValue(sema: *Sema, ty: Type) CompileError!?Value {
                     const only_field_ty = Type.fromInterned(union_obj.field_types.get(ip)[0]);
                     const val_val = (try sema.typeHasOnePossibleValue(only_field_ty)) orelse
                         return null;
-                    const only = try pt.intern(.{ .un = .{
+                    const only = try pt.internUnion(.{
                         .ty = ty.toIntern(),
                         .tag = tag_val.toIntern(),
                         .val = val_val.toIntern(),
-                    } });
+                    });
                     return Value.fromInterned(only);
                 },
 
@@ -37857,7 +37674,7 @@ pub fn analyzeAsAddressSpace(
 ) !std.builtin.AddressSpace {
     const pt = sema.pt;
     const zcu = pt.zcu;
-    const addrspace_ty = try pt.getBuiltinType("AddressSpace");
+    const addrspace_ty = try sema.getBuiltinType("AddressSpace");
     const coerced = try sema.coerce(block, addrspace_ty, air_ref, src);
     const addrspace_val = try sema.resolveConstDefinedValue(block, src, coerced, .{
         .needed_comptime_reason = "address space must be comptime-known",
@@ -37882,6 +37699,9 @@ pub fn analyzeAsAddressSpace(
         .constant => is_gpu and (ctx == .constant),
         // TODO this should also check how many flash banks the cpu has
         .flash, .flash1, .flash2, .flash3, .flash4, .flash5 => arch == .avr,
+
+        .cog, .hub => arch.isPropeller(),
+        .lut => (arch == .propeller2),
     };
 
     if (!supported) {
@@ -38840,7 +38660,7 @@ fn analyzeUnreachable(sema: *Sema, block: *Block, src: LazySrcLoc, safety_check:
             sema.branch_hint = .cold;
         }
 
-        try sema.safetyPanic(block, src, .unreach);
+        try sema.safetyPanic(block, src, .reached_unreachable);
     } else {
         _ = try block.addNoOp(.unreach);
     }
@@ -39114,3 +38934,70 @@ const loadComptimePtr = @import("Sema/comptime_ptr_access.zig").loadComptimePtr;
 const ComptimeLoadResult = @import("Sema/comptime_ptr_access.zig").ComptimeLoadResult;
 const storeComptimePtr = @import("Sema/comptime_ptr_access.zig").storeComptimePtr;
 const ComptimeStoreResult = @import("Sema/comptime_ptr_access.zig").ComptimeStoreResult;
+
+fn getPanicInnerFn(
+    sema: *Sema,
+    block: *Block,
+    src: LazySrcLoc,
+    inner_name: []const u8,
+) !InternPool.Index {
+    const gpa = sema.gpa;
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const ip = &zcu.intern_pool;
+    const outer_ty = try sema.getBuiltinType("Panic");
+    const inner_name_ip = try ip.getOrPutString(gpa, pt.tid, inner_name, .no_embedded_nulls);
+    const opt_fn_ref = try namespaceLookupVal(sema, block, src, outer_ty.getNamespaceIndex(zcu), inner_name_ip);
+    const fn_ref = opt_fn_ref orelse return sema.fail(block, src, "std.builtin.Panic missing {s}", .{inner_name});
+    const fn_val = try sema.resolveConstValue(block, src, fn_ref, .{
+        .needed_comptime_reason = "panic handler must be comptime-known",
+    });
+    if (fn_val.typeOf(zcu).zigTypeTag(zcu) != .@"fn") {
+        return sema.fail(block, src, "std.builtin.Panic.{s} is not a function", .{inner_name});
+    }
+    // Better not to queue up function body analysis because the function might be generic, and
+    // the semantic analysis for the call will already queue if necessary.
+    return fn_val.toIntern();
+}
+
+fn getBuiltinType(sema: *Sema, name: []const u8) SemaError!Type {
+    const pt = sema.pt;
+    const ty_inst = try sema.getBuiltin(name);
+    const ty = Type.fromInterned(ty_inst.toInterned() orelse @panic("std.builtin is corrupt"));
+    try ty.resolveFully(pt);
+    return ty;
+}
+
+fn getBuiltinInnerType(
+    sema: *Sema,
+    block: *Block,
+    src: LazySrcLoc,
+    outer_ty: Type,
+    /// Relative to "std.builtin".
+    compile_error_parent_name: []const u8,
+    inner_name: []const u8,
+) !Type {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const ip = &zcu.intern_pool;
+    const gpa = sema.gpa;
+    const inner_name_ip = try ip.getOrPutString(gpa, pt.tid, inner_name, .no_embedded_nulls);
+    const opt_nav = try sema.namespaceLookup(block, src, outer_ty.getNamespaceIndex(zcu), inner_name_ip);
+    const nav = opt_nav orelse return sema.fail(block, src, "std.builtin.{s} missing {s}", .{
+        compile_error_parent_name, inner_name,
+    });
+    try sema.ensureNavResolved(src, nav);
+    const val = Value.fromInterned(ip.getNav(nav).status.resolved.val);
+    const ty = val.toType();
+    try ty.resolveFully(pt);
+    return ty;
+}
+
+fn getBuiltin(sema: *Sema, name: []const u8) SemaError!Air.Inst.Ref {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const ip = &zcu.intern_pool;
+    const nav = try pt.getBuiltinNav(name);
+    try pt.ensureCauAnalyzed(ip.getNav(nav).analysis_owner.unwrap().?);
+    return Air.internedToRef(ip.getNav(nav).status.resolved.val);
+}
diff --git a/zig/src/Sema/bitcast.zig b/zig/src/Sema/bitcast.zig
index d3adbe7eb8..25955b113f 100644
--- a/zig/src/Sema/bitcast.zig
+++ b/zig/src/Sema/bitcast.zig
@@ -613,11 +613,11 @@ const PackValueBits = struct {
                         pack.bit_offset = prev_bit_offset;
                         break :backing;
                     }
-                    return Value.fromInterned(try pt.intern(.{ .un = .{
+                    return Value.fromInterned(try pt.internUnion(.{
                         .ty = ty.toIntern(),
                         .tag = .none,
                         .val = backing_val.toIntern(),
-                    } }));
+                    }));
                 }
 
                 const field_order = try pack.arena.alloc(u32, ty.unionTagTypeHypothetical(zcu).enumFieldCount(zcu));
@@ -658,21 +658,21 @@ const PackValueBits = struct {
                         continue;
                     }
                     const tag_val = try pt.enumValueFieldIndex(ty.unionTagTypeHypothetical(zcu), field_idx);
-                    return Value.fromInterned(try pt.intern(.{ .un = .{
+                    return Value.fromInterned(try pt.internUnion(.{
                         .ty = ty.toIntern(),
                         .tag = tag_val.toIntern(),
                         .val = field_val.toIntern(),
-                    } }));
+                    }));
                 }
 
                 // No field could represent the value. Just do whatever happens when we try to read
                 // the backing type - either `undefined` or `error.ReinterpretDeclRef`.
                 const backing_val = try pack.get(backing_ty);
-                return Value.fromInterned(try pt.intern(.{ .un = .{
+                return Value.fromInterned(try pt.internUnion(.{
                     .ty = ty.toIntern(),
                     .tag = .none,
                     .val = backing_val.toIntern(),
-                } }));
+                }));
             },
             else => return pack.primitive(ty),
         }
diff --git a/zig/src/Type.zig b/zig/src/Type.zig
index 0dfd12cb35..808c8cfdb3 100644
--- a/zig/src/Type.zig
+++ b/zig/src/Type.zig
@@ -1641,6 +1641,7 @@ pub fn maxIntAlignment(target: std.Target, use_llvm: bool) u16 {
         .avr => 1,
         .msp430 => 2,
         .xcore => 4,
+        .propeller1, .propeller2 => 4,
 
         .arm,
         .armeb,
@@ -1703,7 +1704,6 @@ pub fn maxIntAlignment(target: std.Target, use_llvm: bool) u16 {
         .spirv32,
         .ve,
         .spirv64,
-        .dxil,
         .loongarch32,
         .loongarch64,
         .xtensa,
@@ -2678,11 +2678,11 @@ pub fn onePossibleValue(starting_type: Type, pt: Zcu.PerThread) !?Value {
                 const only_field_ty = union_obj.field_types.get(ip)[0];
                 const val_val = (try Type.fromInterned(only_field_ty).onePossibleValue(pt)) orelse
                     return null;
-                const only = try pt.intern(.{ .un = .{
+                const only = try pt.internUnion(.{
                     .ty = ty.toIntern(),
                     .tag = tag_val.toIntern(),
                     .val = val_val.toIntern(),
-                } });
+                });
                 return Value.fromInterned(only);
             },
             .opaque_type => return null,
diff --git a/zig/src/Value.zig b/zig/src/Value.zig
index d6e533429a..157f47bc7e 100644
--- a/zig/src/Value.zig
+++ b/zig/src/Value.zig
@@ -713,11 +713,11 @@ pub fn readFromMemory(
                 const union_size = ty.abiSize(zcu);
                 const array_ty = try zcu.arrayType(.{ .len = union_size, .child = .u8_type });
                 const val = (try readFromMemory(array_ty, zcu, buffer, arena)).toIntern();
-                return Value.fromInterned(try pt.intern(.{ .un = .{
+                return Value.fromInterned(try pt.internUnion(.{
                     .ty = ty.toIntern(),
                     .tag = .none,
                     .val = val,
-                } }));
+                }));
             },
             .@"packed" => {
                 const byte_count = (@as(usize, @intCast(ty.bitSize(zcu))) + 7) / 8;
@@ -860,11 +860,11 @@ pub fn readFromPackedMemory(
             .@"packed" => {
                 const backing_ty = try ty.unionBackingType(pt);
                 const val = (try readFromPackedMemory(backing_ty, pt, buffer, bit_offset, arena)).toIntern();
-                return Value.fromInterned(try pt.intern(.{ .un = .{
+                return Value.fromInterned(try pt.internUnion(.{
                     .ty = ty.toIntern(),
                     .tag = .none,
                     .val = val,
-                } }));
+                }));
             },
         },
         .pointer => {
@@ -4481,11 +4481,11 @@ pub fn resolveLazy(
             return if (resolved_tag == un.tag and resolved_val == un.val)
                 val
             else
-                Value.fromInterned(try pt.intern(.{ .un = .{
+                Value.fromInterned(try pt.internUnion(.{
                     .ty = un.ty,
                     .tag = resolved_tag,
                     .val = resolved_val,
-                } }));
+                }));
         },
         else => return val,
     }
diff --git a/zig/src/Zcu.zig b/zig/src/Zcu.zig
index 3b0d5d9d87..641c7fc880 100644
--- a/zig/src/Zcu.zig
+++ b/zig/src/Zcu.zig
@@ -220,7 +220,7 @@ generation: u32 = 0,
 pub const PerThread = @import("Zcu/PerThread.zig");
 
 pub const PanicId = enum {
-    unreach,
+    reached_unreachable,
     unwrap_null,
     cast_to_null,
     incorrect_alignment,
@@ -232,15 +232,10 @@ pub const PanicId = enum {
     shr_overflow,
     divide_by_zero,
     exact_division_remainder,
-    inactive_union_field,
     integer_part_out_of_bounds,
     corrupt_switch,
     shift_rhs_too_big,
     invalid_enum_value,
-    sentinel_mismatch,
-    unwrap_error,
-    index_out_of_bounds,
-    start_index_greater_than_end,
     for_len_mismatch,
     memcpy_len_mismatch,
     memcpy_alias,
@@ -2923,17 +2918,10 @@ pub fn addGlobalAssembly(zcu: *Zcu, cau: InternPool.Cau.Index, source: []const u
 }
 
 pub const Feature = enum {
-    /// When this feature is enabled, Sema will emit calls to `std.builtin.panic`
-    /// for things like safety checks and unreachables. Otherwise traps will be emitted.
+    /// When this feature is enabled, Sema will emit calls to
+    /// `std.builtin.Panic` functions for things like safety checks and
+    /// unreachables. Otherwise traps will be emitted.
     panic_fn,
-    /// When this feature is enabled, Sema will emit calls to `std.builtin.panicUnwrapError`.
-    /// This error message requires more advanced formatting, hence it being seperate from `panic_fn`.
-    /// Otherwise traps will be emitted.
-    panic_unwrap_error,
-    /// When this feature is enabled, Sema will emit calls to the more complex panic functions
-    /// that use formatting to add detail to error messages. Similar to `panic_unwrap_error`.
-    /// Otherwise traps will be emitted.
-    safety_check_formatted,
     /// When this feature is enabled, Sema will insert tracer functions for gathering a stack
     /// trace for error returns.
     error_return_trace,
@@ -3010,9 +2998,10 @@ pub fn atomicPtrAlignment(
         .wasm32,
         .csky,
         .spirv32,
-        .dxil,
         .loongarch32,
         .xtensa,
+        .propeller1,
+        .propeller2,
         => 32,
 
         .amdgcn,
diff --git a/zig/src/Zcu/PerThread.zig b/zig/src/Zcu/PerThread.zig
index a11910302d..8cc72dc4d9 100644
--- a/zig/src/Zcu/PerThread.zig
+++ b/zig/src/Zcu/PerThread.zig
@@ -1,6 +1,32 @@
 //! This type provides a wrapper around a `*Zcu` for uses which require a thread `Id`.
 //! Any operation which mutates `InternPool` state lives here rather than on `Zcu`.
 
+const Air = @import("../Air.zig");
+const Allocator = std.mem.Allocator;
+const assert = std.debug.assert;
+const Ast = std.zig.Ast;
+const AstGen = std.zig.AstGen;
+const BigIntConst = std.math.big.int.Const;
+const BigIntMutable = std.math.big.int.Mutable;
+const build_options = @import("build_options");
+const builtin = @import("builtin");
+const Cache = std.Build.Cache;
+const dev = @import("../dev.zig");
+const InternPool = @import("../InternPool.zig");
+const AnalUnit = InternPool.AnalUnit;
+const isUpDir = @import("../introspect.zig").isUpDir;
+const Liveness = @import("../Liveness.zig");
+const log = std.log.scoped(.zcu);
+const Module = @import("../Package.zig").Module;
+const Sema = @import("../Sema.zig");
+const std = @import("std");
+const target_util = @import("../target.zig");
+const trace = @import("../tracy.zig").trace;
+const Type = @import("../Type.zig");
+const Value = @import("../Value.zig");
+const Zcu = @import("../Zcu.zig");
+const Zir = std.zig.Zir;
+
 zcu: *Zcu,
 
 /// Dense, per-thread unique index.
@@ -2697,11 +2723,16 @@ pub fn reportRetryableFileError(
     gop.value_ptr.* = err_msg;
 }
 
-///Shortcut for calling `intern_pool.get`.
+/// Shortcut for calling `intern_pool.get`.
 pub fn intern(pt: Zcu.PerThread, key: InternPool.Key) Allocator.Error!InternPool.Index {
     return pt.zcu.intern_pool.get(pt.zcu.gpa, pt.tid, key);
 }
 
+/// Shortcut for calling `intern_pool.getUnion`.
+pub fn internUnion(pt: Zcu.PerThread, un: InternPool.Key.Union) Allocator.Error!InternPool.Index {
+    return pt.zcu.intern_pool.getUnion(pt.zcu.gpa, pt.tid, un);
+}
+
 /// Essentially a shortcut for calling `intern_pool.getCoerced`.
 /// However, this function also allows coercing `extern`s. The `InternPool` function can't do
 /// this because it requires potentially pushing to the job queue.
@@ -2949,11 +2980,12 @@ pub fn intValue_i64(pt: Zcu.PerThread, ty: Type, x: i64) Allocator.Error!Value {
 }
 
 pub fn unionValue(pt: Zcu.PerThread, union_ty: Type, tag: Value, val: Value) Allocator.Error!Value {
-    return Value.fromInterned(try pt.intern(.{ .un = .{
+    const zcu = pt.zcu;
+    return Value.fromInterned(try zcu.intern_pool.getUnion(zcu.gpa, pt.tid, .{
         .ty = union_ty.toIntern(),
         .tag = tag.toIntern(),
         .val = val.toIntern(),
-    } }));
+    }));
 }
 
 /// This function casts the float representation down to the representation of the type, potentially
@@ -3069,14 +3101,6 @@ pub fn structPackedFieldBitOffset(
     unreachable; // index out of bounds
 }
 
-pub fn getBuiltin(pt: Zcu.PerThread, name: []const u8) Allocator.Error!Air.Inst.Ref {
-    const zcu = pt.zcu;
-    const ip = &zcu.intern_pool;
-    const nav = try pt.getBuiltinNav(name);
-    pt.ensureCauAnalyzed(ip.getNav(nav).analysis_owner.unwrap().?) catch @panic("std.builtin is corrupt");
-    return Air.internedToRef(ip.getNav(nav).status.resolved.val);
-}
-
 pub fn getBuiltinNav(pt: Zcu.PerThread, name: []const u8) Allocator.Error!InternPool.Nav.Index {
     const zcu = pt.zcu;
     const gpa = zcu.gpa;
@@ -3094,13 +3118,6 @@ pub fn getBuiltinNav(pt: Zcu.PerThread, name: []const u8) Allocator.Error!Intern
     return builtin_namespace.pub_decls.getKeyAdapted(name_str, Zcu.Namespace.NameAdapter{ .zcu = zcu }) orelse @panic("lib/std/builtin.zig is corrupt");
 }
 
-pub fn getBuiltinType(pt: Zcu.PerThread, name: []const u8) Allocator.Error!Type {
-    const ty_inst = try pt.getBuiltin(name);
-    const ty = Type.fromInterned(ty_inst.toInterned() orelse @panic("std.builtin is corrupt"));
-    ty.resolveFully(pt) catch @panic("std.builtin is corrupt");
-    return ty;
-}
-
 pub fn navPtrType(pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) Allocator.Error!Type {
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
@@ -3650,28 +3667,21 @@ pub fn ensureNamespaceUpToDate(pt: Zcu.PerThread, namespace_index: Zcu.Namespace
     namespace.generation = zcu.generation;
 }
 
-const Air = @import("../Air.zig");
-const Allocator = std.mem.Allocator;
-const assert = std.debug.assert;
-const Ast = std.zig.Ast;
-const AstGen = std.zig.AstGen;
-const BigIntConst = std.math.big.int.Const;
-const BigIntMutable = std.math.big.int.Mutable;
-const build_options = @import("build_options");
-const builtin = @import("builtin");
-const Cache = std.Build.Cache;
-const dev = @import("../dev.zig");
-const InternPool = @import("../InternPool.zig");
-const AnalUnit = InternPool.AnalUnit;
-const isUpDir = @import("../introspect.zig").isUpDir;
-const Liveness = @import("../Liveness.zig");
-const log = std.log.scoped(.zcu);
-const Module = @import("../Package.zig").Module;
-const Sema = @import("../Sema.zig");
-const std = @import("std");
-const target_util = @import("../target.zig");
-const trace = @import("../tracy.zig").trace;
-const Type = @import("../Type.zig");
-const Value = @import("../Value.zig");
-const Zcu = @import("../Zcu.zig");
-const Zir = std.zig.Zir;
+pub fn refValue(pt: Zcu.PerThread, val: InternPool.Index) Zcu.SemaError!InternPool.Index {
+    const ptr_ty = (try pt.ptrTypeSema(.{
+        .child = pt.zcu.intern_pool.typeOf(val),
+        .flags = .{
+            .alignment = .none,
+            .is_const = true,
+            .address_space = .generic,
+        },
+    })).toIntern();
+    return pt.intern(.{ .ptr = .{
+        .ty = ptr_ty,
+        .base_addr = .{ .uav = .{
+            .val = val,
+            .orig_ty = ptr_ty,
+        } },
+        .byte_offset = 0,
+    } });
+}
diff --git a/zig/src/arch/aarch64/CodeGen.zig b/zig/src/arch/aarch64/CodeGen.zig
index 649be16c06..012de69bd1 100644
--- a/zig/src/arch/aarch64/CodeGen.zig
+++ b/zig/src/arch/aarch64/CodeGen.zig
@@ -739,7 +739,6 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
             .breakpoint      => try self.airBreakpoint(),
             .ret_addr        => try self.airRetAddr(inst),
             .frame_addr      => try self.airFrameAddress(inst),
-            .fence           => try self.airFence(),
             .cond_br         => try self.airCondBr(inst),
             .fptrunc         => try self.airFptrunc(inst),
             .fpext           => try self.airFpext(inst),
@@ -4264,11 +4263,6 @@ fn airFrameAddress(self: *Self, inst: Air.Inst.Index) !void {
     return self.finishAir(inst, result, .{ .none, .none, .none });
 }
 
-fn airFence(self: *Self) !void {
-    return self.fail("TODO implement fence() for {}", .{self.target.cpu.arch});
-    //return self.finishAirBookkeeping();
-}
-
 fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier) !void {
     if (modifier == .always_tail) return self.fail("TODO implement tail calls for aarch64", .{});
     const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
diff --git a/zig/src/arch/aarch64/Mir.zig b/zig/src/arch/aarch64/Mir.zig
index d4b2d0d1a0..edf05f625e 100644
--- a/zig/src/arch/aarch64/Mir.zig
+++ b/zig/src/arch/aarch64/Mir.zig
@@ -168,7 +168,7 @@ pub const Inst = struct {
         orr_shifted_register,
         /// Pseudo-instruction: Pop multiple registers
         pop_regs,
-        /// Psuedo-instruction: Push multiple registers
+        /// Pseudo-instruction: Push multiple registers
         push_regs,
         /// Return from subroutine
         ret,
diff --git a/zig/src/arch/arm/CodeGen.zig b/zig/src/arch/arm/CodeGen.zig
index 48137d4413..1eb01f365a 100644
--- a/zig/src/arch/arm/CodeGen.zig
+++ b/zig/src/arch/arm/CodeGen.zig
@@ -726,7 +726,6 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
             .breakpoint      => try self.airBreakpoint(),
             .ret_addr        => try self.airRetAddr(inst),
             .frame_addr      => try self.airFrameAddress(inst),
-            .fence           => try self.airFence(),
             .cond_br         => try self.airCondBr(inst),
             .fptrunc         => try self.airFptrunc(inst),
             .fpext           => try self.airFpext(inst),
@@ -4244,11 +4243,6 @@ fn airFrameAddress(self: *Self, inst: Air.Inst.Index) !void {
     return self.finishAir(inst, result, .{ .none, .none, .none });
 }
 
-fn airFence(self: *Self) !void {
-    return self.fail("TODO implement fence() for {}", .{self.target.cpu.arch});
-    //return self.finishAirBookkeeping();
-}
-
 fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier) !void {
     if (modifier == .always_tail) return self.fail("TODO implement tail calls for arm", .{});
     const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
diff --git a/zig/src/arch/mips/abi.zig b/zig/src/arch/mips/abi.zig
index 8f3cebd21c..02c4c637a4 100644
--- a/zig/src/arch/mips/abi.zig
+++ b/zig/src/arch/mips/abi.zig
@@ -41,8 +41,6 @@ pub fn classifyType(ty: Type, zcu: *Zcu, ctx: Context) Class {
         .bool => return .byval,
         .float => return .byval,
         .int, .@"enum", .error_set => {
-            const bit_size = ty.bitSize(zcu);
-            if (bit_size > max_direct_size) return .memory;
             return .byval;
         },
         .vector => {
diff --git a/zig/src/arch/riscv64/CodeGen.zig b/zig/src/arch/riscv64/CodeGen.zig
index 73fa0460de..7309160488 100644
--- a/zig/src/arch/riscv64/CodeGen.zig
+++ b/zig/src/arch/riscv64/CodeGen.zig
@@ -1593,7 +1593,6 @@ fn genBody(func: *Func, body: []const Air.Inst.Index) InnerError!void {
             .breakpoint      => try func.airBreakpoint(),
             .ret_addr        => try func.airRetAddr(inst),
             .frame_addr      => try func.airFrameAddress(inst),
-            .fence           => try func.airFence(inst),
             .cond_br         => try func.airCondBr(inst),
             .dbg_stmt        => try func.airDbgStmt(inst),
             .fptrunc         => try func.airFptrunc(inst),
@@ -4833,26 +4832,6 @@ fn airFrameAddress(func: *Func, inst: Air.Inst.Index) !void {
     return func.finishAir(inst, dst_mcv, .{ .none, .none, .none });
 }
 
-fn airFence(func: *Func, inst: Air.Inst.Index) !void {
-    const order = func.air.instructions.items(.data)[@intFromEnum(inst)].fence;
-    const pred: Mir.Barrier, const succ: Mir.Barrier = switch (order) {
-        .unordered, .monotonic => unreachable,
-        .acquire => .{ .r, .rw },
-        .release => .{ .rw, .r },
-        .acq_rel => .{ .rw, .rw },
-        .seq_cst => .{ .rw, .rw },
-    };
-
-    _ = try func.addInst(.{
-        .tag = if (order == .acq_rel) .fencetso else .fence,
-        .data = .{ .fence = .{
-            .pred = pred,
-            .succ = succ,
-        } },
-    });
-    return func.finishAirBookkeeping();
-}
-
 fn airCall(func: *Func, inst: Air.Inst.Index, modifier: std.builtin.CallModifier) !void {
     if (modifier == .always_tail) return func.fail("TODO implement tail calls for riscv64", .{});
     const pl_op = func.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
diff --git a/zig/src/arch/sparc64/CodeGen.zig b/zig/src/arch/sparc64/CodeGen.zig
index f2ffd517f9..5006ebc4f6 100644
--- a/zig/src/arch/sparc64/CodeGen.zig
+++ b/zig/src/arch/sparc64/CodeGen.zig
@@ -581,7 +581,6 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
             .breakpoint      => try self.airBreakpoint(),
             .ret_addr        => @panic("TODO try self.airRetAddr(inst)"),
             .frame_addr      => @panic("TODO try self.airFrameAddress(inst)"),
-            .fence           => try self.airFence(inst),
             .cond_br         => try self.airCondBr(inst),
             .fptrunc         => @panic("TODO try self.airFptrunc(inst)"),
             .fpext           => @panic("TODO try self.airFpext(inst)"),
@@ -1693,29 +1692,6 @@ fn airErrUnionPayloadPtrSet(self: *Self, inst: Air.Inst.Index) !void {
     return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
 }
 
-fn airFence(self: *Self, inst: Air.Inst.Index) !void {
-    // TODO weaken this as needed, currently this implements the strongest membar form
-    const fence = self.air.instructions.items(.data)[@intFromEnum(inst)].fence;
-    _ = fence;
-
-    // membar #StoreStore | #LoadStore | #StoreLoad | #LoadLoad
-    _ = try self.addInst(.{
-        .tag = .membar,
-        .data = .{
-            .membar_mask = .{
-                .mmask = .{
-                    .store_store = true,
-                    .store_load = true,
-                    .load_store = true,
-                    .load_load = true,
-                },
-            },
-        },
-    });
-
-    return self.finishAir(inst, .dead, .{ .none, .none, .none });
-}
-
 fn airIntFromFloat(self: *Self, inst: Air.Inst.Index) !void {
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airIntFromFloat for {}", .{
diff --git a/zig/src/arch/wasm/CodeGen.zig b/zig/src/arch/wasm/CodeGen.zig
index 193bd27a38..c78fc1584f 100644
--- a/zig/src/arch/wasm/CodeGen.zig
+++ b/zig/src/arch/wasm/CodeGen.zig
@@ -2040,7 +2040,6 @@ fn genInst(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
         .atomic_rmw => func.airAtomicRmw(inst),
         .cmpxchg_weak => func.airCmpxchg(inst),
         .cmpxchg_strong => func.airCmpxchg(inst),
-        .fence => func.airFence(inst),
 
         .add_optimized,
         .sub_optimized,
@@ -2784,6 +2783,7 @@ const FloatOp = enum {
             .sqrt => .sqrt,
             .sub => .sub,
             .trunc => .trunc,
+            .rem => .fmod,
             else => unreachable,
         };
     }
@@ -6809,30 +6809,37 @@ fn airMod(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const lhs = try func.resolveInst(bin_op.lhs);
     const rhs = try func.resolveInst(bin_op.rhs);
 
-    if (ty.isUnsignedInt(zcu)) {
-        _ = try func.binOp(lhs, rhs, ty, .rem);
-    } else if (ty.isSignedInt(zcu)) {
-        // The wasm rem instruction gives the remainder after truncating division (rounding towards
-        // 0), equivalent to @rem.
-        // We make use of the fact that:
-        // @mod(a, b) = @rem(@rem(a, b) + b, b)
-        const int_bits = ty.intInfo(zcu).bits;
-        const wasm_bits = toWasmBits(int_bits) orelse {
-            return func.fail("TODO: `@mod` for signed integers larger than 64 bits ({d} bits requested)", .{int_bits});
-        };
-
-        if (wasm_bits > 64) {
-            return func.fail("TODO: `@mod` for signed integers larger than 64 bits ({d} bits requested)", .{int_bits});
+    const result = result: {
+        if (ty.isUnsignedInt(zcu)) {
+            break :result try func.binOp(lhs, rhs, ty, .rem);
         }
+        if (ty.isSignedInt(zcu)) {
+            // The wasm rem instruction gives the remainder after truncating division (rounding towards
+            // 0), equivalent to @rem.
+            // We make use of the fact that:
+            // @mod(a, b) = @rem(@rem(a, b) + b, b)
+            const int_bits = ty.intInfo(zcu).bits;
+            const wasm_bits = toWasmBits(int_bits) orelse {
+                return func.fail("TODO: `@mod` for signed integers larger than 64 bits ({d} bits requested)", .{int_bits});
+            };
 
-        _ = try func.binOp(lhs, rhs, ty, .rem);
-        _ = try func.binOp(.stack, rhs, ty, .add);
-        _ = try func.binOp(.stack, rhs, ty, .rem);
-    } else {
-        return func.fail("TODO: implement `@mod` on floating point types for {}", .{func.target.cpu.arch});
-    }
+            if (wasm_bits > 64) {
+                return func.fail("TODO: `@mod` for signed integers larger than 64 bits ({d} bits requested)", .{int_bits});
+            }
 
-    return func.finishAir(inst, .stack, &.{ bin_op.lhs, bin_op.rhs });
+            _ = try func.binOp(lhs, rhs, ty, .rem);
+            _ = try func.binOp(.stack, rhs, ty, .add);
+            break :result try func.binOp(.stack, rhs, ty, .rem);
+        }
+        if (ty.isAnyFloat()) {
+            const rem = try func.binOp(lhs, rhs, ty, .rem);
+            const add = try func.binOp(rem, rhs, ty, .add);
+            break :result try func.binOp(add, rhs, ty, .rem);
+        }
+        return func.fail("TODO: @mod for {}", .{ty.fmt(pt)});
+    };
+
+    return func.finishAir(inst, result, &.{ bin_op.lhs, bin_op.rhs });
 }
 
 fn airSatMul(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
@@ -7742,20 +7749,6 @@ fn airAtomicRmw(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     }
 }
 
-fn airFence(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
-    const pt = func.pt;
-    const zcu = pt.zcu;
-    // Only when the atomic feature is enabled, and we're not building
-    // for a single-threaded build, can we emit the `fence` instruction.
-    // In all other cases, we emit no instructions for a fence.
-    const single_threaded = zcu.navFileScope(func.owner_nav).mod.single_threaded;
-    if (func.useAtomicFeature() and !single_threaded) {
-        try func.addAtomicTag(.atomic_fence);
-    }
-
-    return func.finishAir(inst, .none, &.{});
-}
-
 fn airAtomicStore(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
     const zcu = pt.zcu;
diff --git a/zig/src/arch/x86_64/CodeGen.zig b/zig/src/arch/x86_64/CodeGen.zig
index 01e60367ea..3e272a43f2 100644
--- a/zig/src/arch/x86_64/CodeGen.zig
+++ b/zig/src/arch/x86_64/CodeGen.zig
@@ -36,6 +36,7 @@ const abi = @import("abi.zig");
 const bits = @import("bits.zig");
 const errUnionErrorOffset = codegen.errUnionErrorOffset;
 const errUnionPayloadOffset = codegen.errUnionPayloadOffset;
+const encoder = @import("encoder.zig");
 
 const Condition = bits.Condition;
 const Immediate = bits.Immediate;
@@ -1188,6 +1189,74 @@ fn formatWipMir(
         try writer.print("  | {}", .{lowered_inst});
         first = false;
     }
+    if (first) {
+        const ip = &data.self.pt.zcu.intern_pool;
+        const mir_inst = lower.mir.instructions.get(data.inst);
+        try writer.print("  | .{s}", .{@tagName(mir_inst.ops)});
+        switch (mir_inst.ops) {
+            else => unreachable,
+            .pseudo_dbg_prologue_end_none,
+            .pseudo_dbg_line_line_column,
+            .pseudo_dbg_epilogue_begin_none,
+            .pseudo_dbg_enter_block_none,
+            .pseudo_dbg_leave_block_none,
+            .pseudo_dbg_var_args_none,
+            .pseudo_dead_none,
+            => {},
+            .pseudo_dbg_enter_inline_func, .pseudo_dbg_leave_inline_func => try writer.print(" {}", .{
+                ip.getNav(ip.indexToKey(mir_inst.data.func).func.owner_nav).name.fmt(ip),
+            }),
+            .pseudo_dbg_local_a => try writer.print(" {}", .{mir_inst.data.a.air_inst}),
+            .pseudo_dbg_local_ai_s => try writer.print(" {}, {d}", .{
+                mir_inst.data.ai.air_inst,
+                @as(i32, @bitCast(mir_inst.data.ai.i)),
+            }),
+            .pseudo_dbg_local_ai_u => try writer.print(" {}, {d}", .{
+                mir_inst.data.ai.air_inst,
+                mir_inst.data.ai.i,
+            }),
+            .pseudo_dbg_local_ai_64 => try writer.print(" {}, {d}", .{
+                mir_inst.data.ai.air_inst,
+                lower.mir.extraData(Mir.Imm64, mir_inst.data.ai.i).data.decode(),
+            }),
+            .pseudo_dbg_local_as => {
+                const mem_op: Instruction.Operand = .{ .mem = .initSib(.qword, .{
+                    .base = .{ .reloc = mir_inst.data.as.sym_index },
+                }) };
+                try writer.print(" {}, {}", .{ mir_inst.data.as.air_inst, mem_op.fmt(.m) });
+            },
+            .pseudo_dbg_local_aso => {
+                const sym_off = lower.mir.extraData(bits.SymbolOffset, mir_inst.data.ax.payload).data;
+                const mem_op: Instruction.Operand = .{ .mem = .initSib(.qword, .{
+                    .base = .{ .reloc = sym_off.sym_index },
+                    .disp = sym_off.off,
+                }) };
+                try writer.print(" {}, {}", .{ mir_inst.data.ax.air_inst, mem_op.fmt(.m) });
+            },
+            .pseudo_dbg_local_aro => {
+                const air_off = lower.mir.extraData(Mir.AirOffset, mir_inst.data.rx.payload).data;
+                const mem_op: Instruction.Operand = .{ .mem = .initSib(.qword, .{
+                    .base = .{ .reg = mir_inst.data.rx.r1 },
+                    .disp = air_off.off,
+                }) };
+                try writer.print(" {}, {}", .{ air_off.air_inst, mem_op.fmt(.m) });
+            },
+            .pseudo_dbg_local_af => {
+                const frame_addr = lower.mir.extraData(bits.FrameAddr, mir_inst.data.ax.payload).data;
+                const mem_op: Instruction.Operand = .{ .mem = .initSib(.qword, .{
+                    .base = .{ .frame = frame_addr.index },
+                    .disp = frame_addr.off,
+                }) };
+                try writer.print(" {}, {d}", .{ mir_inst.data.ax.air_inst, mem_op.fmt(.m) });
+            },
+            .pseudo_dbg_local_am => {
+                const mem_op: Instruction.Operand = .{
+                    .mem = lower.mir.extraData(Mir.Memory, mir_inst.data.ax.payload).data.decode(),
+                };
+                try writer.print(" {}, {}", .{ mir_inst.data.ax.air_inst, mem_op.fmt(.m) });
+            },
+        }
+    }
 }
 fn fmtWipMir(self: *Self, inst: Mir.Inst.Index) std.fmt.Formatter(formatWipMir) {
     return .{ .data = .{ .self = self, .inst = inst } };
@@ -2180,6 +2249,12 @@ fn checkInvariantsAfterAirInst(self: *Self, inst: Air.Inst.Index, old_air_bookke
     }
 }
 
+fn genBodyBlock(self: *Self, body: []const Air.Inst.Index) InnerError!void {
+    try self.asmPseudo(.pseudo_dbg_enter_block_none);
+    try self.genBody(body);
+    try self.asmPseudo(.pseudo_dbg_leave_block_none);
+}
+
 fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
     const pt = self.pt;
     const zcu = pt.zcu;
@@ -2294,7 +2369,6 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
             .breakpoint      => try self.airBreakpoint(),
             .ret_addr        => try self.airRetAddr(inst),
             .frame_addr      => try self.airFrameAddress(inst),
-            .fence           => try self.airFence(inst),
             .cond_br         => try self.airCondBr(inst),
             .fptrunc         => try self.airFptrunc(inst),
             .fpext           => try self.airFpext(inst),
@@ -12251,16 +12325,6 @@ fn airFrameAddress(self: *Self, inst: Air.Inst.Index) !void {
     return self.finishAir(inst, dst_mcv, .{ .none, .none, .none });
 }
 
-fn airFence(self: *Self, inst: Air.Inst.Index) !void {
-    const order = self.air.instructions.items(.data)[@intFromEnum(inst)].fence;
-    switch (order) {
-        .unordered, .monotonic => unreachable,
-        .acquire, .release, .acq_rel => {},
-        .seq_cst => try self.asmOpOnly(.{ ._, .mfence }),
-    }
-    self.finishAirBookkeeping();
-}
-
 fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier) !void {
     if (modifier == .always_tail) return self.fail("TODO implement tail calls for x86_64", .{});
 
@@ -13195,7 +13259,7 @@ fn genTry(
     const state = try self.saveState();
 
     for (liveness_cond_br.else_deaths) |death| try self.processDeath(death);
-    try self.genBody(body);
+    try self.genBodyBlock(body);
     try self.restoreState(state, &.{}, .{
         .emit_instructions = false,
         .update_tracking = true,
@@ -13304,7 +13368,7 @@ fn airCondBr(self: *Self, inst: Air.Inst.Index) !void {
     const reloc = try self.genCondBrMir(cond_ty, cond);
 
     for (liveness_cond_br.then_deaths) |death| try self.processDeath(death);
-    try self.genBody(then_body);
+    try self.genBodyBlock(then_body);
     try self.restoreState(state, &.{}, .{
         .emit_instructions = false,
         .update_tracking = true,
@@ -13315,7 +13379,7 @@ fn airCondBr(self: *Self, inst: Air.Inst.Index) !void {
     self.performReloc(reloc);
 
     for (liveness_cond_br.else_deaths) |death| try self.processDeath(death);
-    try self.genBody(else_body);
+    try self.genBodyBlock(else_body);
     try self.restoreState(state, &.{}, .{
         .emit_instructions = false,
         .update_tracking = true,
@@ -13676,14 +13740,16 @@ fn airLoop(self: *Self, inst: Air.Inst.Index) !void {
     });
     defer assert(self.loops.remove(inst));
 
-    try self.genBody(body);
+    try self.genBodyBlock(body);
     self.finishAirBookkeeping();
 }
 
 fn airBlock(self: *Self, inst: Air.Inst.Index) !void {
     const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const extra = self.air.extraData(Air.Block, ty_pl.payload);
+    try self.asmPseudo(.pseudo_dbg_enter_block_none);
     try self.lowerBlock(inst, @ptrCast(self.air.extra[extra.end..][0..extra.data.body_len]));
+    try self.asmPseudo(.pseudo_dbg_leave_block_none);
 }
 
 fn lowerBlock(self: *Self, inst: Air.Inst.Index, body: []const Air.Inst.Index) !void {
@@ -13695,7 +13761,6 @@ fn lowerBlock(self: *Self, inst: Air.Inst.Index, body: []const Air.Inst.Index) !
     try self.blocks.putNoClobber(self.gpa, inst, .{ .state = self.initRetroactiveState() });
     const liveness = self.liveness.getBlock(inst);
 
-    // TODO emit debug info lexical block
     try self.genBody(body);
 
     var block_data = self.blocks.fetchRemove(inst).?;
@@ -13807,7 +13872,7 @@ fn lowerSwitchBr(self: *Self, inst: Air.Inst.Index, switch_br: Air.UnwrappedSwit
 
         // Relocate all success cases to the body we're about to generate.
         for (relocs) |reloc| self.performReloc(reloc);
-        try self.genBody(case.body);
+        try self.genBodyBlock(case.body);
         try self.restoreState(state, &.{}, .{
             .emit_instructions = false,
             .update_tracking = true,
@@ -13825,7 +13890,7 @@ fn lowerSwitchBr(self: *Self, inst: Air.Inst.Index, switch_br: Air.UnwrappedSwit
         const else_deaths = liveness.deaths.len - 1;
         for (liveness.deaths[else_deaths]) |operand| try self.processDeath(operand);
 
-        try self.genBody(else_body);
+        try self.genBodyBlock(else_body);
         try self.restoreState(state, &.{}, .{
             .emit_instructions = false,
             .update_tracking = true,
diff --git a/zig/src/arch/x86_64/Emit.zig b/zig/src/arch/x86_64/Emit.zig
index c33fbb53a5..354960d6ee 100644
--- a/zig/src/arch/x86_64/Emit.zig
+++ b/zig/src/arch/x86_64/Emit.zig
@@ -287,6 +287,30 @@ pub fn emitMir(emit: *Emit) Error!void {
                             .none => {},
                         }
                     },
+                    .pseudo_dbg_enter_block_none => {
+                        switch (emit.debug_output) {
+                            .dwarf => |dw| {
+                                log.debug("mirDbgEnterBlock (line={d}, col={d})", .{
+                                    emit.prev_di_line, emit.prev_di_column,
+                                });
+                                try dw.enterBlock(emit.code.items.len);
+                            },
+                            .plan9 => {},
+                            .none => {},
+                        }
+                    },
+                    .pseudo_dbg_leave_block_none => {
+                        switch (emit.debug_output) {
+                            .dwarf => |dw| {
+                                log.debug("mirDbgLeaveBlock (line={d}, col={d})", .{
+                                    emit.prev_di_line, emit.prev_di_column,
+                                });
+                                try dw.leaveBlock(emit.code.items.len);
+                            },
+                            .plan9 => {},
+                            .none => {},
+                        }
+                    },
                     .pseudo_dbg_enter_inline_func => {
                         switch (emit.debug_output) {
                             .dwarf => |dw| {
diff --git a/zig/src/arch/x86_64/Lower.zig b/zig/src/arch/x86_64/Lower.zig
index 174e9b069c..058201c2d7 100644
--- a/zig/src/arch/x86_64/Lower.zig
+++ b/zig/src/arch/x86_64/Lower.zig
@@ -312,6 +312,8 @@ pub fn lowerMir(lower: *Lower, index: Mir.Inst.Index) Error!struct {
             .pseudo_dbg_prologue_end_none,
             .pseudo_dbg_line_line_column,
             .pseudo_dbg_epilogue_begin_none,
+            .pseudo_dbg_enter_block_none,
+            .pseudo_dbg_leave_block_none,
             .pseudo_dbg_enter_inline_func,
             .pseudo_dbg_leave_inline_func,
             .pseudo_dbg_local_a,
diff --git a/zig/src/arch/x86_64/Mir.zig b/zig/src/arch/x86_64/Mir.zig
index ff7c78e86e..0e9d010758 100644
--- a/zig/src/arch/x86_64/Mir.zig
+++ b/zig/src/arch/x86_64/Mir.zig
@@ -935,6 +935,10 @@ pub const Inst = struct {
         pseudo_dbg_line_line_column,
         /// Start of epilogue
         pseudo_dbg_epilogue_begin_none,
+        /// Start of lexical block
+        pseudo_dbg_enter_block_none,
+        /// End of lexical block
+        pseudo_dbg_leave_block_none,
         /// Start of inline function
         pseudo_dbg_enter_inline_func,
         /// End of inline function
diff --git a/zig/src/arch/x86_64/encoder.zig b/zig/src/arch/x86_64/encoder.zig
index e3c93ce114..674c81fa62 100644
--- a/zig/src/arch/x86_64/encoder.zig
+++ b/zig/src/arch/x86_64/encoder.zig
@@ -233,7 +233,7 @@ pub const Instruction = struct {
             _ = unused_format_string;
             _ = options;
             _ = writer;
-            @compileError("do not format Operand directly; use fmtPrint() instead");
+            @compileError("do not format Operand directly; use fmt() instead");
         }
 
         const FormatContext = struct {
@@ -241,7 +241,7 @@ pub const Instruction = struct {
             enc_op: Encoding.Op,
         };
 
-        fn fmt(
+        fn fmtContext(
             ctx: FormatContext,
             comptime unused_format_string: []const u8,
             options: std.fmt.FormatOptions,
@@ -309,7 +309,7 @@ pub const Instruction = struct {
             }
         }
 
-        pub fn fmtPrint(op: Operand, enc_op: Encoding.Op) std.fmt.Formatter(fmt) {
+        pub fn fmt(op: Operand, enc_op: Encoding.Op) std.fmt.Formatter(fmtContext) {
             return .{ .data = .{ .op = op, .enc_op = enc_op } };
         }
     };
@@ -373,7 +373,7 @@ pub const Instruction = struct {
             if (op == .none) break;
             if (i > 0) try writer.writeByte(',');
             try writer.writeByte(' ');
-            try writer.print("{}", .{op.fmtPrint(enc)});
+            try writer.print("{}", .{op.fmt(enc)});
         }
     }
 
diff --git a/zig/src/clang.zig b/zig/src/clang.zig
index cb58a92bd0..904eca3c3f 100644
--- a/zig/src/clang.zig
+++ b/zig/src/clang.zig
@@ -64,7 +64,7 @@ pub const APValueKind = enum(c_int) {
 
 pub const APValue = extern struct {
     Kind: APValueKind,
-    Data: if (builtin.os.tag == .windows and builtin.abi == .msvc) [52]u8 else [68]u8,
+    Data: if (builtin.os.tag == .windows and (builtin.abi == .msvc or builtin.abi == .itanium)) [52]u8 else [68]u8,
 
     pub const getKind = ZigClangAPValue_getKind;
     extern fn ZigClangAPValue_getKind(*const APValue) APValueKind;
diff --git a/zig/src/codegen/c.zig b/zig/src/codegen/c.zig
index 466bdcde6a..98c3c42deb 100644
--- a/zig/src/codegen/c.zig
+++ b/zig/src/codegen/c.zig
@@ -3144,7 +3144,6 @@ fn genBodyInner(f: *Function, body: []const Air.Inst.Index) error{ AnalysisFail,
             .breakpoint => try airBreakpoint(f.object.writer()),
             .ret_addr   => try airRetAddr(f, inst),
             .frame_addr => try airFrameAddress(f, inst),
-            .fence      => try airFence(f, inst),
 
             .ptr_add => try airPtrAddSub(f, inst, '+'),
             .ptr_sub => try airPtrAddSub(f, inst, '-'),
@@ -4988,17 +4987,6 @@ fn airFrameAddress(f: *Function, inst: Air.Inst.Index) !CValue {
     return local;
 }
 
-fn airFence(f: *Function, inst: Air.Inst.Index) !CValue {
-    const atomic_order = f.air.instructions.items(.data)[@intFromEnum(inst)].fence;
-    const writer = f.object.writer();
-
-    try writer.writeAll("zig_fence(");
-    try writeMemoryOrder(writer, atomic_order);
-    try writer.writeAll(");\n");
-
-    return .none;
-}
-
 fn airUnreach(f: *Function) !void {
     // Not even allowed to call unreachable in a naked function.
     if (f.object.dg.is_naked_fn) return;
diff --git a/zig/src/codegen/llvm.zig b/zig/src/codegen/llvm.zig
index c9cb79b4a0..623aa995d4 100644
--- a/zig/src/codegen/llvm.zig
+++ b/zig/src/codegen/llvm.zig
@@ -37,10 +37,20 @@ const compilerRtIntAbbrev = target_util.compilerRtIntAbbrev;
 
 const Error = error{ OutOfMemory, CodegenFail };
 
+fn subArchName(features: std.Target.Cpu.Feature.Set, arch: anytype, mappings: anytype) ?[]const u8 {
+    inline for (mappings) |mapping| {
+        if (arch.featureSetHas(features, mapping[0])) return mapping[1];
+    }
+
+    return null;
+}
+
 pub fn targetTriple(allocator: Allocator, target: std.Target) ![]const u8 {
     var llvm_triple = std.ArrayList(u8).init(allocator);
     defer llvm_triple.deinit();
 
+    const features = target.cpu.features;
+
     const llvm_arch = switch (target.cpu.arch) {
         .arm => "arm",
         .armeb => "armeb",
@@ -51,15 +61,15 @@ pub fn targetTriple(allocator: Allocator, target: std.Target) ![]const u8 {
         .bpfel => "bpfel",
         .bpfeb => "bpfeb",
         .csky => "csky",
-        .dxil => "dxil",
         .hexagon => "hexagon",
         .loongarch32 => "loongarch32",
         .loongarch64 => "loongarch64",
         .m68k => "m68k",
-        .mips => "mips",
-        .mipsel => "mipsel",
-        .mips64 => "mips64",
-        .mips64el => "mips64el",
+        // MIPS sub-architectures are a bit irregular, so we handle them manually here.
+        .mips => if (std.Target.mips.featureSetHas(features, .mips32r6)) "mipsisa32r6" else "mips",
+        .mipsel => if (std.Target.mips.featureSetHas(features, .mips32r6)) "mipsisa32r6el" else "mipsel",
+        .mips64 => if (std.Target.mips.featureSetHas(features, .mips64r6)) "mipsisa64r6" else "mips64",
+        .mips64el => if (std.Target.mips.featureSetHas(features, .mips64r6)) "mipsisa64r6el" else "mips64el",
         .msp430 => "msp430",
         .powerpc => "powerpc",
         .powerpcle => "powerpcle",
@@ -89,10 +99,72 @@ pub fn targetTriple(allocator: Allocator, target: std.Target) ![]const u8 {
 
         .kalimba,
         .spu_2,
+        .propeller1,
+        .propeller2,
         => unreachable, // Gated by hasLlvmSupport().
+
     };
+
     try llvm_triple.appendSlice(llvm_arch);
 
+    const llvm_sub_arch: ?[]const u8 = switch (target.cpu.arch) {
+        .arm, .armeb, .thumb, .thumbeb => subArchName(features, std.Target.arm, .{
+            .{ .v4t, "v4t" },
+            .{ .v5t, "v5t" },
+            .{ .v5te, "v5te" },
+            .{ .v5tej, "v5tej" },
+            .{ .v6, "v6" },
+            .{ .v6k, "v6k" },
+            .{ .v6kz, "v6kz" },
+            .{ .v6m, "v6m" },
+            .{ .v6t2, "v6t2" },
+            // v7k and v7s imply v7a so they have to be tested first.
+            .{ .v7k, "v7k" },
+            .{ .v7s, "v7s" },
+            .{ .v7a, "v7a" },
+            .{ .v7em, "v7em" },
+            .{ .v7m, "v7m" },
+            .{ .v7r, "v7r" },
+            .{ .v7ve, "v7ve" },
+            .{ .v8a, "v8a" },
+            .{ .v8_1a, "v8.1a" },
+            .{ .v8_2a, "v8.2a" },
+            .{ .v8_3a, "v8.3a" },
+            .{ .v8_4a, "v8.4a" },
+            .{ .v8_5a, "v8.5a" },
+            .{ .v8_6a, "v8.6a" },
+            .{ .v8_7a, "v8.7a" },
+            .{ .v8_8a, "v8.8a" },
+            .{ .v8_9a, "v8.9a" },
+            .{ .v8m, "v8m.base" },
+            .{ .v8m_main, "v8m.main" },
+            .{ .v8_1m_main, "v8.1m.main" },
+            .{ .v8r, "v8r" },
+            .{ .v9a, "v9a" },
+            .{ .v9_1a, "v9.1a" },
+            .{ .v9_2a, "v9.2a" },
+            .{ .v9_3a, "v9.3a" },
+            .{ .v9_4a, "v9.4a" },
+            .{ .v9_5a, "v9.5a" },
+        }),
+        .powerpc => subArchName(features, std.Target.powerpc, .{
+            .{ .spe, "spe" },
+        }),
+        .spirv => subArchName(features, std.Target.spirv, .{
+            .{ .v1_5, "1.5" },
+        }),
+        .spirv32, .spirv64 => subArchName(features, std.Target.spirv, .{
+            .{ .v1_5, "1.5" },
+            .{ .v1_4, "1.4" },
+            .{ .v1_3, "1.3" },
+            .{ .v1_2, "1.2" },
+            .{ .v1_1, "1.1" },
+        }),
+        else => null,
+    };
+
+    if (llvm_sub_arch) |sub| try llvm_triple.appendSlice(sub);
+
     // Unlike CPU backends, GPU backends actually care about the vendor tag.
     try llvm_triple.appendSlice(switch (target.cpu.arch) {
         .amdgcn => if (target.os.tag == .mesa3d) "-mesa-" else "-amd-",
@@ -135,7 +207,6 @@ pub fn targetTriple(allocator: Allocator, target: std.Target) ![]const u8 {
         .tvos => "tvos",
         .watchos => "watchos",
         .driverkit => "driverkit",
-        .shadermodel => "shadermodel",
         .visionos => "xros",
         .serenity => "serenity",
         .vulkan => "vulkan",
@@ -173,6 +244,7 @@ pub fn targetTriple(allocator: Allocator, target: std.Target) ![]const u8 {
         .eabi => "eabi",
         .eabihf => "eabihf",
         .android => "android",
+        .androideabi => "androideabi",
         .musl => "musl",
         .musleabi => "musleabi",
         .musleabihf => "musleabihf",
@@ -182,22 +254,8 @@ pub fn targetTriple(allocator: Allocator, target: std.Target) ![]const u8 {
         .cygnus => "cygnus",
         .simulator => "simulator",
         .macabi => "macabi",
-        .pixel => "pixel",
-        .vertex => "vertex",
-        .geometry => "geometry",
-        .hull => "hull",
-        .domain => "domain",
-        .compute => "compute",
-        .library => "library",
-        .raygeneration => "raygeneration",
-        .intersection => "intersection",
-        .anyhit => "anyhit",
-        .closesthit => "closesthit",
-        .miss => "miss",
-        .callable => "callable",
-        .mesh => "mesh",
-        .amplification => "amplification",
         .ohos => "ohos",
+        .ohoseabi => "ohoseabi",
     };
     try llvm_triple.appendSlice(llvm_abi);
 
@@ -239,7 +297,6 @@ pub fn targetOs(os_tag: std.Target.Os.Tag) llvm.OSType {
         .wasi => .WASI,
         .emscripten => .Emscripten,
         .driverkit => .DriverKit,
-        .shadermodel => .ShaderModel,
         .vulkan => .Vulkan,
         .serenity => .Serenity,
         .bridgeos => .BridgeOS,
@@ -263,7 +320,6 @@ pub fn targetArch(arch_tag: std.Target.Cpu.Arch) llvm.ArchType {
         .bpfel => .bpfel,
         .bpfeb => .bpfeb,
         .csky => .csky,
-        .dxil => .dxil,
         .hexagon => .hexagon,
         .loongarch32 => .loongarch32,
         .loongarch64 => .loongarch64,
@@ -299,7 +355,7 @@ pub fn targetArch(arch_tag: std.Target.Cpu.Arch) llvm.ArchType {
         .wasm32 => .wasm32,
         .wasm64 => .wasm64,
         .ve => .ve,
-        .spu_2 => .UnknownArch,
+        .propeller1, .propeller2, .spu_2 => .UnknownArch,
     };
 }
 
@@ -3865,13 +3921,13 @@ pub const Object = struct {
 
             .undef => unreachable, // handled above
             .simple_value => |simple_value| switch (simple_value) {
-                .undefined,
-                .void,
-                .null,
-                .empty_struct,
-                .@"unreachable",
-                .generic_poison,
-                => unreachable, // non-runtime values
+                .undefined => unreachable, // non-runtime value
+                .void => unreachable, // non-runtime value
+                .null => unreachable, // non-runtime value
+                .empty_struct => unreachable, // non-runtime value
+                .@"unreachable" => unreachable, // non-runtime value
+                .generic_poison => unreachable, // non-runtime value
+
                 .false => .false,
                 .true => .true,
             },
@@ -5154,7 +5210,6 @@ pub const FuncGen = struct {
                 .float_from_int => try self.airFloatFromInt(inst),
                 .cmpxchg_weak   => try self.airCmpxchg(inst, .weak),
                 .cmpxchg_strong => try self.airCmpxchg(inst, .strong),
-                .fence          => try self.airFence(inst),
                 .atomic_rmw     => try self.airAtomicRmw(inst),
                 .atomic_load    => try self.airAtomicLoad(inst),
                 .memset         => try self.airMemset(inst, false),
@@ -9681,13 +9736,6 @@ pub const FuncGen = struct {
         return self.wip.cast(.ptrtoint, result, try o.lowerType(Type.usize), "");
     }
 
-    fn airFence(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
-        const atomic_order = self.air.instructions.items(.data)[@intFromEnum(inst)].fence;
-        const ordering = toLlvmAtomicOrdering(atomic_order);
-        _ = try self.wip.fence(self.sync_scope, ordering);
-        return .none;
-    }
-
     fn airCmpxchg(
         self: *FuncGen,
         inst: Air.Inst.Index,
@@ -12257,6 +12305,7 @@ fn ccAbiPromoteInt(
             .sparc64,
             .powerpc64,
             .powerpc64le,
+            .s390x,
             => switch (int_info.bits) {
                 0...63 => int_info.signedness,
                 else => null,
@@ -12396,6 +12445,7 @@ fn backendSupportsF80(target: std.Target) bool {
 /// if it produces miscompilations.
 fn backendSupportsF16(target: std.Target) bool {
     return switch (target.cpu.arch) {
+        .hexagon,
         .powerpc,
         .powerpcle,
         .powerpc64,
@@ -12726,12 +12776,13 @@ pub fn initializeLLVMTarget(arch: std.Target.Cpu.Arch) void {
         .spirv,
         .spirv32,
         .spirv64,
-        .dxil,
         => {},
 
         // LLVM does does not have a backend for these.
         .kalimba,
         .spu_2,
+        .propeller1,
+        .propeller2,
         => unreachable,
     }
 }
diff --git a/zig/src/codegen/spirv.zig b/zig/src/codegen/spirv.zig
index dc45b26931..164367207a 100644
--- a/zig/src/codegen/spirv.zig
+++ b/zig/src/codegen/spirv.zig
@@ -1856,6 +1856,9 @@ const NavGen = struct {
             .flash3,
             .flash4,
             .flash5,
+            .cog,
+            .lut,
+            .hub,
             => unreachable,
         };
     }
diff --git a/zig/src/crash_report.zig b/zig/src/crash_report.zig
index c0a90d8705..d9f8bac350 100644
--- a/zig/src/crash_report.zig
+++ b/zig/src/crash_report.zig
@@ -13,11 +13,23 @@ const Sema = @import("Sema.zig");
 const InternPool = @import("InternPool.zig");
 const Zir = std.zig.Zir;
 const Decl = Zcu.Decl;
+const dev = @import("dev.zig");
 
 /// To use these crash report diagnostics, publish this panic in your main file
 /// and add `pub const enable_segfault_handler = false;` to your `std_options`.
 /// You will also need to call initialize() on startup, preferably as the very first operation in your program.
-pub const panic = if (build_options.enable_debug_extensions) compilerPanic else std.builtin.default_panic;
+pub const Panic = if (build_options.enable_debug_extensions) struct {
+    pub const call = compilerPanic;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+} else if (dev.env == .bootstrap)
+    std.debug.SimplePanic
+else
+    std.debug.FormattedPanic;
 
 /// Install signal handlers to identify crashes and report diagnostics.
 pub fn initialize() void {
@@ -317,9 +329,6 @@ const PanicSwitch = struct {
     /// until all panicking threads have dumped their traces.
     var panicking = std.atomic.Value(u8).init(0);
 
-    // Locked to avoid interleaving panic messages from multiple threads.
-    var panic_mutex = std.Thread.Mutex{};
-
     /// Tracks the state of the current panic.  If the code within the
     /// panic triggers a secondary panic, this allows us to recover.
     threadlocal var panic_state_raw: PanicState = .{};
@@ -387,7 +396,7 @@ const PanicSwitch = struct {
 
         state.recover_stage = .release_ref_count;
 
-        panic_mutex.lock();
+        std.debug.lockStdErr();
 
         state.recover_stage = .release_mutex;
 
@@ -447,7 +456,7 @@ const PanicSwitch = struct {
     noinline fn releaseMutex(state: *volatile PanicState) noreturn {
         state.recover_stage = .abort;
 
-        panic_mutex.unlock();
+        std.debug.unlockStdErr();
 
         goTo(releaseRefCount, .{state});
     }
diff --git a/zig/src/glibc.zig b/zig/src/glibc.zig
index 7042f9c102..f01e867843 100644
--- a/zig/src/glibc.zig
+++ b/zig/src/glibc.zig
@@ -169,14 +169,14 @@ fn useElfInitFini(target: std.Target) bool {
     };
 }
 
-pub const CRTFile = enum {
+pub const CrtFile = enum {
     crti_o,
     crtn_o,
     scrt1_o,
     libc_nonshared_a,
 };
 
-pub fn buildCRTFile(comp: *Compilation, crt_file: CRTFile, prog_node: std.Progress.Node) !void {
+pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progress.Node) !void {
     if (!build_options.have_llvm) {
         return error.ZigCompilerNotBuiltWithLLVMExtensions;
     }
@@ -292,7 +292,8 @@ pub fn buildCRTFile(comp: *Compilation, crt_file: CRTFile, prog_node: std.Progre
                 .owner = undefined,
             };
             var files = [_]Compilation.CSourceFile{ start_o, abi_note_o, init_o };
-            return comp.build_crt_file("Scrt1", .Obj, .@"glibc Scrt1.o", prog_node, &files);
+            const basename = if (comp.config.output_mode == .Exe and !comp.config.pie) "crt1" else "Scrt1";
+            return comp.build_crt_file(basename, .Obj, .@"glibc Scrt1.o", prog_node, &files);
         },
         .libc_nonshared_a => {
             const s = path.sep_str;
@@ -845,12 +846,8 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) !voi
         stubs_asm.shrinkRetainingCapacity(0);
         try stubs_asm.appendSlice(".text\n");
 
-        var inc_i: usize = 0;
-
-        const fn_inclusions_len = mem.readInt(u16, metadata.inclusions[inc_i..][0..2], .little);
-        inc_i += 2;
-
         var sym_i: usize = 0;
+        var sym_name_buf = std.ArrayList(u8).init(arena);
         var opt_symbol_name: ?[]const u8 = null;
         var versions_buffer: [32]u8 = undefined;
         var versions_len: usize = undefined;
@@ -871,32 +868,38 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) !voi
         // twice, which causes a "duplicate symbol" assembler error.
         var versions_written = std.AutoArrayHashMap(Version, void).init(arena);
 
+        var inc_fbs = std.io.fixedBufferStream(metadata.inclusions);
+        var inc_reader = inc_fbs.reader();
+
+        const fn_inclusions_len = try inc_reader.readInt(u16, .little);
+
         while (sym_i < fn_inclusions_len) : (sym_i += 1) {
             const sym_name = opt_symbol_name orelse n: {
-                const name = mem.sliceTo(metadata.inclusions[inc_i..], 0);
-                inc_i += name.len + 1;
+                sym_name_buf.clearRetainingCapacity();
+                try inc_reader.streamUntilDelimiter(sym_name_buf.writer(), 0, null);
 
-                opt_symbol_name = name;
+                opt_symbol_name = sym_name_buf.items;
                 versions_buffer = undefined;
                 versions_len = 0;
-                break :n name;
+
+                break :n sym_name_buf.items;
             };
-            const targets = mem.readInt(u32, metadata.inclusions[inc_i..][0..4], .little);
-            inc_i += 4;
+            const targets = try std.leb.readUleb128(u64, inc_reader);
+            var lib_index = try inc_reader.readByte();
 
-            const lib_index = metadata.inclusions[inc_i];
-            inc_i += 1;
-            const is_terminal = (targets & (1 << 31)) != 0;
-            if (is_terminal) opt_symbol_name = null;
+            const is_terminal = (lib_index & (1 << 7)) != 0;
+            if (is_terminal) {
+                lib_index &= ~@as(u8, 1 << 7);
+                opt_symbol_name = null;
+            }
 
             // Test whether the inclusion applies to our current library and target.
             const ok_lib_and_target =
                 (lib_index == lib_i) and
-                ((targets & (@as(u32, 1) << @as(u5, @intCast(target_targ_index)))) != 0);
+                ((targets & (@as(u64, 1) << @as(u6, @intCast(target_targ_index)))) != 0);
 
             while (true) {
-                const byte = metadata.inclusions[inc_i];
-                inc_i += 1;
+                const byte = try inc_reader.readByte();
                 const last = (byte & 0b1000_0000) != 0;
                 const ver_i = @as(u7, @truncate(byte));
                 if (ok_lib_and_target and ver_i <= target_ver_index) {
@@ -1027,8 +1030,7 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) !voi
             , .{wordDirective(target)});
         }
 
-        const obj_inclusions_len = mem.readInt(u16, metadata.inclusions[inc_i..][0..2], .little);
-        inc_i += 2;
+        const obj_inclusions_len = try inc_reader.readInt(u16, .little);
 
         sym_i = 0;
         opt_symbol_name = null;
@@ -1036,33 +1038,32 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) !voi
         versions_len = undefined;
         while (sym_i < obj_inclusions_len) : (sym_i += 1) {
             const sym_name = opt_symbol_name orelse n: {
-                const name = mem.sliceTo(metadata.inclusions[inc_i..], 0);
-                inc_i += name.len + 1;
+                sym_name_buf.clearRetainingCapacity();
+                try inc_reader.streamUntilDelimiter(sym_name_buf.writer(), 0, null);
 
-                opt_symbol_name = name;
+                opt_symbol_name = sym_name_buf.items;
                 versions_buffer = undefined;
                 versions_len = 0;
-                break :n name;
-            };
-            const targets = mem.readInt(u32, metadata.inclusions[inc_i..][0..4], .little);
-            inc_i += 4;
-
-            const size = mem.readInt(u16, metadata.inclusions[inc_i..][0..2], .little);
-            inc_i += 2;
 
-            const lib_index = metadata.inclusions[inc_i];
-            inc_i += 1;
-            const is_terminal = (targets & (1 << 31)) != 0;
-            if (is_terminal) opt_symbol_name = null;
+                break :n sym_name_buf.items;
+            };
+            const targets = try std.leb.readUleb128(u64, inc_reader);
+            const size = try std.leb.readUleb128(u16, inc_reader);
+            var lib_index = try inc_reader.readByte();
+
+            const is_terminal = (lib_index & (1 << 7)) != 0;
+            if (is_terminal) {
+                lib_index &= ~@as(u8, 1 << 7);
+                opt_symbol_name = null;
+            }
 
             // Test whether the inclusion applies to our current library and target.
             const ok_lib_and_target =
                 (lib_index == lib_i) and
-                ((targets & (@as(u32, 1) << @as(u5, @intCast(target_targ_index)))) != 0);
+                ((targets & (@as(u64, 1) << @as(u6, @intCast(target_targ_index)))) != 0);
 
             while (true) {
-                const byte = metadata.inclusions[inc_i];
-                inc_i += 1;
+                const byte = try inc_reader.readByte();
                 const last = (byte & 0b1000_0000) != 0;
                 const ver_i = @as(u7, @truncate(byte));
                 if (ok_lib_and_target and ver_i <= target_ver_index) {
diff --git a/zig/src/libcxx.zig b/zig/src/libcxx.zig
index 1baa6df1b1..11deff91c9 100644
--- a/zig/src/libcxx.zig
+++ b/zig/src/libcxx.zig
@@ -221,7 +221,7 @@ pub fn buildLibCXX(comp: *Compilation, prog_node: std.Progress.Node) BuildError!
     for (libcxx_files) |cxx_src| {
         var cflags = std.ArrayList([]const u8).init(arena);
 
-        if ((target.os.tag == .windows and target.abi == .msvc) or target.os.tag == .wasi) {
+        if ((target.os.tag == .windows and (target.abi == .msvc or target.abi == .itanium)) or target.os.tag == .wasi) {
             // Filesystem stuff isn't supported on WASI and Windows (MSVC).
             if (std.mem.startsWith(u8, cxx_src, "src/filesystem/"))
                 continue;
diff --git a/zig/src/libtsan.zig b/zig/src/libtsan.zig
index 42b605bf3c..63131def00 100644
--- a/zig/src/libtsan.zig
+++ b/zig/src/libtsan.zig
@@ -160,10 +160,13 @@ pub fn buildTsan(comp: *Compilation, prog_node: std.Progress.Node) BuildError!vo
     }
     {
         const asm_source = switch (target.cpu.arch) {
-            .aarch64 => "tsan_rtl_aarch64.S",
+            .aarch64, .aarch64_be => "tsan_rtl_aarch64.S",
+            .loongarch64 => "tsan_rtl_loongarch64.S",
+            .mips64, .mips64el => "tsan_rtl_mips64.S",
+            .powerpc64, .powerpc64le => "tsan_rtl_ppc64.S",
+            .riscv64 => "tsan_rtl_riscv64.S",
+            .s390x => "tsan_rtl_s390x.S",
             .x86_64 => "tsan_rtl_amd64.S",
-            .mips64 => "tsan_rtl_mips64.S",
-            .powerpc64 => "tsan_rtl_ppc64.S",
             else => return error.TSANUnsupportedCPUArchitecture,
         };
         var cflags = std.ArrayList([]const u8).init(arena);
@@ -416,7 +419,6 @@ const sanitizer_common_sources = [_][]const u8{
     "sanitizer_platform_limits_freebsd.cpp",
     "sanitizer_platform_limits_linux.cpp",
     "sanitizer_platform_limits_netbsd.cpp",
-    "sanitizer_platform_limits_openbsd.cpp",
     "sanitizer_platform_limits_posix.cpp",
     "sanitizer_platform_limits_solaris.cpp",
     "sanitizer_posix.cpp",
@@ -429,7 +431,6 @@ const sanitizer_common_sources = [_][]const u8{
     "sanitizer_procmaps_solaris.cpp",
     "sanitizer_range.cpp",
     "sanitizer_solaris.cpp",
-    "sanitizer_stack_store.cpp",
     "sanitizer_stoptheworld_fuchsia.cpp",
     "sanitizer_stoptheworld_mac.cpp",
     "sanitizer_stoptheworld_win.cpp",
@@ -452,6 +453,7 @@ const sanitizer_nolibc_sources = [_][]const u8{
 const sanitizer_libcdep_sources = [_][]const u8{
     "sanitizer_common_libcdep.cpp",
     "sanitizer_allocator_checks.cpp",
+    "sanitizer_dl.cpp",
     "sanitizer_linux_libcdep.cpp",
     "sanitizer_mac_libcdep.cpp",
     "sanitizer_posix_libcdep.cpp",
@@ -461,6 +463,7 @@ const sanitizer_libcdep_sources = [_][]const u8{
 
 const sanitizer_symbolizer_sources = [_][]const u8{
     "sanitizer_allocator_report.cpp",
+    "sanitizer_stack_store.cpp",
     "sanitizer_stackdepot.cpp",
     "sanitizer_stacktrace.cpp",
     "sanitizer_stacktrace_libcdep.cpp",
@@ -471,10 +474,13 @@ const sanitizer_symbolizer_sources = [_][]const u8{
     "sanitizer_symbolizer_libcdep.cpp",
     "sanitizer_symbolizer_mac.cpp",
     "sanitizer_symbolizer_markup.cpp",
+    "sanitizer_symbolizer_markup_fuchsia.cpp",
     "sanitizer_symbolizer_posix_libcdep.cpp",
     "sanitizer_symbolizer_report.cpp",
+    "sanitizer_symbolizer_report_fuchsia.cpp",
     "sanitizer_symbolizer_win.cpp",
     "sanitizer_unwind_linux_libcdep.cpp",
+    "sanitizer_unwind_fuchsia.cpp",
     "sanitizer_unwind_win.cpp",
 };
 
diff --git a/zig/src/libunwind.zig b/zig/src/libunwind.zig
index 605206467c..5eb19e8d67 100644
--- a/zig/src/libunwind.zig
+++ b/zig/src/libunwind.zig
@@ -143,6 +143,10 @@ pub fn buildStaticLib(comp: *Compilation, prog_node: std.Progress.Node) BuildErr
         try cflags.append("-Wno-visibility");
         try cflags.append("-Wno-incompatible-pointer-types");
 
+        if (target.os.tag == .windows) {
+            try cflags.append("-Wno-dll-attribute-on-redeclaration");
+        }
+
         c_source_files[i] = .{
             .src_path = try comp.zig_lib_directory.join(arena, &[_][]const u8{unwind_src}),
             .extra_flags = cflags.items,
diff --git a/zig/src/link.zig b/zig/src/link.zig
index 2894302c11..64115ab3ee 100644
--- a/zig/src/link.zig
+++ b/zig/src/link.zig
@@ -11,7 +11,7 @@ const wasi_libc = @import("wasi_libc.zig");
 const Air = @import("Air.zig");
 const Allocator = std.mem.Allocator;
 const Cache = std.Build.Cache;
-const Path = Cache.Path;
+const Path = std.Build.Cache.Path;
 const Compilation = @import("Compilation.zig");
 const LibCInstallation = std.zig.LibCInstallation;
 const Liveness = @import("Liveness.zig");
@@ -34,7 +34,7 @@ pub const SystemLib = struct {
     /// 1. Windows DLLs that zig ships such as advapi32.
     /// 2. extern "foo" fn declarations where we find out about libraries too late
     /// TODO: make this non-optional and resolve those two cases somehow.
-    path: ?[]const u8,
+    path: ?Path,
 };
 
 pub fn hashAddSystemLibs(
@@ -46,7 +46,7 @@ pub fn hashAddSystemLibs(
     for (hm.values()) |value| {
         man.hash.add(value.needed);
         man.hash.add(value.weak);
-        if (value.path) |p| _ = try man.addFile(p, null);
+        if (value.path) |p| _ = try man.addFilePath(p, null);
     }
 }
 
@@ -67,7 +67,6 @@ pub const File = struct {
     gc_sections: bool,
     print_gc_sections: bool,
     build_id: std.zig.BuildId,
-    rpath_list: []const []const u8,
     allow_shlib_undefined: bool,
     stack_size: u64,
 
@@ -534,7 +533,10 @@ pub const File = struct {
         FailedToEmit,
         FileSystem,
         FilesOpenedWithWrongFlags,
+        /// Indicates an error will be present in `Compilation.link_errors`.
         FlushFailure,
+        /// Indicates an error will be present in `Compilation.link_errors`.
+        LinkFailure,
         FunctionSignatureMismatch,
         GlobalTypeMismatch,
         HotSwapUnavailableOnHostOperatingSystem,
@@ -549,7 +551,7 @@ pub const File = struct {
         LLDCrashed,
         LLDReportedFailure,
         LLD_LinkingIsTODO_ForSpirV,
-        LibCInstallationMissingCRTDir,
+        LibCInstallationMissingCrtDir,
         LibCInstallationNotAvailable,
         LinkingWithoutZigSourceUnimplemented,
         MalformedArchive,
@@ -604,18 +606,15 @@ pub const File = struct {
         const comp = base.comp;
         if (comp.clang_preprocessor_mode == .yes or comp.clang_preprocessor_mode == .pch) {
             dev.check(.clang_command);
-            const gpa = comp.gpa;
             const emit = base.emit;
             // TODO: avoid extra link step when it's just 1 object file (the `zig cc -c` case)
             // Until then, we do `lld -r -o output.o input.o` even though the output is the same
             // as the input. For the preprocessing case (`zig cc -E -o foo`) we copy the file
             // to the final location. See also the corresponding TODO in Coff linking.
-            const full_out_path = try emit.root_dir.join(gpa, &[_][]const u8{emit.sub_path});
-            defer gpa.free(full_out_path);
             assert(comp.c_object_table.count() == 1);
             const the_key = comp.c_object_table.keys()[0];
             const cached_pp_file_path = the_key.status.success.object_path;
-            try fs.cwd().copyFile(cached_pp_file_path, fs.cwd(), full_out_path, .{});
+            try cached_pp_file_path.root_dir.handle.copyFile(cached_pp_file_path.sub_path, emit.root_dir.handle, emit.sub_path, .{});
             return;
         }
 
@@ -779,7 +778,7 @@ pub const File = struct {
 
         log.debug("zcu_obj_path={s}", .{if (zcu_obj_path) |s| s else "(null)"});
 
-        const compiler_rt_path: ?[]const u8 = if (comp.include_compiler_rt)
+        const compiler_rt_path: ?Path = if (comp.include_compiler_rt)
             comp.compiler_rt_obj.?.full_object_path
         else
             null;
@@ -804,18 +803,18 @@ pub const File = struct {
             base.releaseLock();
 
             for (objects) |obj| {
-                _ = try man.addFile(obj.path, null);
+                _ = try man.addFilePath(obj.path, null);
                 man.hash.add(obj.must_link);
                 man.hash.add(obj.loption);
             }
             for (comp.c_object_table.keys()) |key| {
-                _ = try man.addFile(key.status.success.object_path, null);
+                _ = try man.addFilePath(key.status.success.object_path, null);
             }
             for (comp.win32_resource_table.keys()) |key| {
                 _ = try man.addFile(key.status.success.res_path, null);
             }
             try man.addOptionalFile(zcu_obj_path);
-            try man.addOptionalFile(compiler_rt_path);
+            try man.addOptionalFilePath(compiler_rt_path);
 
             // We don't actually care whether it's a cache hit or miss; we just need the digest and the lock.
             _ = try man.hit();
@@ -849,10 +848,10 @@ pub const File = struct {
         defer object_files.deinit();
 
         for (objects) |obj| {
-            object_files.appendAssumeCapacity(try arena.dupeZ(u8, obj.path));
+            object_files.appendAssumeCapacity(try obj.path.toStringZ(arena));
         }
         for (comp.c_object_table.keys()) |key| {
-            object_files.appendAssumeCapacity(try arena.dupeZ(u8, key.status.success.object_path));
+            object_files.appendAssumeCapacity(try key.status.success.object_path.toStringZ(arena));
         }
         for (comp.win32_resource_table.keys()) |key| {
             object_files.appendAssumeCapacity(try arena.dupeZ(u8, key.status.success.res_path));
@@ -861,7 +860,7 @@ pub const File = struct {
             object_files.appendAssumeCapacity(try arena.dupeZ(u8, p));
         }
         if (compiler_rt_path) |p| {
-            object_files.appendAssumeCapacity(try arena.dupeZ(u8, p));
+            object_files.appendAssumeCapacity(try p.toStringZ(arena));
         }
 
         if (comp.verbose_link) {
@@ -932,7 +931,6 @@ pub const File = struct {
                 .xcoff => @panic("TODO implement xcoff object format"),
                 .hex => @panic("TODO implement hex object format"),
                 .raw => @panic("TODO implement raw object format"),
-                .dxcontainer => @panic("TODO implement dxcontainer object format"),
             };
         }
 
diff --git a/zig/src/link/C.zig b/zig/src/link/C.zig
index a674b256b0..d2d4ca9fbc 100644
--- a/zig/src/link/C.zig
+++ b/zig/src/link/C.zig
@@ -148,7 +148,6 @@ pub fn createEmpty(
             .file = file,
             .disable_lld_caching = options.disable_lld_caching,
             .build_id = options.build_id,
-            .rpath_list = options.rpath_list,
         },
     };
 
@@ -398,7 +397,7 @@ fn abiDefines(self: *C, target: std.Target) !std.ArrayList(u8) {
     errdefer defines.deinit();
     const writer = defines.writer();
     switch (target.abi) {
-        .msvc => try writer.writeAll("#define ZIG_TARGET_ABI_MSVC\n"),
+        .msvc, .itanium => try writer.writeAll("#define ZIG_TARGET_ABI_MSVC\n"),
         else => {},
     }
     try writer.print("#define ZIG_TARGET_MAX_INT_ALIGNMENT {d}\n", .{
diff --git a/zig/src/link/Coff.zig b/zig/src/link/Coff.zig
index 24040cb2f8..b104cd5840 100644
--- a/zig/src/link/Coff.zig
+++ b/zig/src/link/Coff.zig
@@ -263,7 +263,6 @@ pub fn createEmpty(
             .file = null,
             .disable_lld_caching = options.disable_lld_caching,
             .build_id = options.build_id,
-            .rpath_list = options.rpath_list,
         },
         .ptr_width = ptr_width,
         .page_size = page_size,
diff --git a/zig/src/link/Coff/lld.zig b/zig/src/link/Coff/lld.zig
index 9225399c94..cf09174e88 100644
--- a/zig/src/link/Coff/lld.zig
+++ b/zig/src/link/Coff/lld.zig
@@ -7,6 +7,7 @@ const fs = std.fs;
 const log = std.log.scoped(.link);
 const mem = std.mem;
 const Cache = std.Build.Cache;
+const Path = std.Build.Cache.Path;
 
 const mingw = @import("../../mingw.zig");
 const link = @import("../../link.zig");
@@ -74,11 +75,11 @@ pub fn linkWithLLD(self: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_no
         comptime assert(Compilation.link_hash_implementation_version == 14);
 
         for (comp.objects) |obj| {
-            _ = try man.addFile(obj.path, null);
+            _ = try man.addFilePath(obj.path, null);
             man.hash.add(obj.must_link);
         }
         for (comp.c_object_table.keys()) |key| {
-            _ = try man.addFile(key.status.success.object_path, null);
+            _ = try man.addFilePath(key.status.success.object_path, null);
         }
         for (comp.win32_resource_table.keys()) |key| {
             _ = try man.addFile(key.status.success.res_path, null);
@@ -93,7 +94,7 @@ pub fn linkWithLLD(self: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_no
             man.hash.add(comp.libc_installation != null);
             if (comp.libc_installation) |libc_installation| {
                 man.hash.addBytes(libc_installation.crt_dir.?);
-                if (target.abi == .msvc) {
+                if (target.abi == .msvc or target.abi == .itanium) {
                     man.hash.addBytes(libc_installation.msvc_lib_dir.?);
                     man.hash.addBytes(libc_installation.kernel32_lib_dir.?);
                 }
@@ -154,17 +155,19 @@ pub fn linkWithLLD(self: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_no
                 break :blk comp.c_object_table.keys()[0].status.success.object_path;
 
             if (module_obj_path) |p|
-                break :blk p;
+                break :blk Path.initCwd(p);
 
             // TODO I think this is unreachable. Audit this situation when solving the above TODO
             // regarding eliding redundant object -> object transformations.
             return error.NoObjectsToLink;
         };
-        // This can happen when using --enable-cache and using the stage1 backend. In this case
-        // we can skip the file copy.
-        if (!mem.eql(u8, the_object_path, full_out_path)) {
-            try fs.cwd().copyFile(the_object_path, fs.cwd(), full_out_path, .{});
-        }
+        try std.fs.Dir.copyFile(
+            the_object_path.root_dir.handle,
+            the_object_path.sub_path,
+            directory.handle,
+            self.base.emit.sub_path,
+            .{},
+        );
     } else {
         // Create an LLD command line and invoke it.
         var argv = std.ArrayList([]const u8).init(gpa);
@@ -256,7 +259,7 @@ pub fn linkWithLLD(self: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_no
             if (comp.libc_installation) |libc_installation| {
                 try argv.append(try allocPrint(arena, "-LIBPATH:{s}", .{libc_installation.crt_dir.?}));
 
-                if (target.abi == .msvc) {
+                if (target.abi == .msvc or target.abi == .itanium) {
                     try argv.append(try allocPrint(arena, "-LIBPATH:{s}", .{libc_installation.msvc_lib_dir.?}));
                     try argv.append(try allocPrint(arena, "-LIBPATH:{s}", .{libc_installation.kernel32_lib_dir.?}));
                 }
@@ -270,14 +273,14 @@ pub fn linkWithLLD(self: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_no
         try argv.ensureUnusedCapacity(comp.objects.len);
         for (comp.objects) |obj| {
             if (obj.must_link) {
-                argv.appendAssumeCapacity(try allocPrint(arena, "-WHOLEARCHIVE:{s}", .{obj.path}));
+                argv.appendAssumeCapacity(try allocPrint(arena, "-WHOLEARCHIVE:{}", .{@as(Path, obj.path)}));
             } else {
-                argv.appendAssumeCapacity(obj.path);
+                argv.appendAssumeCapacity(try obj.path.toString(arena));
             }
         }
 
         for (comp.c_object_table.keys()) |key| {
-            try argv.append(key.status.success.object_path);
+            try argv.append(try key.status.success.object_path.toString(arena));
         }
 
         for (comp.win32_resource_table.keys()) |key| {
@@ -401,17 +404,17 @@ pub fn linkWithLLD(self: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_no
                         }
 
                         if (is_dyn_lib) {
-                            try argv.append(try comp.get_libc_crt_file(arena, "dllcrt2.obj"));
+                            try argv.append(try comp.crtFileAsString(arena, "dllcrt2.obj"));
                             if (target.cpu.arch == .x86) {
                                 try argv.append("-ALTERNATENAME:__DllMainCRTStartup@12=_DllMainCRTStartup@12");
                             } else {
                                 try argv.append("-ALTERNATENAME:_DllMainCRTStartup=DllMainCRTStartup");
                             }
                         } else {
-                            try argv.append(try comp.get_libc_crt_file(arena, "crt2.obj"));
+                            try argv.append(try comp.crtFileAsString(arena, "crt2.obj"));
                         }
 
-                        try argv.append(try comp.get_libc_crt_file(arena, "mingw32.lib"));
+                        try argv.append(try comp.crtFileAsString(arena, "mingw32.lib"));
                     } else {
                         const lib_str = switch (comp.config.link_mode) {
                             .dynamic => "",
@@ -456,36 +459,36 @@ pub fn linkWithLLD(self: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_no
 
         // libc++ dep
         if (comp.config.link_libcpp) {
-            try argv.append(comp.libcxxabi_static_lib.?.full_object_path);
-            try argv.append(comp.libcxx_static_lib.?.full_object_path);
+            try argv.append(try comp.libcxxabi_static_lib.?.full_object_path.toString(arena));
+            try argv.append(try comp.libcxx_static_lib.?.full_object_path.toString(arena));
         }
 
         // libunwind dep
         if (comp.config.link_libunwind) {
-            try argv.append(comp.libunwind_static_lib.?.full_object_path);
+            try argv.append(try comp.libunwind_static_lib.?.full_object_path.toString(arena));
         }
 
         if (comp.config.any_fuzz) {
-            try argv.append(comp.fuzzer_lib.?.full_object_path);
+            try argv.append(try comp.fuzzer_lib.?.full_object_path.toString(arena));
         }
 
         if (is_exe_or_dyn_lib and !comp.skip_linker_dependencies) {
             if (!comp.config.link_libc) {
                 if (comp.libc_static_lib) |lib| {
-                    try argv.append(lib.full_object_path);
+                    try argv.append(try lib.full_object_path.toString(arena));
                 }
             }
             // MSVC compiler_rt is missing some stuff, so we build it unconditionally but
             // and rely on weak linkage to allow MSVC compiler_rt functions to override ours.
-            if (comp.compiler_rt_obj) |obj| try argv.append(obj.full_object_path);
-            if (comp.compiler_rt_lib) |lib| try argv.append(lib.full_object_path);
+            if (comp.compiler_rt_obj) |obj| try argv.append(try obj.full_object_path.toString(arena));
+            if (comp.compiler_rt_lib) |lib| try argv.append(try lib.full_object_path.toString(arena));
         }
 
         try argv.ensureUnusedCapacity(comp.system_libs.count());
         for (comp.system_libs.keys()) |key| {
             const lib_basename = try allocPrint(arena, "{s}.lib", .{key});
             if (comp.crt_files.get(lib_basename)) |crt_file| {
-                argv.appendAssumeCapacity(crt_file.full_object_path);
+                argv.appendAssumeCapacity(try crt_file.full_object_path.toString(arena));
                 continue;
             }
             if (try findLib(arena, lib_basename, self.lib_dirs)) |full_path| {
@@ -499,7 +502,7 @@ pub fn linkWithLLD(self: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_no
                     continue;
                 }
             }
-            if (target.abi == .msvc) {
+            if (target.abi == .msvc or target.abi == .itanium) {
                 argv.appendAssumeCapacity(lib_basename);
                 continue;
             }
diff --git a/zig/src/link/Dwarf.zig b/zig/src/link/Dwarf.zig
index 6efa708d05..3b5e4fddeb 100644
--- a/zig/src/link/Dwarf.zig
+++ b/zig/src/link/Dwarf.zig
@@ -389,15 +389,10 @@ pub const Section = struct {
         if (dwarf.bin_file.cast(.elf)) |elf_file| {
             const zo = elf_file.zigObjectPtr().?;
             const atom = zo.symbol(sec.index).atom(elf_file).?;
-            const shndx = atom.output_section_index;
-            if (sec == &dwarf.debug_frame.section)
-                try elf_file.growAllocSection(shndx, len, sec.alignment.toByteUnits().?)
-            else
-                try elf_file.growNonAllocSection(shndx, len, sec.alignment.toByteUnits().?, true);
-            const shdr = elf_file.sections.items(.shdr)[shndx];
-            atom.size = shdr.sh_size;
-            atom.alignment = InternPool.Alignment.fromNonzeroByteUnits(shdr.sh_addralign);
-            sec.len = shdr.sh_size;
+            atom.size = len;
+            atom.alignment = sec.alignment;
+            sec.len = len;
+            try zo.allocateAtom(atom, false, elf_file);
         } else if (dwarf.bin_file.cast(.macho)) |macho_file| {
             const header = if (macho_file.d_sym) |*d_sym| header: {
                 try d_sym.growSection(@intCast(sec.index), len, true, macho_file);
@@ -418,11 +413,15 @@ pub const Section = struct {
         if (dwarf.bin_file.cast(.elf)) |elf_file| {
             const zo = elf_file.zigObjectPtr().?;
             const atom = zo.symbol(sec.index).atom(elf_file).?;
-            const shndx = atom.output_section_index;
-            const shdr = &elf_file.sections.items(.shdr)[shndx];
-            atom.size = sec.len;
-            shdr.sh_offset += len;
-            shdr.sh_size = sec.len;
+            if (atom.prevAtom(elf_file)) |_| {
+                // FIXME:JK trimming/shrinking has to be reworked on ZigObject/Elf level
+                atom.value += len;
+            } else {
+                const shdr = &elf_file.sections.items(.shdr)[atom.output_section_index];
+                shdr.sh_offset += len;
+                atom.value = 0;
+            }
+            atom.size -= len;
         } else if (dwarf.bin_file.cast(.macho)) |macho_file| {
             const header = if (macho_file.d_sym) |*d_sym|
                 &d_sym.sections.items[sec.index]
@@ -911,11 +910,9 @@ const Entry = struct {
         if (std.debug.runtime_safety) {
             log.err("missing {} from {s}", .{
                 @as(Entry.Index, @enumFromInt(entry - unit.entries.items.ptr)),
-                std.mem.sliceTo(if (dwarf.bin_file.cast(.elf)) |elf_file| sh_name: {
-                    const zo = elf_file.zigObjectPtr().?;
-                    const shndx = zo.symbol(sec.index).atom(elf_file).?.output_section_index;
-                    break :sh_name elf_file.shstrtab.items[elf_file.sections.items(.shdr)[shndx].sh_name..];
-                } else if (dwarf.bin_file.cast(.macho)) |macho_file|
+                std.mem.sliceTo(if (dwarf.bin_file.cast(.elf)) |elf_file|
+                    elf_file.zigObjectPtr().?.symbol(sec.index).name(elf_file)
+                else if (dwarf.bin_file.cast(.macho)) |macho_file|
                     if (macho_file.d_sym) |*d_sym|
                         &d_sym.sections.items[sec.index].segname
                     else
@@ -1374,10 +1371,11 @@ pub const WipNav = struct {
     any_children: bool,
     func: InternPool.Index,
     func_sym_index: u32,
-    func_high_reloc: u32,
-    inlined_funcs: std.ArrayListUnmanaged(struct {
+    func_high_pc: u32,
+    blocks: std.ArrayListUnmanaged(struct {
         abbrev_code: u32,
-        high_reloc: u32,
+        low_pc_off: u64,
+        high_pc: u32,
     }),
     cfi: struct {
         loc: u32,
@@ -1391,7 +1389,7 @@ pub const WipNav = struct {
 
     pub fn deinit(wip_nav: *WipNav) void {
         const gpa = wip_nav.dwarf.gpa;
-        if (wip_nav.func != .none) wip_nav.inlined_funcs.deinit(gpa);
+        if (wip_nav.func != .none) wip_nav.blocks.deinit(gpa);
         wip_nav.debug_frame.deinit(gpa);
         wip_nav.debug_info.deinit(gpa);
         wip_nav.debug_line.deinit(gpa);
@@ -1486,49 +1484,72 @@ pub const WipNav = struct {
         try dlw.writeByte(DW.LNS.set_epilogue_begin);
     }
 
-    pub fn enterInlineFunc(wip_nav: *WipNav, func: InternPool.Index, code_off: u64, line: u32, column: u32) UpdateError!void {
+    pub fn enterBlock(wip_nav: *WipNav, code_off: u64) UpdateError!void {
+        const dwarf = wip_nav.dwarf;
+        const diw = wip_nav.debug_info.writer(dwarf.gpa);
+        const block = try wip_nav.blocks.addOne(dwarf.gpa);
+
+        block.abbrev_code = @intCast(wip_nav.debug_info.items.len);
+        try wip_nav.abbrevCode(.block);
+        block.low_pc_off = code_off;
+        try wip_nav.infoAddrSym(wip_nav.func_sym_index, code_off);
+        block.high_pc = @intCast(wip_nav.debug_info.items.len);
+        try diw.writeInt(u32, 0, dwarf.endian);
+        wip_nav.any_children = false;
+    }
+
+    pub fn leaveBlock(wip_nav: *WipNav, code_off: u64) UpdateError!void {
+        const block_bytes = comptime uleb128Bytes(@intFromEnum(AbbrevCode.block));
+        const block = wip_nav.blocks.pop();
+        if (wip_nav.any_children)
+            try uleb128(wip_nav.debug_info.writer(wip_nav.dwarf.gpa), @intFromEnum(AbbrevCode.null))
+        else
+            std.leb.writeUnsignedFixed(
+                block_bytes,
+                wip_nav.debug_info.items[block.abbrev_code..][0..block_bytes],
+                try wip_nav.dwarf.refAbbrevCode(.empty_block),
+            );
+        std.mem.writeInt(u32, wip_nav.debug_info.items[block.high_pc..][0..4], @intCast(code_off - block.low_pc_off), wip_nav.dwarf.endian);
+        wip_nav.any_children = true;
+    }
+
+    pub fn enterInlineFunc(
+        wip_nav: *WipNav,
+        func: InternPool.Index,
+        code_off: u64,
+        line: u32,
+        column: u32,
+    ) UpdateError!void {
         const dwarf = wip_nav.dwarf;
         const zcu = wip_nav.pt.zcu;
         const diw = wip_nav.debug_info.writer(dwarf.gpa);
-        const inlined_func = try wip_nav.inlined_funcs.addOne(dwarf.gpa);
+        const block = try wip_nav.blocks.addOne(dwarf.gpa);
 
-        inlined_func.abbrev_code = @intCast(wip_nav.debug_info.items.len);
+        block.abbrev_code = @intCast(wip_nav.debug_info.items.len);
         try wip_nav.abbrevCode(.inlined_func);
         try wip_nav.refNav(zcu.funcInfo(func).owner_nav);
         try uleb128(diw, zcu.navSrcLine(zcu.funcInfo(wip_nav.func).owner_nav) + line + 1);
         try uleb128(diw, column + 1);
-        const external_relocs = &dwarf.debug_info.section.getUnit(wip_nav.unit).getEntry(wip_nav.entry).external_relocs;
-        try external_relocs.ensureUnusedCapacity(dwarf.gpa, 2);
-        external_relocs.appendAssumeCapacity(.{
-            .source_off = @intCast(wip_nav.debug_info.items.len),
-            .target_sym = wip_nav.func_sym_index,
-            .target_off = code_off,
-        });
-        try diw.writeByteNTimes(0, @intFromEnum(dwarf.address_size));
-        inlined_func.high_reloc = @intCast(external_relocs.items.len);
-        external_relocs.appendAssumeCapacity(.{
-            .source_off = @intCast(wip_nav.debug_info.items.len),
-            .target_sym = wip_nav.func_sym_index,
-            .target_off = undefined,
-        });
-        try diw.writeByteNTimes(0, @intFromEnum(dwarf.address_size));
+        block.low_pc_off = code_off;
+        try wip_nav.infoAddrSym(wip_nav.func_sym_index, code_off);
+        block.high_pc = @intCast(wip_nav.debug_info.items.len);
+        try diw.writeInt(u32, 0, dwarf.endian);
         try wip_nav.setInlineFunc(func);
         wip_nav.any_children = false;
     }
 
     pub fn leaveInlineFunc(wip_nav: *WipNav, func: InternPool.Index, code_off: u64) UpdateError!void {
         const inlined_func_bytes = comptime uleb128Bytes(@intFromEnum(AbbrevCode.inlined_func));
-        const inlined_func = wip_nav.inlined_funcs.pop();
-        const external_relocs = &wip_nav.dwarf.debug_info.section.getUnit(wip_nav.unit).getEntry(wip_nav.entry).external_relocs;
-        external_relocs.items[inlined_func.high_reloc].target_off = code_off;
+        const block = wip_nav.blocks.pop();
         if (wip_nav.any_children)
             try uleb128(wip_nav.debug_info.writer(wip_nav.dwarf.gpa), @intFromEnum(AbbrevCode.null))
         else
             std.leb.writeUnsignedFixed(
                 inlined_func_bytes,
-                wip_nav.debug_info.items[inlined_func.abbrev_code..][0..inlined_func_bytes],
+                wip_nav.debug_info.items[block.abbrev_code..][0..inlined_func_bytes],
                 try wip_nav.dwarf.refAbbrevCode(.empty_inlined_func),
             );
+        std.mem.writeInt(u32, wip_nav.debug_info.items[block.high_pc..][0..4], @intCast(code_off - block.low_pc_off), wip_nav.dwarf.endian);
         try wip_nav.setInlineFunc(func);
         wip_nav.any_children = true;
     }
@@ -1664,17 +1685,18 @@ pub const WipNav = struct {
                 return ctx.wip_nav.dwarf.endian;
             }
             fn addrSym(ctx: @This(), sym_index: u32) UpdateError!void {
-                try ctx.wip_nav.infoAddrSym(sym_index);
+                try ctx.wip_nav.infoAddrSym(sym_index, 0);
             }
         } = .{ .wip_nav = wip_nav };
         try uleb128(adapter.writer(), counter.stream.bytes_written);
         try loc.write(adapter);
     }
 
-    fn infoAddrSym(wip_nav: *WipNav, sym_index: u32) UpdateError!void {
+    fn infoAddrSym(wip_nav: *WipNav, sym_index: u32, sym_off: u64) UpdateError!void {
         try wip_nav.infoExternalReloc(.{
             .source_off = @intCast(wip_nav.debug_info.items.len),
             .target_sym = sym_index,
+            .target_off = sym_off,
         });
         try wip_nav.debug_info.appendNTimes(wip_nav.dwarf.gpa, 0, @intFromEnum(wip_nav.dwarf.address_size));
     }
@@ -1695,17 +1717,18 @@ pub const WipNav = struct {
                 return ctx.wip_nav.dwarf.endian;
             }
             fn addrSym(ctx: @This(), sym_index: u32) UpdateError!void {
-                try ctx.wip_nav.frameAddrSym(sym_index);
+                try ctx.wip_nav.frameAddrSym(sym_index, 0);
             }
         } = .{ .wip_nav = wip_nav };
         try uleb128(adapter.writer(), counter.stream.bytes_written);
         try loc.write(adapter);
     }
 
-    fn frameAddrSym(wip_nav: *WipNav, sym_index: u32) UpdateError!void {
+    fn frameAddrSym(wip_nav: *WipNav, sym_index: u32, sym_off: u64) UpdateError!void {
         try wip_nav.frameExternalReloc(.{
             .source_off = @intCast(wip_nav.debug_frame.items.len),
             .target_sym = sym_index,
+            .target_off = sym_off,
         });
         try wip_nav.debug_frame.appendNTimes(wip_nav.dwarf.gpa, 0, @intFromEnum(wip_nav.dwarf.address_size));
     }
@@ -2150,8 +2173,8 @@ pub fn initWipNav(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPool.Nav.In
         .any_children = false,
         .func = .none,
         .func_sym_index = undefined,
-        .func_high_reloc = undefined,
-        .inlined_funcs = undefined,
+        .func_high_pc = undefined,
+        .blocks = undefined,
         .cfi = undefined,
         .debug_frame = .{},
         .debug_info = .{},
@@ -2294,7 +2317,7 @@ pub fn initWipNav(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPool.Nav.In
             const func_type = ip.indexToKey(func.ty).func_type;
             wip_nav.func = nav_val.toIntern();
             wip_nav.func_sym_index = sym_index;
-            wip_nav.inlined_funcs = .{};
+            wip_nav.blocks = .{};
             if (dwarf.debug_frame.header.format != .none) wip_nav.cfi = .{
                 .loc = 0,
                 .cfa = dwarf.debug_frame.header.initial_instructions[0].def_cfa,
@@ -2319,7 +2342,7 @@ pub fn initWipNav(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPool.Nav.In
                                 .source_off = @intCast(wip_nav.debug_frame.items.len),
                             });
                             try dfw.writeByteNTimes(0, dwarf.sectionOffsetBytes());
-                            try wip_nav.frameAddrSym(sym_index);
+                            try wip_nav.frameAddrSym(sym_index, 0);
                             try dfw.writeByteNTimes(undefined, @intFromEnum(dwarf.address_size));
                         },
                         .eh_frame => {
@@ -2346,20 +2369,9 @@ pub fn initWipNav(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPool.Nav.In
             try wip_nav.strp(nav.name.toSlice(ip));
             try wip_nav.strp(nav.fqn.toSlice(ip));
             try wip_nav.refType(Type.fromInterned(func_type.return_type));
-            const external_relocs = &dwarf.debug_info.section.getUnit(wip_nav.unit).getEntry(wip_nav.entry).external_relocs;
-            try external_relocs.ensureUnusedCapacity(dwarf.gpa, 2);
-            external_relocs.appendAssumeCapacity(.{
-                .source_off = @intCast(wip_nav.debug_info.items.len),
-                .target_sym = sym_index,
-            });
-            try diw.writeByteNTimes(0, @intFromEnum(dwarf.address_size));
-            wip_nav.func_high_reloc = @intCast(external_relocs.items.len);
-            external_relocs.appendAssumeCapacity(.{
-                .source_off = @intCast(wip_nav.debug_info.items.len),
-                .target_sym = sym_index,
-                .target_off = undefined,
-            });
-            try diw.writeByteNTimes(0, @intFromEnum(dwarf.address_size));
+            try wip_nav.infoAddrSym(sym_index, 0);
+            wip_nav.func_high_pc = @intCast(wip_nav.debug_info.items.len);
+            try diw.writeInt(u32, 0, dwarf.endian);
             try uleb128(diw, nav.status.resolved.alignment.toByteUnits() orelse
                 target_info.defaultFunctionAlignment(file.mod.resolved_target.result).toByteUnits().?);
             try diw.writeByte(@intFromBool(false));
@@ -2466,8 +2478,7 @@ pub fn finishWipNav(
             },
         }
         {
-            const external_relocs = &dwarf.debug_info.section.getUnit(wip_nav.unit).getEntry(wip_nav.entry).external_relocs;
-            external_relocs.items[wip_nav.func_high_reloc].target_off = sym.size;
+            std.mem.writeInt(u32, wip_nav.debug_info.items[wip_nav.func_high_pc..][0..4], @intCast(sym.size), dwarf.endian);
             if (wip_nav.any_children) {
                 const diw = wip_nav.debug_info.writer(dwarf.gpa);
                 try uleb128(diw, @intFromEnum(AbbrevCode.null));
@@ -2562,8 +2573,8 @@ pub fn updateComptimeNav(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPool
         .any_children = false,
         .func = .none,
         .func_sym_index = undefined,
-        .func_high_reloc = undefined,
-        .inlined_funcs = undefined,
+        .func_high_pc = undefined,
+        .blocks = undefined,
         .cfi = undefined,
         .debug_frame = .{},
         .debug_info = .{},
@@ -3036,8 +3047,8 @@ fn updateType(
         .any_children = false,
         .func = .none,
         .func_sym_index = undefined,
-        .func_high_reloc = undefined,
-        .inlined_funcs = undefined,
+        .func_high_pc = undefined,
+        .blocks = undefined,
         .cfi = undefined,
         .debug_frame = .{},
         .debug_info = .{},
@@ -3480,8 +3491,8 @@ pub fn updateContainerType(dwarf: *Dwarf, pt: Zcu.PerThread, type_index: InternP
             .any_children = false,
             .func = .none,
             .func_sym_index = undefined,
-            .func_high_reloc = undefined,
-            .inlined_funcs = undefined,
+            .func_high_pc = undefined,
+            .blocks = undefined,
             .cfi = undefined,
             .debug_frame = .{},
             .debug_info = .{},
@@ -3553,8 +3564,8 @@ pub fn updateContainerType(dwarf: *Dwarf, pt: Zcu.PerThread, type_index: InternP
             .any_children = false,
             .func = .none,
             .func_sym_index = undefined,
-            .func_high_reloc = undefined,
-            .inlined_funcs = undefined,
+            .func_high_pc = undefined,
+            .blocks = undefined,
             .cfi = undefined,
             .debug_frame = .{},
             .debug_info = .{},
@@ -3756,8 +3767,8 @@ pub fn flushModule(dwarf: *Dwarf, pt: Zcu.PerThread) FlushError!void {
             .any_children = false,
             .func = .none,
             .func_sym_index = undefined,
-            .func_high_reloc = undefined,
-            .inlined_funcs = undefined,
+            .func_high_pc = undefined,
+            .blocks = undefined,
             .cfi = undefined,
             .debug_frame = .{},
             .debug_info = .{},
@@ -4212,6 +4223,8 @@ const AbbrevCode = enum {
     empty_packed_struct_type,
     union_type,
     empty_union_type,
+    empty_block,
+    block,
     empty_inlined_func,
     inlined_func,
     local_arg,
@@ -4319,7 +4332,7 @@ const AbbrevCode = enum {
                 .{ .linkage_name, .strp },
                 .{ .type, .ref_addr },
                 .{ .low_pc, .addr },
-                .{ .high_pc, .addr },
+                .{ .high_pc, .data4 },
                 .{ .alignment, .udata },
                 .{ .external, .flag },
                 .{ .noreturn, .flag },
@@ -4331,7 +4344,7 @@ const AbbrevCode = enum {
                 .{ .linkage_name, .strp },
                 .{ .type, .ref_addr },
                 .{ .low_pc, .addr },
-                .{ .high_pc, .addr },
+                .{ .high_pc, .data4 },
                 .{ .alignment, .udata },
                 .{ .external, .flag },
                 .{ .noreturn, .flag },
@@ -4672,6 +4685,21 @@ const AbbrevCode = enum {
                 .{ .alignment, .udata },
             },
         },
+        .empty_block = .{
+            .tag = .lexical_block,
+            .attrs = &.{
+                .{ .low_pc, .addr },
+                .{ .high_pc, .data4 },
+            },
+        },
+        .block = .{
+            .tag = .lexical_block,
+            .children = true,
+            .attrs = &.{
+                .{ .low_pc, .addr },
+                .{ .high_pc, .data4 },
+            },
+        },
         .empty_inlined_func = .{
             .tag = .inlined_subroutine,
             .attrs = &.{
@@ -4679,7 +4707,7 @@ const AbbrevCode = enum {
                 .{ .call_line, .udata },
                 .{ .call_column, .udata },
                 .{ .low_pc, .addr },
-                .{ .high_pc, .addr },
+                .{ .high_pc, .data4 },
             },
         },
         .inlined_func = .{
@@ -4690,7 +4718,7 @@ const AbbrevCode = enum {
                 .{ .call_line, .udata },
                 .{ .call_column, .udata },
                 .{ .low_pc, .addr },
-                .{ .high_pc, .addr },
+                .{ .high_pc, .data4 },
             },
         },
         .local_arg = .{
diff --git a/zig/src/link/Elf.zig b/zig/src/link/Elf.zig
index ba3abcf330..5f6a073842 100644
--- a/zig/src/link/Elf.zig
+++ b/zig/src/link/Elf.zig
@@ -1,4 +1,5 @@
 base: link.File,
+rpath_table: std.StringArrayHashMapUnmanaged(void),
 image_base: u64,
 emit_relocs: bool,
 z_nodelete: bool,
@@ -147,6 +148,7 @@ thunks: std.ArrayListUnmanaged(Thunk) = .empty,
 
 /// List of output merge sections with deduped contents.
 merge_sections: std.ArrayListUnmanaged(MergeSection) = .empty,
+comment_merge_section_index: ?MergeSection.Index = null,
 
 first_eflags: ?elf.Elf64_Word = null,
 
@@ -187,11 +189,41 @@ pub fn createEmpty(
         else => return error.UnsupportedELFArchitecture,
     };
 
+    // This is the max page size that the target system can run with, aka the ABI page size. Not to
+    // be confused with the common page size, which is the page size that's used in practice on most
+    // systems.
     const page_size: u32 = switch (target.cpu.arch) {
-        .aarch64, .powerpc64le => 0x10000,
-        .sparc64 => 0x2000,
+        .bpfel,
+        .bpfeb,
+        .sparc64,
+        => 0x100000,
+        .aarch64,
+        .aarch64_be,
+        .amdgcn,
+        .hexagon,
+        .mips,
+        .mipsel,
+        .mips64,
+        .mips64el,
+        .powerpc,
+        .powerpcle,
+        .powerpc64,
+        .powerpc64le,
+        .sparc,
+        => 0x10000,
+        .loongarch32,
+        .loongarch64,
+        => 0x4000,
+        .arc,
+        .m68k,
+        => 0x2000,
+        .msp430,
+        => 0x4,
+        .avr,
+        => 0x1,
         else => 0x1000,
     };
+
     const is_dyn_lib = output_mode == .Lib and link_mode == .dynamic;
     const default_sym_version: elf.Elf64_Versym = if (is_dyn_lib or comp.config.rdynamic)
         elf.VER_NDX_GLOBAL
@@ -208,6 +240,11 @@ pub fn createEmpty(
     else
         try std.fmt.allocPrint(arena, "{s}.o", .{emit.sub_path});
 
+    var rpath_table: std.StringArrayHashMapUnmanaged(void) = .empty;
+    try rpath_table.entries.resize(arena, options.rpath_list.len);
+    @memcpy(rpath_table.entries.items(.key), options.rpath_list);
+    try rpath_table.reIndex(arena);
+
     const self = try arena.create(Elf);
     self.* = .{
         .base = .{
@@ -222,8 +259,8 @@ pub fn createEmpty(
             .file = null,
             .disable_lld_caching = options.disable_lld_caching,
             .build_id = options.build_id,
-            .rpath_list = options.rpath_list,
         },
+        .rpath_table = rpath_table,
         .ptr_width = ptr_width,
         .page_size = page_size,
         .default_sym_version = default_sym_version,
@@ -346,9 +383,9 @@ pub fn createEmpty(
             const index: File.Index = @intCast(try self.files.addOne(gpa));
             self.files.set(index, .{ .zig_object = .{
                 .index = index,
-                .path = try std.fmt.allocPrint(arena, "{s}.o", .{fs.path.stem(
-                    zcu.main_mod.root_src_path,
-                )}),
+                .basename = try std.fmt.allocPrint(arena, "{s}.o", .{
+                    fs.path.stem(zcu.main_mod.root_src_path),
+                }),
             } });
             self.zig_object_index = index;
             try self.zigObjectPtr().?.init(self, .{
@@ -511,16 +548,6 @@ pub fn allocatedSize(self: *Elf, start: u64) u64 {
     return min_pos - start;
 }
 
-fn allocatedVirtualSize(self: *Elf, start: u64) u64 {
-    if (start == 0) return 0;
-    var min_pos: u64 = std.math.maxInt(u64);
-    for (self.phdrs.items) |phdr| {
-        if (phdr.p_vaddr <= start) continue;
-        if (phdr.p_vaddr < min_pos) min_pos = phdr.p_vaddr;
-    }
-    return min_pos - start;
-}
-
 pub fn findFreeSpace(self: *Elf, object_size: u64, min_alignment: u64) !u64 {
     var start: u64 = 0;
     while (try self.detectAllocCollision(start, object_size)) |item_end| {
@@ -529,103 +556,49 @@ pub fn findFreeSpace(self: *Elf, object_size: u64, min_alignment: u64) !u64 {
     return start;
 }
 
-pub fn growAllocSection(self: *Elf, shdr_index: u32, needed_size: u64, min_alignment: u64) !void {
-    const slice = self.sections.slice();
-    const shdr = &slice.items(.shdr)[shdr_index];
-    assert(shdr.sh_flags & elf.SHF_ALLOC != 0);
-    const phndx = slice.items(.phndx)[shdr_index];
-    const maybe_phdr = if (phndx) |ndx| &self.phdrs.items[ndx] else null;
-
-    log.debug("allocated size {x} of {s}, needed size {x}", .{
-        self.allocatedSize(shdr.sh_offset),
-        self.getShString(shdr.sh_name),
-        needed_size,
-    });
+pub fn growSection(self: *Elf, shdr_index: u32, needed_size: u64, min_alignment: u64) !void {
+    const shdr = &self.sections.items(.shdr)[shdr_index];
 
     if (shdr.sh_type != elf.SHT_NOBITS) {
         const allocated_size = self.allocatedSize(shdr.sh_offset);
+        log.debug("allocated size {x} of '{s}', needed size {x}", .{
+            allocated_size,
+            self.getShString(shdr.sh_name),
+            needed_size,
+        });
+
         if (needed_size > allocated_size) {
             const existing_size = shdr.sh_size;
             shdr.sh_size = 0;
             // Must move the entire section.
             const new_offset = try self.findFreeSpace(needed_size, min_alignment);
 
-            log.debug("new '{s}' file offset 0x{x} to 0x{x}", .{
+            log.debug("moving '{s}' from 0x{x} to 0x{x}", .{
                 self.getShString(shdr.sh_name),
+                shdr.sh_offset,
                 new_offset,
-                new_offset + existing_size,
             });
 
-            const amt = try self.base.file.?.copyRangeAll(shdr.sh_offset, self.base.file.?, new_offset, existing_size);
-            // TODO figure out what to about this error condition - how to communicate it up.
-            if (amt != existing_size) return error.InputOutput;
-
-            shdr.sh_offset = new_offset;
-            if (maybe_phdr) |phdr| phdr.p_offset = new_offset;
-        } else if (shdr.sh_offset + allocated_size == std.math.maxInt(u64)) {
-            try self.base.file.?.setEndPos(shdr.sh_offset + needed_size);
-        }
-        if (maybe_phdr) |phdr| phdr.p_filesz = needed_size;
-    }
-    shdr.sh_size = needed_size;
-
-    if (maybe_phdr) |phdr| {
-        const mem_capacity = self.allocatedVirtualSize(phdr.p_vaddr);
-        if (needed_size > mem_capacity) {
-            var err = try self.base.addErrorWithNotes(2);
-            try err.addMsg("fatal linker error: cannot expand load segment phdr({d}) in virtual memory", .{phndx.?});
-            try err.addNote("TODO: emit relocations to memory locations in self-hosted backends", .{});
-            try err.addNote("as a workaround, try increasing pre-allocated virtual memory of each segment", .{});
-        }
-
-        phdr.p_memsz = needed_size;
-    }
-
-    self.markDirty(shdr_index);
-}
-
-pub fn growNonAllocSection(
-    self: *Elf,
-    shdr_index: u32,
-    needed_size: u64,
-    min_alignment: u64,
-    requires_file_copy: bool,
-) !void {
-    const shdr = &self.sections.items(.shdr)[shdr_index];
-    assert(shdr.sh_flags & elf.SHF_ALLOC == 0);
-
-    const allocated_size = self.allocatedSize(shdr.sh_offset);
-    if (needed_size > allocated_size) {
-        const existing_size = shdr.sh_size;
-        shdr.sh_size = 0;
-        // Move all the symbols to a new file location.
-        const new_offset = try self.findFreeSpace(needed_size, min_alignment);
-
-        log.debug("new '{s}' file offset 0x{x} to 0x{x}", .{
-            self.getShString(shdr.sh_name),
-            new_offset,
-            new_offset + existing_size,
-        });
-
-        if (requires_file_copy) {
             const amt = try self.base.file.?.copyRangeAll(
                 shdr.sh_offset,
                 self.base.file.?,
                 new_offset,
                 existing_size,
             );
+            // TODO figure out what to about this error condition - how to communicate it up.
             if (amt != existing_size) return error.InputOutput;
-        }
 
-        shdr.sh_offset = new_offset;
-    } else if (shdr.sh_offset + allocated_size == std.math.maxInt(u64)) {
-        try self.base.file.?.setEndPos(shdr.sh_offset + needed_size);
+            shdr.sh_offset = new_offset;
+        } else if (shdr.sh_offset + allocated_size == std.math.maxInt(u64)) {
+            try self.base.file.?.setEndPos(shdr.sh_offset + needed_size);
+        }
     }
+
     shdr.sh_size = needed_size;
     self.markDirty(shdr_index);
 }
 
-pub fn markDirty(self: *Elf, shdr_index: u32) void {
+fn markDirty(self: *Elf, shdr_index: u32) void {
     if (self.zigObjectPtr()) |zo| {
         for ([_]?Symbol.Index{
             zo.debug_info_index,
@@ -718,25 +691,27 @@ pub fn allocateChunk(self: *Elf, args: struct {
         }
     };
 
-    log.debug("allocated chunk (size({x}),align({x})) at 0x{x} (file(0x{x}))", .{
-        args.size,
-        args.alignment.toByteUnits().?,
-        shdr.sh_addr + res.value,
-        shdr.sh_offset + res.value,
-    });
-
     const expand_section = if (self.atom(res.placement)) |placement_atom|
         placement_atom.nextAtom(self) == null
     else
         true;
     if (expand_section) {
         const needed_size = res.value + args.size;
-        if (shdr.sh_flags & elf.SHF_ALLOC != 0)
-            try self.growAllocSection(args.shndx, needed_size, args.alignment.toByteUnits().?)
-        else
-            try self.growNonAllocSection(args.shndx, needed_size, args.alignment.toByteUnits().?, true);
+        try self.growSection(args.shndx, needed_size, args.alignment.toByteUnits().?);
     }
 
+    log.debug("allocated chunk (size({x}),align({x})) in {s} at 0x{x} (file(0x{x}))", .{
+        args.size,
+        args.alignment.toByteUnits().?,
+        self.getShString(shdr.sh_name),
+        shdr.sh_addr + res.value,
+        shdr.sh_offset + res.value,
+    });
+    log.debug("  placement {}, {s}", .{
+        res.placement,
+        if (self.atom(res.placement)) |atom_ptr| atom_ptr.name(self) else "",
+    });
+
     return res;
 }
 
@@ -767,13 +742,12 @@ pub fn flushModule(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_nod
     const target = self.getTarget();
     const link_mode = comp.config.link_mode;
     const directory = self.base.emit.root_dir; // Just an alias to make it shorter to type.
-    const full_out_path = try directory.join(arena, &[_][]const u8{self.base.emit.sub_path});
-    const module_obj_path: ?[]const u8 = if (self.base.zcu_object_sub_path) |path| blk: {
-        if (fs.path.dirname(full_out_path)) |dirname| {
-            break :blk try fs.path.join(arena, &.{ dirname, path });
-        } else {
-            break :blk path;
-        }
+    const module_obj_path: ?Path = if (self.base.zcu_object_sub_path) |path| .{
+        .root_dir = directory,
+        .sub_path = if (fs.path.dirname(self.base.emit.sub_path)) |dirname|
+            try fs.path.join(arena, &.{ dirname, path })
+        else
+            path,
     } else null;
 
     // --verbose-link
@@ -783,89 +757,54 @@ pub fn flushModule(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_nod
     if (self.base.isStaticLib()) return relocatable.flushStaticLib(self, comp, module_obj_path);
     if (self.base.isObject()) return relocatable.flushObject(self, comp, module_obj_path);
 
-    const csu = try CsuObjects.init(arena, comp);
-    const compiler_rt_path: ?[]const u8 = blk: {
-        if (comp.compiler_rt_lib) |x| break :blk x.full_object_path;
-        if (comp.compiler_rt_obj) |x| break :blk x.full_object_path;
-        break :blk null;
-    };
-
-    // Here we will parse input positional and library files (if referenced).
-    // This will roughly match in any linker backend we support.
-    var positionals = std.ArrayList(Compilation.LinkObject).init(arena);
+    const csu = try comp.getCrtPaths(arena);
 
     // csu prelude
-    if (csu.crt0) |v| try positionals.append(.{ .path = v });
-    if (csu.crti) |v| try positionals.append(.{ .path = v });
-    if (csu.crtbegin) |v| try positionals.append(.{ .path = v });
+    if (csu.crt0) |path| try parseObjectReportingFailure(self, path);
+    if (csu.crti) |path| try parseObjectReportingFailure(self, path);
+    if (csu.crtbegin) |path| try parseObjectReportingFailure(self, path);
 
-    try positionals.ensureUnusedCapacity(comp.objects.len);
-    positionals.appendSliceAssumeCapacity(comp.objects);
+    for (comp.objects) |obj| {
+        if (obj.isObject()) {
+            try parseObjectReportingFailure(self, obj.path);
+        } else {
+            try parseLibraryReportingFailure(self, .{ .path = obj.path }, obj.must_link);
+        }
+    }
 
     // This is a set of object files emitted by clang in a single `build-exe` invocation.
     // For instance, the implicit `a.o` as compiled by `zig build-exe a.c` will end up
     // in this set.
     for (comp.c_object_table.keys()) |key| {
-        try positionals.append(.{ .path = key.status.success.object_path });
-    }
-
-    if (module_obj_path) |path| try positionals.append(.{ .path = path });
-
-    // rpaths
-    var rpath_table = std.StringArrayHashMap(void).init(gpa);
-    defer rpath_table.deinit();
-
-    for (self.base.rpath_list) |rpath| {
-        _ = try rpath_table.put(rpath, {});
+        try parseObjectReportingFailure(self, key.status.success.object_path);
     }
 
-    if (comp.config.any_sanitize_thread) {
-        try positionals.append(.{ .path = comp.tsan_lib.?.full_object_path });
-    }
+    if (module_obj_path) |path| try parseObjectReportingFailure(self, path);
 
-    if (comp.config.any_fuzz) {
-        try positionals.append(.{ .path = comp.fuzzer_lib.?.full_object_path });
-    }
+    if (comp.config.any_sanitize_thread) try parseCrtFileReportingFailure(self, comp.tsan_lib.?);
+    if (comp.config.any_fuzz) try parseCrtFileReportingFailure(self, comp.fuzzer_lib.?);
 
     // libc
     if (!comp.skip_linker_dependencies and !comp.config.link_libc) {
-        if (comp.libc_static_lib) |lib| {
-            try positionals.append(.{ .path = lib.full_object_path });
-        }
+        if (comp.libc_static_lib) |lib| try parseCrtFileReportingFailure(self, lib);
     }
 
-    for (positionals.items) |obj| {
-        self.parsePositional(obj.path, obj.must_link) catch |err| switch (err) {
-            error.MalformedObject,
-            error.MalformedArchive,
-            error.MismatchedEflags,
-            error.InvalidMachineType,
-            => continue, // already reported
-            else => |e| try self.reportParseError(
-                obj.path,
-                "unexpected error: parsing input file failed with error {s}",
-                .{@errorName(e)},
-            ),
-        };
-    }
-
-    var system_libs = std.ArrayList(SystemLib).init(arena);
-
-    try system_libs.ensureUnusedCapacity(comp.system_libs.values().len);
     for (comp.system_libs.values()) |lib_info| {
-        system_libs.appendAssumeCapacity(.{ .needed = lib_info.needed, .path = lib_info.path.? });
+        try self.parseLibraryReportingFailure(.{
+            .needed = lib_info.needed,
+            .path = lib_info.path.?,
+        }, false);
     }
 
     // libc++ dep
     if (comp.config.link_libcpp) {
-        try system_libs.ensureUnusedCapacity(2);
-        system_libs.appendAssumeCapacity(.{ .path = comp.libcxxabi_static_lib.?.full_object_path });
-        system_libs.appendAssumeCapacity(.{ .path = comp.libcxx_static_lib.?.full_object_path });
+        try self.parseLibraryReportingFailure(.{ .path = comp.libcxxabi_static_lib.?.full_object_path }, false);
+        try self.parseLibraryReportingFailure(.{ .path = comp.libcxx_static_lib.?.full_object_path }, false);
     }
 
     // libunwind dep
     if (comp.config.link_libunwind) {
-        try system_libs.append(.{ .path = comp.libunwind_static_lib.?.full_object_path });
+        try self.parseLibraryReportingFailure(.{ .path = comp.libunwind_static_lib.?.full_object_path }, false);
     }
 
     // libc dep
@@ -873,7 +812,6 @@ pub fn flushModule(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_nod
     if (comp.config.link_libc) {
         if (comp.libc_installation) |lc| {
             const flags = target_util.libcFullLinkFlags(target);
-            try system_libs.ensureUnusedCapacity(flags.len);
 
             var test_path = std.ArrayList(u8).init(arena);
             var checked_paths = std.ArrayList([]const u8).init(arena);
@@ -899,72 +837,48 @@ pub fn flushModule(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_nod
                     continue;
                 }
 
-                const resolved_path = try arena.dupe(u8, test_path.items);
-                system_libs.appendAssumeCapacity(.{ .path = resolved_path });
+                const resolved_path = Path.initCwd(try arena.dupe(u8, test_path.items));
+                try self.parseLibraryReportingFailure(.{ .path = resolved_path }, false);
             }
         } else if (target.isGnuLibC()) {
-            try system_libs.ensureUnusedCapacity(glibc.libs.len + 1);
             for (glibc.libs) |lib| {
                 if (lib.removed_in) |rem_in| {
                     if (target.os.version_range.linux.glibc.order(rem_in) != .lt) continue;
                 }
 
-                const lib_path = try std.fmt.allocPrint(arena, "{s}{c}lib{s}.so.{d}", .{
+                const lib_path = Path.initCwd(try std.fmt.allocPrint(arena, "{s}{c}lib{s}.so.{d}", .{
                     comp.glibc_so_files.?.dir_path, fs.path.sep, lib.name, lib.sover,
-                });
-                system_libs.appendAssumeCapacity(.{ .path = lib_path });
+                }));
+                try self.parseLibraryReportingFailure(.{ .path = lib_path }, false);
             }
-            system_libs.appendAssumeCapacity(.{
+            try self.parseLibraryReportingFailure(.{
                 .path = try comp.get_libc_crt_file(arena, "libc_nonshared.a"),
-            });
+            }, false);
         } else if (target.isMusl()) {
             const path = try comp.get_libc_crt_file(arena, switch (link_mode) {
                 .static => "libc.a",
                 .dynamic => "libc.so",
             });
-            try system_libs.append(.{ .path = path });
+            try self.parseLibraryReportingFailure(.{ .path = path }, false);
         } else {
             comp.link_error_flags.missing_libc = true;
         }
     }
 
-    for (system_libs.items) |lib| {
-        self.parseLibrary(lib, false) catch |err| switch (err) {
-            error.MalformedObject, error.MalformedArchive, error.InvalidMachineType => continue, // already reported
-            else => |e| try self.reportParseError(
-                lib.path,
-                "unexpected error: parsing library failed with error {s}",
-                .{@errorName(e)},
-            ),
-        };
-    }
-
     // Finally, as the last input objects we add compiler_rt and CSU postlude (if any).
-    positionals.clearRetainingCapacity();
 
     // compiler-rt. Since compiler_rt exports symbols like `memset`, it needs
     // to be after the shared libraries, so they are picked up from the shared
     // libraries, not libcompiler_rt.
-    if (compiler_rt_path) |path| try positionals.append(.{ .path = path });
+    if (comp.compiler_rt_lib) |crt_file| {
+        try parseLibraryReportingFailure(self, .{ .path = crt_file.full_object_path }, false);
+    } else if (comp.compiler_rt_obj) |crt_file| {
+        try parseObjectReportingFailure(self, crt_file.full_object_path);
+    }
 
     // csu postlude
-    if (csu.crtend) |v| try positionals.append(.{ .path = v });
-    if (csu.crtn) |v| try positionals.append(.{ .path = v });
-
-    for (positionals.items) |obj| {
-        self.parsePositional(obj.path, obj.must_link) catch |err| switch (err) {
-            error.MalformedObject,
-            error.MalformedArchive,
-            error.MismatchedEflags,
-            error.InvalidMachineType,
-            => continue, // already reported
-            else => |e| try self.reportParseError(
-                obj.path,
-                "unexpected error: parsing input file failed with error {s}",
-                .{@errorName(e)},
-            ),
-        };
-    }
+    if (csu.crtend) |path| try parseObjectReportingFailure(self, path);
+    if (csu.crtn) |path| try parseObjectReportingFailure(self, path);
 
     if (self.base.hasErrors()) return error.FlushFailure;
 
@@ -1006,7 +920,9 @@ pub fn flushModule(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_nod
     self.markEhFrameAtomsDead();
     try self.resolveMergeSections();
 
-    try self.convertCommonSymbols();
+    for (self.objects.items) |index| {
+        try self.file(index).?.object.convertCommonSymbols(self);
+    }
     self.markImportsExports();
 
     if (self.base.gc_sections) {
@@ -1038,7 +954,7 @@ pub fn flushModule(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_nod
     try self.initSpecialPhdrs();
     try self.sortShdrs();
 
-    try self.setDynamicSection(rpath_table.keys());
+    try self.setDynamicSection(self.rpath_table.keys());
     self.sortDynamicSymtab();
     try self.setHashSections();
     try self.setVersionSymtab();
@@ -1047,6 +963,7 @@ pub fn flushModule(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_nod
     try self.updateMergeSectionSizes();
     try self.updateSectionSizes();
 
+    try self.addLoadPhdrs();
     try self.allocatePhdrTable();
     try self.allocateAllocSections();
     try self.sortPhdrs();
@@ -1064,6 +981,13 @@ pub fn flushModule(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_nod
 
     // Beyond this point, everything has been allocated a virtual address and we can resolve
     // the relocations, and commit objects to file.
+    for (self.objects.items) |index| {
+        self.file(index).?.object.dirty = false;
+    }
+    // TODO: would state tracking be more appropriate here? perhaps even custom relocation type?
+    self.rela_dyn.clearRetainingCapacity();
+    self.rela_plt.clearRetainingCapacity();
+
     if (self.zigObjectPtr()) |zo| {
         var has_reloc_errors = false;
         for (zo.atoms_indexes.items) |atom_index| {
@@ -1093,6 +1017,7 @@ pub fn flushModule(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_nod
     try self.writeShdrTable();
     try self.writeAtoms();
     try self.writeMergeSections();
+
     self.writeSyntheticSections() catch |err| switch (err) {
         error.RelocFailure => return error.FlushFailure,
         error.UnsupportedCpuArch => {
@@ -1133,10 +1058,10 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
         }
     } else null;
 
-    const csu = try CsuObjects.init(arena, comp);
+    const csu = try comp.getCrtPaths(arena);
     const compiler_rt_path: ?[]const u8 = blk: {
-        if (comp.compiler_rt_lib) |x| break :blk x.full_object_path;
-        if (comp.compiler_rt_obj) |x| break :blk x.full_object_path;
+        if (comp.compiler_rt_lib) |x| break :blk try x.full_object_path.toString(arena);
+        if (comp.compiler_rt_obj) |x| break :blk try x.full_object_path.toString(arena);
         break :blk null;
     };
 
@@ -1159,11 +1084,11 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
 
     if (self.base.isRelocatable()) {
         for (comp.objects) |obj| {
-            try argv.append(obj.path);
+            try argv.append(try obj.path.toString(arena));
         }
 
         for (comp.c_object_table.keys()) |key| {
-            try argv.append(key.status.success.object_path);
+            try argv.append(try key.status.success.object_path.toString(arena));
         }
 
         if (module_obj_path) |p| {
@@ -1188,9 +1113,8 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
             try argv.appendSlice(&.{ "--entry", name });
         }
 
-        for (self.base.rpath_list) |rpath| {
-            try argv.append("-rpath");
-            try argv.append(rpath);
+        for (self.rpath_table.keys()) |rpath| {
+            try argv.appendSlice(&.{ "-rpath", rpath });
         }
 
         try argv.appendSlice(&.{
@@ -1246,9 +1170,9 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
         }
 
         // csu prelude
-        if (csu.crt0) |v| try argv.append(v);
-        if (csu.crti) |v| try argv.append(v);
-        if (csu.crtbegin) |v| try argv.append(v);
+        if (csu.crt0) |path| try argv.append(try path.toString(arena));
+        if (csu.crti) |path| try argv.append(try path.toString(arena));
+        if (csu.crtbegin) |path| try argv.append(try path.toString(arena));
 
         for (self.lib_dirs) |lib_dir| {
             try argv.append("-L");
@@ -1273,10 +1197,9 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
             }
 
             if (obj.loption) {
-                assert(obj.path[0] == ':');
                 try argv.append("-l");
             }
-            try argv.append(obj.path);
+            try argv.append(try obj.path.toString(arena));
         }
         if (whole_archive) {
             try argv.append("-no-whole-archive");
@@ -1284,7 +1207,7 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
         }
 
         for (comp.c_object_table.keys()) |key| {
-            try argv.append(key.status.success.object_path);
+            try argv.append(try key.status.success.object_path.toString(arena));
         }
 
         if (module_obj_path) |p| {
@@ -1292,17 +1215,17 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
         }
 
         if (comp.config.any_sanitize_thread) {
-            try argv.append(comp.tsan_lib.?.full_object_path);
+            try argv.append(try comp.tsan_lib.?.full_object_path.toString(arena));
         }
 
         if (comp.config.any_fuzz) {
-            try argv.append(comp.fuzzer_lib.?.full_object_path);
+            try argv.append(try comp.fuzzer_lib.?.full_object_path.toString(arena));
         }
 
         // libc
         if (!comp.skip_linker_dependencies and !comp.config.link_libc) {
             if (comp.libc_static_lib) |lib| {
-                try argv.append(lib.full_object_path);
+                try argv.append(try lib.full_object_path.toString(arena));
             }
         }
 
@@ -1326,7 +1249,7 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
                     as_needed = true;
                 },
             }
-            argv.appendAssumeCapacity(lib_info.path.?);
+            argv.appendAssumeCapacity(try lib_info.path.?.toString(arena));
         }
 
         if (!as_needed) {
@@ -1336,13 +1259,13 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
 
         // libc++ dep
         if (comp.config.link_libcpp) {
-            try argv.append(comp.libcxxabi_static_lib.?.full_object_path);
-            try argv.append(comp.libcxx_static_lib.?.full_object_path);
+            try argv.append(try comp.libcxxabi_static_lib.?.full_object_path.toString(arena));
+            try argv.append(try comp.libcxx_static_lib.?.full_object_path.toString(arena));
         }
 
         // libunwind dep
         if (comp.config.link_libunwind) {
-            try argv.append(comp.libunwind_static_lib.?.full_object_path);
+            try argv.append(try comp.libunwind_static_lib.?.full_object_path.toString(arena));
         }
 
         // libc dep
@@ -1363,9 +1286,9 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
                     });
                     try argv.append(lib_path);
                 }
-                try argv.append(try comp.get_libc_crt_file(arena, "libc_nonshared.a"));
+                try argv.append(try comp.crtFileAsString(arena, "libc_nonshared.a"));
             } else if (target.isMusl()) {
-                try argv.append(try comp.get_libc_crt_file(arena, switch (link_mode) {
+                try argv.append(try comp.crtFileAsString(arena, switch (link_mode) {
                     .static => "libc.a",
                     .dynamic => "libc.so",
                 }));
@@ -1378,18 +1301,17 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
         }
 
         // crt postlude
-        if (csu.crtend) |v| try argv.append(v);
-        if (csu.crtn) |v| try argv.append(v);
+        if (csu.crtend) |path| try argv.append(try path.toString(arena));
+        if (csu.crtn) |path| try argv.append(try path.toString(arena));
     }
 
     Compilation.dump_argv(argv.items);
 }
 
 pub const ParseError = error{
-    MalformedObject,
-    MalformedArchive,
-    InvalidMachineType,
-    MismatchedEflags,
+    /// Indicates the error is already reported on `Compilation.link_errors`.
+    LinkFailure,
+
     OutOfMemory,
     Overflow,
     InputOutput,
@@ -1400,20 +1322,33 @@ pub const ParseError = error{
     UnknownFileType,
 } || LdScript.Error || fs.Dir.AccessError || fs.File.SeekError || fs.File.OpenError || fs.File.ReadError;
 
-pub fn parsePositional(self: *Elf, path: []const u8, must_link: bool) ParseError!void {
-    const tracy = trace(@src());
-    defer tracy.end();
-    if (try Object.isObject(path)) {
-        try self.parseObject(path);
+fn parseCrtFileReportingFailure(self: *Elf, crt_file: Compilation.CrtFile) error{OutOfMemory}!void {
+    if (crt_file.isObject()) {
+        try parseObjectReportingFailure(self, crt_file.full_object_path);
     } else {
-        try self.parseLibrary(.{ .path = path }, must_link);
+        try parseLibraryReportingFailure(self, .{ .path = crt_file.full_object_path }, false);
     }
 }
 
+pub fn parseObjectReportingFailure(self: *Elf, path: Path) error{OutOfMemory}!void {
+    self.parseObject(path) catch |err| switch (err) {
+        error.LinkFailure => return, // already reported
+        error.OutOfMemory => return error.OutOfMemory,
+        else => |e| try self.addParseError(path, "unable to parse object: {s}", .{@errorName(e)}),
+    };
+}
+
+pub fn parseLibraryReportingFailure(self: *Elf, lib: SystemLib, must_link: bool) error{OutOfMemory}!void {
+    self.parseLibrary(lib, must_link) catch |err| switch (err) {
+        error.LinkFailure => return, // already reported
+        error.OutOfMemory => return error.OutOfMemory,
+        else => |e| try self.addParseError(lib.path, "unable to parse library: {s}", .{@errorName(e)}),
+    };
+}
+
 fn parseLibrary(self: *Elf, lib: SystemLib, must_link: bool) ParseError!void {
     const tracy = trace(@src());
     defer tracy.end();
-
     if (try Archive.isArchive(lib.path)) {
         try self.parseArchive(lib.path, must_link);
     } else if (try SharedObject.isSharedObject(lib.path)) {
@@ -1423,17 +1358,20 @@ fn parseLibrary(self: *Elf, lib: SystemLib, must_link: bool) ParseError!void {
     }
 }
 
-fn parseObject(self: *Elf, path: []const u8) ParseError!void {
+fn parseObject(self: *Elf, path: Path) ParseError!void {
     const tracy = trace(@src());
     defer tracy.end();
 
     const gpa = self.base.comp.gpa;
-    const handle = try fs.cwd().openFile(path, .{});
+    const handle = try path.root_dir.handle.openFile(path.sub_path, .{});
     const fh = try self.addFileHandle(handle);
 
-    const index = @as(File.Index, @intCast(try self.files.addOne(gpa)));
+    const index: File.Index = @intCast(try self.files.addOne(gpa));
     self.files.set(index, .{ .object = .{
-        .path = try gpa.dupe(u8, path),
+        .path = .{
+            .root_dir = path.root_dir,
+            .sub_path = try gpa.dupe(u8, path.sub_path),
+        },
         .file_handle = fh,
         .index = index,
     } });
@@ -1443,15 +1381,15 @@ fn parseObject(self: *Elf, path: []const u8) ParseError!void {
     try object.parse(self);
 }
 
-fn parseArchive(self: *Elf, path: []const u8, must_link: bool) ParseError!void {
+fn parseArchive(self: *Elf, path: Path, must_link: bool) ParseError!void {
     const tracy = trace(@src());
     defer tracy.end();
 
     const gpa = self.base.comp.gpa;
-    const handle = try fs.cwd().openFile(path, .{});
+    const handle = try path.root_dir.handle.openFile(path.sub_path, .{});
     const fh = try self.addFileHandle(handle);
 
-    var archive = Archive{};
+    var archive: Archive = .{};
     defer archive.deinit(gpa);
     try archive.parse(self, path, fh);
 
@@ -1459,7 +1397,7 @@ fn parseArchive(self: *Elf, path: []const u8, must_link: bool) ParseError!void {
     defer gpa.free(objects);
 
     for (objects) |extracted| {
-        const index = @as(File.Index, @intCast(try self.files.addOne(gpa)));
+        const index: File.Index = @intCast(try self.files.addOne(gpa));
         self.files.set(index, .{ .object = extracted });
         const object = &self.files.items(.data)[index].object;
         object.index = index;
@@ -1474,12 +1412,15 @@ fn parseSharedObject(self: *Elf, lib: SystemLib) ParseError!void {
     defer tracy.end();
 
     const gpa = self.base.comp.gpa;
-    const handle = try fs.cwd().openFile(lib.path, .{});
+    const handle = try lib.path.root_dir.handle.openFile(lib.path.sub_path, .{});
     defer handle.close();
 
     const index = @as(File.Index, @intCast(try self.files.addOne(gpa)));
     self.files.set(index, .{ .shared_object = .{
-        .path = try gpa.dupe(u8, lib.path),
+        .path = .{
+            .root_dir = lib.path.root_dir,
+            .sub_path = try gpa.dupe(u8, lib.path.sub_path),
+        },
         .index = index,
         .needed = lib.needed,
         .alive = lib.needed,
@@ -1495,12 +1436,12 @@ fn parseLdScript(self: *Elf, lib: SystemLib) ParseError!void {
     defer tracy.end();
 
     const gpa = self.base.comp.gpa;
-    const in_file = try fs.cwd().openFile(lib.path, .{});
+    const in_file = try lib.path.root_dir.handle.openFile(lib.path.sub_path, .{});
     defer in_file.close();
     const data = try in_file.readToEndAlloc(gpa, std.math.maxInt(u32));
     defer gpa.free(data);
 
-    var script = LdScript{ .path = lib.path };
+    var script: LdScript = .{ .path = lib.path };
     defer script.deinit(gpa);
     try script.parse(data, self);
 
@@ -1511,12 +1452,12 @@ fn parseLdScript(self: *Elf, lib: SystemLib) ParseError!void {
     var test_path = std.ArrayList(u8).init(arena);
     var checked_paths = std.ArrayList([]const u8).init(arena);
 
-    for (script.args.items) |scr_obj| {
+    for (script.args.items) |script_arg| {
         checked_paths.clearRetainingCapacity();
 
         success: {
-            if (mem.startsWith(u8, scr_obj.path, "-l")) {
-                const lib_name = scr_obj.path["-l".len..];
+            if (mem.startsWith(u8, script_arg.path, "-l")) {
+                const lib_name = script_arg.path["-l".len..];
 
                 // TODO I think technically we should re-use the mechanism used by the frontend here.
                 // Maybe we should hoist search-strategy all the way here?
@@ -1530,37 +1471,34 @@ fn parseLdScript(self: *Elf, lib: SystemLib) ParseError!void {
                 }
             } else {
                 var buffer: [fs.max_path_bytes]u8 = undefined;
-                if (fs.realpath(scr_obj.path, &buffer)) |path| {
+                if (fs.realpath(script_arg.path, &buffer)) |path| {
                     test_path.clearRetainingCapacity();
                     try test_path.writer().writeAll(path);
                     break :success;
                 } else |_| {}
 
-                try checked_paths.append(try arena.dupe(u8, scr_obj.path));
+                try checked_paths.append(try arena.dupe(u8, script_arg.path));
                 for (self.lib_dirs) |lib_dir| {
-                    if (try self.accessLibPath(arena, &test_path, &checked_paths, lib_dir, scr_obj.path, null))
+                    if (try self.accessLibPath(arena, &test_path, &checked_paths, lib_dir, script_arg.path, null))
                         break :success;
                 }
             }
 
             try self.reportMissingLibraryError(
                 checked_paths.items,
-                "missing library dependency: GNU ld script '{s}' requires '{s}', but file not found",
-                .{
-                    lib.path,
-                    scr_obj.path,
-                },
+                "missing library dependency: GNU ld script '{}' requires '{s}', but file not found",
+                .{ @as(Path, lib.path), script_arg.path },
             );
             continue;
         }
 
-        const full_path = test_path.items;
+        const full_path = Path.initCwd(test_path.items);
         self.parseLibrary(.{
-            .needed = scr_obj.needed,
+            .needed = script_arg.needed,
             .path = full_path,
         }, false) catch |err| switch (err) {
-            error.MalformedObject, error.MalformedArchive, error.InvalidMachineType => continue, // already reported
-            else => |e| try self.reportParseError(
+            error.LinkFailure => continue, // already reported
+            else => |e| try self.addParseError(
                 full_path,
                 "unexpected error: parsing library failed with error {s}",
                 .{@errorName(e)},
@@ -1585,24 +1523,24 @@ pub fn validateEFlags(self: *Elf, file_index: File.Index, e_flags: elf.Elf64_Wor
                 self_riscv_eflags.rvc = self_riscv_eflags.rvc or riscv_eflags.rvc;
                 self_riscv_eflags.tso = self_riscv_eflags.tso or riscv_eflags.tso;
 
-                var is_error: bool = false;
+                var any_errors: bool = false;
                 if (self_riscv_eflags.fabi != riscv_eflags.fabi) {
-                    is_error = true;
-                    _ = try self.reportParseError2(
+                    any_errors = true;
+                    try self.addFileError(
                         file_index,
                         "cannot link object files with different float-point ABIs",
                         .{},
                     );
                 }
                 if (self_riscv_eflags.rve != riscv_eflags.rve) {
-                    is_error = true;
-                    _ = try self.reportParseError2(
+                    any_errors = true;
+                    try self.addFileError(
                         file_index,
                         "cannot link object files with different RVEs",
                         .{},
                     );
                 }
-                if (is_error) return error.MismatchedEflags;
+                if (any_errors) return error.LinkFailure;
             }
         },
         else => {},
@@ -1724,12 +1662,6 @@ pub fn markEhFrameAtomsDead(self: *Elf) void {
     }
 }
 
-fn convertCommonSymbols(self: *Elf) !void {
-    for (self.objects.items) |index| {
-        try self.file(index).?.object.convertCommonSymbols(self);
-    }
-}
-
 fn markImportsExports(self: *Elf) void {
     if (self.zigObjectPtr()) |zo| {
         zo.markImportsExports(self);
@@ -1903,7 +1835,7 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
     const have_dynamic_linker = comp.config.link_libc and
         link_mode == .dynamic and is_exe_or_dyn_lib;
     const target = self.getTarget();
-    const compiler_rt_path: ?[]const u8 = blk: {
+    const compiler_rt_path: ?Path = blk: {
         if (comp.compiler_rt_lib) |x| break :blk x.full_object_path;
         if (comp.compiler_rt_obj) |x| break :blk x.full_object_path;
         break :blk null;
@@ -1937,17 +1869,17 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
         man.hash.add(self.allow_undefined_version);
         man.hash.addOptional(self.enable_new_dtags);
         for (comp.objects) |obj| {
-            _ = try man.addFile(obj.path, null);
+            _ = try man.addFilePath(obj.path, null);
             man.hash.add(obj.must_link);
             man.hash.add(obj.loption);
         }
         for (comp.c_object_table.keys()) |key| {
-            _ = try man.addFile(key.status.success.object_path, null);
+            _ = try man.addFilePath(key.status.success.object_path, null);
         }
         try man.addOptionalFile(module_obj_path);
-        try man.addOptionalFile(compiler_rt_path);
-        try man.addOptionalFile(if (comp.tsan_lib) |l| l.full_object_path else null);
-        try man.addOptionalFile(if (comp.fuzzer_lib) |l| l.full_object_path else null);
+        try man.addOptionalFilePath(compiler_rt_path);
+        try man.addOptionalFilePath(if (comp.tsan_lib) |l| l.full_object_path else null);
+        try man.addOptionalFilePath(if (comp.fuzzer_lib) |l| l.full_object_path else null);
 
         // We can skip hashing libc and libc++ components that we are in charge of building from Zig
         // installation sources because they are always a product of the compiler version + target information.
@@ -1959,7 +1891,7 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
         man.hash.add(self.emit_relocs);
         man.hash.add(comp.config.rdynamic);
         man.hash.addListOfBytes(self.lib_dirs);
-        man.hash.addListOfBytes(self.base.rpath_list);
+        man.hash.addListOfBytes(self.rpath_table.keys());
         if (output_mode == .Exe) {
             man.hash.add(self.base.stack_size);
             man.hash.add(self.base.build_id);
@@ -2044,17 +1976,19 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
                 break :blk comp.c_object_table.keys()[0].status.success.object_path;
 
             if (module_obj_path) |p|
-                break :blk p;
+                break :blk Path.initCwd(p);
 
             // TODO I think this is unreachable. Audit this situation when solving the above TODO
             // regarding eliding redundant object -> object transformations.
             return error.NoObjectsToLink;
         };
-        // This can happen when using --enable-cache and using the stage1 backend. In this case
-        // we can skip the file copy.
-        if (!mem.eql(u8, the_object_path, full_out_path)) {
-            try fs.cwd().copyFile(the_object_path, fs.cwd(), full_out_path, .{});
-        }
+        try std.fs.Dir.copyFile(
+            the_object_path.root_dir.handle,
+            the_object_path.sub_path,
+            directory.handle,
+            self.base.emit.sub_path,
+            .{},
+        );
     } else {
         // Create an LLD command line and invoke it.
         var argv = std.ArrayList([]const u8).init(gpa);
@@ -2205,13 +2139,8 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
         }
 
         if (getLDMOption(target)) |ldm| {
-            // Any target ELF will use the freebsd osabi if suffixed with "_fbsd".
-            const arg = if (target.os.tag == .freebsd)
-                try std.fmt.allocPrint(arena, "{s}_fbsd", .{ldm})
-            else
-                ldm;
             try argv.append("-m");
-            try argv.append(arg);
+            try argv.append(ldm);
         }
 
         if (link_mode == .static) {
@@ -2244,19 +2173,13 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
         try argv.append(full_out_path);
 
         // csu prelude
-        const csu = try CsuObjects.init(arena, comp);
-        if (csu.crt0) |v| try argv.append(v);
-        if (csu.crti) |v| try argv.append(v);
-        if (csu.crtbegin) |v| try argv.append(v);
-
-        // rpaths
-        var rpath_table = std.StringHashMap(void).init(gpa);
-        defer rpath_table.deinit();
-        for (self.base.rpath_list) |rpath| {
-            if ((try rpath_table.fetchPut(rpath, {})) == null) {
-                try argv.append("-rpath");
-                try argv.append(rpath);
-            }
+        const csu = try comp.getCrtPaths(arena);
+        if (csu.crt0) |p| try argv.append(try p.toString(arena));
+        if (csu.crti) |p| try argv.append(try p.toString(arena));
+        if (csu.crtbegin) |p| try argv.append(try p.toString(arena));
+
+        for (self.rpath_table.keys()) |rpath| {
+            try argv.appendSlice(&.{ "-rpath", rpath });
         }
 
         for (self.symbol_wrap_set.keys()) |symbol_name| {
@@ -2317,10 +2240,10 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
             }
 
             if (obj.loption) {
-                assert(obj.path[0] == ':');
+                assert(obj.path.sub_path[0] == ':');
                 try argv.append("-l");
             }
-            try argv.append(obj.path);
+            try argv.append(try obj.path.toString(arena));
         }
         if (whole_archive) {
             try argv.append("-no-whole-archive");
@@ -2328,7 +2251,7 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
         }
 
         for (comp.c_object_table.keys()) |key| {
-            try argv.append(key.status.success.object_path);
+            try argv.append(try key.status.success.object_path.toString(arena));
         }
 
         if (module_obj_path) |p| {
@@ -2337,12 +2260,12 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
 
         if (comp.tsan_lib) |lib| {
             assert(comp.config.any_sanitize_thread);
-            try argv.append(lib.full_object_path);
+            try argv.append(try lib.full_object_path.toString(arena));
         }
 
         if (comp.fuzzer_lib) |lib| {
             assert(comp.config.any_fuzz);
-            try argv.append(lib.full_object_path);
+            try argv.append(try lib.full_object_path.toString(arena));
         }
 
         // libc
@@ -2351,7 +2274,7 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
             !comp.config.link_libc)
         {
             if (comp.libc_static_lib) |lib| {
-                try argv.append(lib.full_object_path);
+                try argv.append(try lib.full_object_path.toString(arena));
             }
         }
 
@@ -2384,7 +2307,7 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
                 // libraries and not static libraries (the check for that needs to be earlier),
                 // but they could be full paths to .so files, in which case we
                 // want to avoid prepending "-l".
-                argv.appendAssumeCapacity(lib_info.path.?);
+                argv.appendAssumeCapacity(try lib_info.path.?.toString(arena));
             }
 
             if (!as_needed) {
@@ -2394,13 +2317,13 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
 
             // libc++ dep
             if (comp.config.link_libcpp) {
-                try argv.append(comp.libcxxabi_static_lib.?.full_object_path);
-                try argv.append(comp.libcxx_static_lib.?.full_object_path);
+                try argv.append(try comp.libcxxabi_static_lib.?.full_object_path.toString(arena));
+                try argv.append(try comp.libcxx_static_lib.?.full_object_path.toString(arena));
             }
 
             // libunwind dep
             if (comp.config.link_libunwind) {
-                try argv.append(comp.libunwind_static_lib.?.full_object_path);
+                try argv.append(try comp.libunwind_static_lib.?.full_object_path.toString(arena));
             }
 
             // libc dep
@@ -2422,9 +2345,9 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
                         });
                         try argv.append(lib_path);
                     }
-                    try argv.append(try comp.get_libc_crt_file(arena, "libc_nonshared.a"));
+                    try argv.append(try comp.crtFileAsString(arena, "libc_nonshared.a"));
                 } else if (target.isMusl()) {
-                    try argv.append(try comp.get_libc_crt_file(arena, switch (link_mode) {
+                    try argv.append(try comp.crtFileAsString(arena, switch (link_mode) {
                         .static => "libc.a",
                         .dynamic => "libc.so",
                     }));
@@ -2438,12 +2361,12 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
         // to be after the shared libraries, so they are picked up from the shared
         // libraries, not libcompiler_rt.
         if (compiler_rt_path) |p| {
-            try argv.append(p);
+            try argv.append(try p.toString(arena));
         }
 
         // crt postlude
-        if (csu.crtend) |v| try argv.append(v);
-        if (csu.crtn) |v| try argv.append(v);
+        if (csu.crtend) |p| try argv.append(try p.toString(arena));
+        if (csu.crtn) |p| try argv.append(try p.toString(arena));
 
         if (self.base.allow_shlib_undefined) {
             try argv.append("--allow-shlib-undefined");
@@ -2600,11 +2523,28 @@ pub fn writeElfHeader(self: *Elf) !void {
     hdr_buf[index] = 1; // ELF version
     index += 1;
 
-    // OS ABI, often set to 0 regardless of target platform
+    hdr_buf[index] = @intFromEnum(@as(elf.OSABI, switch (target.cpu.arch) {
+        .amdgcn => switch (target.os.tag) {
+            .amdhsa => .AMDGPU_HSA,
+            .amdpal => .AMDGPU_PAL,
+            .mesa3d => .AMDGPU_MESA3D,
+            else => .NONE,
+        },
+        .msp430 => .STANDALONE,
+        else => switch (target.os.tag) {
+            .freebsd, .ps4 => .FREEBSD,
+            .hermit => .STANDALONE,
+            .illumos, .solaris => .SOLARIS,
+            .openbsd => .OPENBSD,
+            else => .NONE,
+        },
+    }));
+    index += 1;
+
     // ABI Version, possibly used by glibc but not by static executables
     // padding
-    @memset(hdr_buf[index..][0..9], 0);
-    index += 9;
+    @memset(hdr_buf[index..][0..8], 0);
+    index += 8;
 
     assert(index == 16);
 
@@ -2790,6 +2730,7 @@ fn checkDuplicates(self: *Elf) !void {
 
 pub fn addCommentString(self: *Elf) !void {
     const gpa = self.base.comp.gpa;
+    if (self.comment_merge_section_index != null) return;
     const msec_index = try self.getOrCreateMergeSection(".comment", elf.SHF_MERGE | elf.SHF_STRINGS, elf.SHT_PROGBITS);
     const msec = self.mergeSection(msec_index);
     const res = try msec.insertZ(gpa, "zig " ++ builtin.zig_version_string);
@@ -2803,6 +2744,7 @@ pub fn addCommentString(self: *Elf) !void {
     msub.entsize = 1;
     msub.alive = true;
     res.sub.* = msub_index;
+    self.comment_merge_section_index = msec_index;
 }
 
 pub fn resolveMergeSections(self: *Elf) !void {
@@ -2811,10 +2753,11 @@ pub fn resolveMergeSections(self: *Elf) !void {
 
     var has_errors = false;
     for (self.objects.items) |index| {
-        const file_ptr = self.file(index).?;
-        if (!file_ptr.isAlive()) continue;
-        file_ptr.object.initInputMergeSections(self) catch |err| switch (err) {
-            error.MalformedObject => has_errors = true,
+        const object = self.file(index).?.object;
+        if (!object.alive) continue;
+        if (!object.dirty) continue;
+        object.initInputMergeSections(self) catch |err| switch (err) {
+            error.LinkFailure => has_errors = true,
             else => |e| return e,
         };
     }
@@ -2822,21 +2765,23 @@ pub fn resolveMergeSections(self: *Elf) !void {
     if (has_errors) return error.FlushFailure;
 
     for (self.objects.items) |index| {
-        const file_ptr = self.file(index).?;
-        if (!file_ptr.isAlive()) continue;
-        try file_ptr.object.initOutputMergeSections(self);
+        const object = self.file(index).?.object;
+        if (!object.alive) continue;
+        if (!object.dirty) continue;
+        try object.initOutputMergeSections(self);
     }
 
     for (self.objects.items) |index| {
-        const file_ptr = self.file(index).?;
-        if (!file_ptr.isAlive()) continue;
-        file_ptr.object.resolveMergeSubsections(self) catch |err| switch (err) {
-            error.MalformedObject => has_errors = true,
+        const object = self.file(index).?.object;
+        if (!object.alive) continue;
+        if (!object.dirty) continue;
+        object.resolveMergeSubsections(self) catch |err| switch (err) {
+            error.LinkFailure => has_errors = true,
             else => |e| return e,
         };
     }
 
-    if (has_errors) return error.FlushFailure;
+    if (has_errors) return error.LinkFailure;
 }
 
 pub fn finalizeMergeSections(self: *Elf) !void {
@@ -2917,37 +2862,35 @@ fn initSyntheticSections(self: *Elf) !void {
                     elf.SHT_PROGBITS,
                 .flags = elf.SHF_ALLOC,
                 .addralign = ptr_size,
-                .offset = std.math.maxInt(u64),
             });
         }
-        if (comp.link_eh_frame_hdr) {
+        if (comp.link_eh_frame_hdr and self.eh_frame_hdr_section_index == null) {
             self.eh_frame_hdr_section_index = try self.addSection(.{
                 .name = try self.insertShString(".eh_frame_hdr"),
                 .type = elf.SHT_PROGBITS,
                 .flags = elf.SHF_ALLOC,
                 .addralign = 4,
-                .offset = std.math.maxInt(u64),
             });
         }
     }
 
-    if (self.got.entries.items.len > 0) {
+    if (self.got.entries.items.len > 0 and self.got_section_index == null) {
         self.got_section_index = try self.addSection(.{
             .name = try self.insertShString(".got"),
             .type = elf.SHT_PROGBITS,
             .flags = elf.SHF_ALLOC | elf.SHF_WRITE,
             .addralign = ptr_size,
-            .offset = std.math.maxInt(u64),
         });
     }
 
-    self.got_plt_section_index = try self.addSection(.{
-        .name = try self.insertShString(".got.plt"),
-        .type = elf.SHT_PROGBITS,
-        .flags = elf.SHF_ALLOC | elf.SHF_WRITE,
-        .addralign = @alignOf(u64),
-        .offset = std.math.maxInt(u64),
-    });
+    if (self.got_plt_section_index == null) {
+        self.got_plt_section_index = try self.addSection(.{
+            .name = try self.insertShString(".got.plt"),
+            .type = elf.SHT_PROGBITS,
+            .flags = elf.SHF_ALLOC | elf.SHF_WRITE,
+            .addralign = @alignOf(u64),
+        });
+    }
 
     const needs_rela_dyn = blk: {
         if (self.got.flags.needs_rela or self.got.flags.needs_tlsld or self.copy_rel.symbols.items.len > 0)
@@ -2960,51 +2903,50 @@ fn initSyntheticSections(self: *Elf) !void {
         }
         break :blk false;
     };
-    if (needs_rela_dyn) {
+    if (needs_rela_dyn and self.rela_dyn_section_index == null) {
         self.rela_dyn_section_index = try self.addSection(.{
             .name = try self.insertShString(".rela.dyn"),
             .type = elf.SHT_RELA,
             .flags = elf.SHF_ALLOC,
             .addralign = @alignOf(elf.Elf64_Rela),
             .entsize = @sizeOf(elf.Elf64_Rela),
-            .offset = std.math.maxInt(u64),
         });
     }
 
     if (self.plt.symbols.items.len > 0) {
-        self.plt_section_index = try self.addSection(.{
-            .name = try self.insertShString(".plt"),
-            .type = elf.SHT_PROGBITS,
-            .flags = elf.SHF_ALLOC | elf.SHF_EXECINSTR,
-            .addralign = 16,
-            .offset = std.math.maxInt(u64),
-        });
-        self.rela_plt_section_index = try self.addSection(.{
-            .name = try self.insertShString(".rela.plt"),
-            .type = elf.SHT_RELA,
-            .flags = elf.SHF_ALLOC,
-            .addralign = @alignOf(elf.Elf64_Rela),
-            .entsize = @sizeOf(elf.Elf64_Rela),
-            .offset = std.math.maxInt(u64),
-        });
+        if (self.plt_section_index == null) {
+            self.plt_section_index = try self.addSection(.{
+                .name = try self.insertShString(".plt"),
+                .type = elf.SHT_PROGBITS,
+                .flags = elf.SHF_ALLOC | elf.SHF_EXECINSTR,
+                .addralign = 16,
+            });
+        }
+        if (self.rela_plt_section_index == null) {
+            self.rela_plt_section_index = try self.addSection(.{
+                .name = try self.insertShString(".rela.plt"),
+                .type = elf.SHT_RELA,
+                .flags = elf.SHF_ALLOC,
+                .addralign = @alignOf(elf.Elf64_Rela),
+                .entsize = @sizeOf(elf.Elf64_Rela),
+            });
+        }
     }
 
-    if (self.plt_got.symbols.items.len > 0) {
+    if (self.plt_got.symbols.items.len > 0 and self.plt_got_section_index == null) {
         self.plt_got_section_index = try self.addSection(.{
             .name = try self.insertShString(".plt.got"),
             .type = elf.SHT_PROGBITS,
             .flags = elf.SHF_ALLOC | elf.SHF_EXECINSTR,
             .addralign = 16,
-            .offset = std.math.maxInt(u64),
         });
     }
 
-    if (self.copy_rel.symbols.items.len > 0) {
+    if (self.copy_rel.symbols.items.len > 0 and self.copy_rel_section_index == null) {
         self.copy_rel_section_index = try self.addSection(.{
             .name = try self.insertShString(".copyrel"),
             .type = elf.SHT_NOBITS,
             .flags = elf.SHF_ALLOC | elf.SHF_WRITE,
-            .offset = std.math.maxInt(u64),
         });
     }
 
@@ -3017,78 +2959,84 @@ fn initSyntheticSections(self: *Elf) !void {
         if (self.base.isStatic() and !comp.config.pie) break :blk false;
         break :blk target.dynamic_linker.get() != null;
     };
-    if (needs_interp) {
+    if (needs_interp and self.interp_section_index == null) {
         self.interp_section_index = try self.addSection(.{
             .name = try self.insertShString(".interp"),
             .type = elf.SHT_PROGBITS,
             .flags = elf.SHF_ALLOC,
             .addralign = 1,
-            .offset = std.math.maxInt(u64),
         });
     }
 
     if (self.isEffectivelyDynLib() or self.shared_objects.items.len > 0 or comp.config.pie) {
-        self.dynstrtab_section_index = try self.addSection(.{
-            .name = try self.insertShString(".dynstr"),
-            .flags = elf.SHF_ALLOC,
-            .type = elf.SHT_STRTAB,
-            .entsize = 1,
-            .addralign = 1,
-            .offset = std.math.maxInt(u64),
-        });
-        self.dynamic_section_index = try self.addSection(.{
-            .name = try self.insertShString(".dynamic"),
-            .flags = elf.SHF_ALLOC | elf.SHF_WRITE,
-            .type = elf.SHT_DYNAMIC,
-            .entsize = @sizeOf(elf.Elf64_Dyn),
-            .addralign = @alignOf(elf.Elf64_Dyn),
-            .offset = std.math.maxInt(u64),
-        });
-        self.dynsymtab_section_index = try self.addSection(.{
-            .name = try self.insertShString(".dynsym"),
-            .flags = elf.SHF_ALLOC,
-            .type = elf.SHT_DYNSYM,
-            .addralign = @alignOf(elf.Elf64_Sym),
-            .entsize = @sizeOf(elf.Elf64_Sym),
-            .info = 1,
-            .offset = std.math.maxInt(u64),
-        });
-        self.hash_section_index = try self.addSection(.{
-            .name = try self.insertShString(".hash"),
-            .flags = elf.SHF_ALLOC,
-            .type = elf.SHT_HASH,
-            .addralign = 4,
-            .entsize = 4,
-            .offset = std.math.maxInt(u64),
-        });
-        self.gnu_hash_section_index = try self.addSection(.{
-            .name = try self.insertShString(".gnu.hash"),
-            .flags = elf.SHF_ALLOC,
-            .type = elf.SHT_GNU_HASH,
-            .addralign = 8,
-            .offset = std.math.maxInt(u64),
-        });
+        if (self.dynstrtab_section_index == null) {
+            self.dynstrtab_section_index = try self.addSection(.{
+                .name = try self.insertShString(".dynstr"),
+                .flags = elf.SHF_ALLOC,
+                .type = elf.SHT_STRTAB,
+                .entsize = 1,
+                .addralign = 1,
+            });
+        }
+        if (self.dynamic_section_index == null) {
+            self.dynamic_section_index = try self.addSection(.{
+                .name = try self.insertShString(".dynamic"),
+                .flags = elf.SHF_ALLOC | elf.SHF_WRITE,
+                .type = elf.SHT_DYNAMIC,
+                .entsize = @sizeOf(elf.Elf64_Dyn),
+                .addralign = @alignOf(elf.Elf64_Dyn),
+            });
+        }
+        if (self.dynsymtab_section_index == null) {
+            self.dynsymtab_section_index = try self.addSection(.{
+                .name = try self.insertShString(".dynsym"),
+                .flags = elf.SHF_ALLOC,
+                .type = elf.SHT_DYNSYM,
+                .addralign = @alignOf(elf.Elf64_Sym),
+                .entsize = @sizeOf(elf.Elf64_Sym),
+                .info = 1,
+            });
+        }
+        if (self.hash_section_index == null) {
+            self.hash_section_index = try self.addSection(.{
+                .name = try self.insertShString(".hash"),
+                .flags = elf.SHF_ALLOC,
+                .type = elf.SHT_HASH,
+                .addralign = 4,
+                .entsize = 4,
+            });
+        }
+        if (self.gnu_hash_section_index == null) {
+            self.gnu_hash_section_index = try self.addSection(.{
+                .name = try self.insertShString(".gnu.hash"),
+                .flags = elf.SHF_ALLOC,
+                .type = elf.SHT_GNU_HASH,
+                .addralign = 8,
+            });
+        }
 
         const needs_versions = for (self.dynsym.entries.items) |entry| {
             const sym = self.symbol(entry.ref).?;
             if (sym.flags.import and sym.version_index & elf.VERSYM_VERSION > elf.VER_NDX_GLOBAL) break true;
         } else false;
         if (needs_versions) {
-            self.versym_section_index = try self.addSection(.{
-                .name = try self.insertShString(".gnu.version"),
-                .flags = elf.SHF_ALLOC,
-                .type = elf.SHT_GNU_VERSYM,
-                .addralign = @alignOf(elf.Elf64_Versym),
-                .entsize = @sizeOf(elf.Elf64_Versym),
-                .offset = std.math.maxInt(u64),
-            });
-            self.verneed_section_index = try self.addSection(.{
-                .name = try self.insertShString(".gnu.version_r"),
-                .flags = elf.SHF_ALLOC,
-                .type = elf.SHT_GNU_VERNEED,
-                .addralign = @alignOf(elf.Elf64_Verneed),
-                .offset = std.math.maxInt(u64),
-            });
+            if (self.versym_section_index == null) {
+                self.versym_section_index = try self.addSection(.{
+                    .name = try self.insertShString(".gnu.version"),
+                    .flags = elf.SHF_ALLOC,
+                    .type = elf.SHT_GNU_VERSYM,
+                    .addralign = @alignOf(elf.Elf64_Versym),
+                    .entsize = @sizeOf(elf.Elf64_Versym),
+                });
+            }
+            if (self.verneed_section_index == null) {
+                self.verneed_section_index = try self.addSection(.{
+                    .name = try self.insertShString(".gnu.version_r"),
+                    .flags = elf.SHF_ALLOC,
+                    .type = elf.SHT_GNU_VERNEED,
+                    .addralign = @alignOf(elf.Elf64_Verneed),
+                });
+            }
         }
     }
 
@@ -3107,7 +3055,6 @@ pub fn initSymtab(self: *Elf) !void {
             .type = elf.SHT_SYMTAB,
             .addralign = if (small_ptr) @alignOf(elf.Elf32_Sym) else @alignOf(elf.Elf64_Sym),
             .entsize = if (small_ptr) @sizeOf(elf.Elf32_Sym) else @sizeOf(elf.Elf64_Sym),
-            .offset = std.math.maxInt(u64),
         });
     }
     if (self.strtab_section_index == null) {
@@ -3116,7 +3063,6 @@ pub fn initSymtab(self: *Elf) !void {
             .type = elf.SHT_STRTAB,
             .entsize = 1,
             .addralign = 1,
-            .offset = std.math.maxInt(u64),
         });
     }
 }
@@ -3128,7 +3074,6 @@ pub fn initShStrtab(self: *Elf) !void {
             .type = elf.SHT_STRTAB,
             .entsize = 1,
             .addralign = 1,
-            .offset = std.math.maxInt(u64),
         });
     }
 }
@@ -3136,36 +3081,38 @@ pub fn initShStrtab(self: *Elf) !void {
 fn initSpecialPhdrs(self: *Elf) !void {
     comptime assert(max_number_of_special_phdrs == 5);
 
-    if (self.interp_section_index != null) {
+    if (self.interp_section_index != null and self.phdr_interp_index == null) {
         self.phdr_interp_index = try self.addPhdr(.{
             .type = elf.PT_INTERP,
             .flags = elf.PF_R,
             .@"align" = 1,
         });
     }
-    if (self.dynamic_section_index != null) {
+    if (self.dynamic_section_index != null and self.phdr_dynamic_index == null) {
         self.phdr_dynamic_index = try self.addPhdr(.{
             .type = elf.PT_DYNAMIC,
             .flags = elf.PF_R | elf.PF_W,
         });
     }
-    if (self.eh_frame_hdr_section_index != null) {
+    if (self.eh_frame_hdr_section_index != null and self.phdr_gnu_eh_frame_index == null) {
         self.phdr_gnu_eh_frame_index = try self.addPhdr(.{
             .type = elf.PT_GNU_EH_FRAME,
             .flags = elf.PF_R,
         });
     }
-    self.phdr_gnu_stack_index = try self.addPhdr(.{
-        .type = elf.PT_GNU_STACK,
-        .flags = elf.PF_W | elf.PF_R,
-        .memsz = self.base.stack_size,
-        .@"align" = 1,
-    });
+    if (self.phdr_gnu_stack_index == null) {
+        self.phdr_gnu_stack_index = try self.addPhdr(.{
+            .type = elf.PT_GNU_STACK,
+            .flags = elf.PF_W | elf.PF_R,
+            .memsz = self.base.stack_size,
+            .@"align" = 1,
+        });
+    }
 
     const has_tls = for (self.sections.items(.shdr)) |shdr| {
         if (shdr.sh_flags & elf.SHF_TLS != 0) break true;
     } else false;
-    if (has_tls) {
+    if (has_tls and self.phdr_tls_index == null) {
         self.phdr_tls_index = try self.addPhdr(.{
             .type = elf.PT_TLS,
             .flags = elf.PF_R,
@@ -3207,7 +3154,7 @@ fn sortInitFini(self: *Elf) !void {
 
     for (slice.items(.shdr), slice.items(.atom_list_2)) |shdr, *atom_list| {
         if (shdr.sh_flags & elf.SHF_ALLOC == 0) continue;
-        if (atom_list.atoms.items.len == 0) continue;
+        if (atom_list.atoms.keys().len == 0) continue;
 
         var is_init_fini = false;
         var is_ctor_dtor = false;
@@ -3224,16 +3171,17 @@ fn sortInitFini(self: *Elf) !void {
         if (!is_init_fini and !is_ctor_dtor) continue;
 
         var entries = std.ArrayList(Entry).init(gpa);
-        try entries.ensureTotalCapacityPrecise(atom_list.atoms.items.len);
+        try entries.ensureTotalCapacityPrecise(atom_list.atoms.keys().len);
         defer entries.deinit();
 
-        for (atom_list.atoms.items) |ref| {
+        for (atom_list.atoms.keys()) |ref| {
             const atom_ptr = self.atom(ref).?;
             const object = atom_ptr.file(self).?.object;
             const priority = blk: {
                 if (is_ctor_dtor) {
-                    if (mem.indexOf(u8, object.path, "crtbegin") != null) break :blk std.math.minInt(i32);
-                    if (mem.indexOf(u8, object.path, "crtend") != null) break :blk std.math.maxInt(i32);
+                    const basename = object.path.basename();
+                    if (mem.eql(u8, basename, "crtbegin.o")) break :blk std.math.minInt(i32);
+                    if (mem.eql(u8, basename, "crtend.o")) break :blk std.math.maxInt(i32);
                 }
                 const default: i32 = if (is_ctor_dtor) -1 else std.math.maxInt(i32);
                 const name = atom_ptr.name(self);
@@ -3248,7 +3196,7 @@ fn sortInitFini(self: *Elf) !void {
 
         atom_list.atoms.clearRetainingCapacity();
         for (entries.items) |entry| {
-            atom_list.atoms.appendAssumeCapacity(entry.atom_ref);
+            _ = atom_list.atoms.getOrPutAssumeCapacity(entry.atom_ref);
         }
     }
 }
@@ -3494,7 +3442,7 @@ fn resetShdrIndexes(self: *Elf, backlinks: []const u32) void {
     const slice = self.sections.slice();
     for (slice.items(.shdr), slice.items(.atom_list_2)) |*shdr, *atom_list| {
         atom_list.output_section_index = backlinks[atom_list.output_section_index];
-        for (atom_list.atoms.items) |ref| {
+        for (atom_list.atoms.keys()) |ref| {
             self.atom(ref).?.output_section_index = atom_list.output_section_index;
         }
         if (shdr.sh_type == elf.SHT_RELA) {
@@ -3506,12 +3454,7 @@ fn resetShdrIndexes(self: *Elf, backlinks: []const u32) void {
         }
     }
 
-    if (self.zigObjectPtr()) |zo| {
-        for (zo.atoms_indexes.items) |atom_index| {
-            const atom_ptr = zo.atom(atom_index) orelse continue;
-            atom_ptr.output_section_index = backlinks[atom_ptr.output_section_index];
-        }
-    }
+    if (self.zigObjectPtr()) |zo| zo.resetShdrIndexes(backlinks);
 
     for (self.comdat_group_sections.items) |*cg| {
         cg.shndx = backlinks[cg.shndx];
@@ -3573,20 +3516,24 @@ fn resetShdrIndexes(self: *Elf, backlinks: []const u32) void {
 fn updateSectionSizes(self: *Elf) !void {
     const slice = self.sections.slice();
     for (slice.items(.shdr), slice.items(.atom_list_2)) |shdr, *atom_list| {
-        if (atom_list.atoms.items.len == 0) continue;
+        if (atom_list.atoms.keys().len == 0) continue;
+        if (!atom_list.dirty) continue;
         if (self.requiresThunks() and shdr.sh_flags & elf.SHF_EXECINSTR != 0) continue;
         atom_list.updateSize(self);
         try atom_list.allocate(self);
+        atom_list.dirty = false;
     }
 
     if (self.requiresThunks()) {
         for (slice.items(.shdr), slice.items(.atom_list_2)) |shdr, *atom_list| {
             if (shdr.sh_flags & elf.SHF_EXECINSTR == 0) continue;
-            if (atom_list.atoms.items.len == 0) continue;
+            if (atom_list.atoms.keys().len == 0) continue;
+            if (!atom_list.dirty) continue;
 
             // Create jump/branch range extenders if needed.
             try self.createThunks(atom_list);
             try atom_list.allocate(self);
+            atom_list.dirty = false;
         }
 
         // FIXME:JK this will hopefully not be needed once we create a link from Atom/Thunk to AtomList.
@@ -3704,27 +3651,19 @@ fn getMaxNumberOfPhdrs() u64 {
     return num;
 }
 
-/// Calculates how many segments (PT_LOAD progam headers) are required
-/// to cover the set of sections.
-/// We permit a maximum of 3**2 number of segments.
-fn calcNumberOfSegments(self: *Elf) usize {
-    var covers: [9]bool = [_]bool{false} ** 9;
+fn addLoadPhdrs(self: *Elf) error{OutOfMemory}!void {
     for (self.sections.items(.shdr)) |shdr| {
         if (shdr.sh_type == elf.SHT_NULL) continue;
         if (shdr.sh_flags & elf.SHF_ALLOC == 0) continue;
         const flags = shdrToPhdrFlags(shdr.sh_flags);
-        covers[flags - 1] = true;
-    }
-    var count: usize = 0;
-    for (covers) |cover| {
-        if (cover) count += 1;
+        if (self.getPhdr(.{ .flags = flags, .type = elf.PT_LOAD }) == null) {
+            _ = try self.addPhdr(.{ .flags = flags, .type = elf.PT_LOAD });
+        }
     }
-    return count;
 }
 
 /// Allocates PHDR table in virtual memory and in file.
 fn allocatePhdrTable(self: *Elf) error{OutOfMemory}!void {
-    const new_load_segments = self.calcNumberOfSegments();
     const phdr_table = &self.phdrs.items[self.phdr_table_index.?];
     const phdr_table_load = &self.phdrs.items[self.phdr_table_load_index.?];
 
@@ -3736,7 +3675,7 @@ fn allocatePhdrTable(self: *Elf) error{OutOfMemory}!void {
         .p32 => @sizeOf(elf.Elf32_Phdr),
         .p64 => @sizeOf(elf.Elf64_Phdr),
     };
-    const needed_size = (self.phdrs.items.len + new_load_segments) * phsize;
+    const needed_size = self.phdrs.items.len * phsize;
     const available_space = self.allocatedSize(phdr_table.p_offset);
 
     if (needed_size > available_space) {
@@ -3878,58 +3817,55 @@ pub fn allocateAllocSections(self: *Elf) !void {
         }
 
         const first = slice.items(.shdr)[cover.items[0]];
-        var new_offset = try self.findFreeSpace(filesz, @"align");
-        const phndx = try self.addPhdr(.{
-            .type = elf.PT_LOAD,
-            .offset = new_offset,
-            .addr = first.sh_addr,
-            .memsz = memsz,
-            .filesz = filesz,
-            .@"align" = @"align",
-            .flags = shdrToPhdrFlags(first.sh_flags),
-        });
+        const phndx = self.getPhdr(.{ .type = elf.PT_LOAD, .flags = shdrToPhdrFlags(first.sh_flags) }).?;
+        const phdr = &self.phdrs.items[phndx];
+        const allocated_size = self.allocatedSize(phdr.p_offset);
+        if (filesz > allocated_size) {
+            const old_offset = phdr.p_offset;
+            phdr.p_offset = 0;
+            var new_offset = try self.findFreeSpace(filesz, @"align");
+            phdr.p_offset = new_offset;
+
+            log.debug("moving phdr({d}) from 0x{x} to 0x{x}", .{ phndx, old_offset, new_offset });
+
+            for (cover.items) |shndx| {
+                const shdr = &slice.items(.shdr)[shndx];
+                slice.items(.phndx)[shndx] = phndx;
+                if (shdr.sh_type == elf.SHT_NOBITS) {
+                    shdr.sh_offset = 0;
+                    continue;
+                }
+                new_offset = alignment.@"align"(shndx, shdr.sh_addralign, new_offset);
 
-        for (cover.items) |shndx| {
-            const shdr = &slice.items(.shdr)[shndx];
-            slice.items(.phndx)[shndx] = phndx;
-            if (shdr.sh_type == elf.SHT_NOBITS) {
-                shdr.sh_offset = 0;
-                continue;
-            }
-            new_offset = alignment.@"align"(shndx, shdr.sh_addralign, new_offset);
-
-            if (self.zigObjectPtr()) |zo| blk: {
-                const existing_size = for ([_]?Symbol.Index{
-                    zo.text_index,
-                    zo.rodata_index,
-                    zo.data_relro_index,
-                    zo.data_index,
-                    zo.tdata_index,
-                    zo.eh_frame_index,
-                }) |maybe_sym_index| {
-                    const sect_sym_index = maybe_sym_index orelse continue;
-                    const sect_atom_ptr = zo.symbol(sect_sym_index).atom(self).?;
-                    if (sect_atom_ptr.output_section_index != shndx) continue;
-                    break sect_atom_ptr.size;
-                } else break :blk;
                 log.debug("moving {s} from 0x{x} to 0x{x}", .{
                     self.getShString(shdr.sh_name),
                     shdr.sh_offset,
                     new_offset,
                 });
-                const amt = try self.base.file.?.copyRangeAll(
-                    shdr.sh_offset,
-                    self.base.file.?,
-                    new_offset,
-                    existing_size,
-                );
-                if (amt != existing_size) return error.InputOutput;
-            }
 
-            shdr.sh_offset = new_offset;
-            new_offset += shdr.sh_size;
+                if (shdr.sh_offset > 0) {
+                    // Get size actually commited to the output file.
+                    const existing_size = self.sectionSize(shndx);
+                    const amt = try self.base.file.?.copyRangeAll(
+                        shdr.sh_offset,
+                        self.base.file.?,
+                        new_offset,
+                        existing_size,
+                    );
+                    if (amt != existing_size) return error.InputOutput;
+                }
+
+                shdr.sh_offset = new_offset;
+                new_offset += shdr.sh_size;
+            }
         }
 
+        phdr.p_vaddr = first.sh_addr;
+        phdr.p_paddr = first.sh_addr;
+        phdr.p_memsz = memsz;
+        phdr.p_filesz = filesz;
+        phdr.p_align = @"align";
+
         addr = mem.alignForward(u64, addr, self.page_size);
     }
 }
@@ -3944,27 +3880,14 @@ pub fn allocateNonAllocSections(self: *Elf) !void {
             shdr.sh_size = 0;
             const new_offset = try self.findFreeSpace(needed_size, shdr.sh_addralign);
 
-            if (self.zigObjectPtr()) |zo| blk: {
-                const existing_size = for ([_]?Symbol.Index{
-                    zo.debug_info_index,
-                    zo.debug_abbrev_index,
-                    zo.debug_aranges_index,
-                    zo.debug_str_index,
-                    zo.debug_line_index,
-                    zo.debug_line_str_index,
-                    zo.debug_loclists_index,
-                    zo.debug_rnglists_index,
-                }) |maybe_sym_index| {
-                    const sym_index = maybe_sym_index orelse continue;
-                    const sym = zo.symbol(sym_index);
-                    const atom_ptr = sym.atom(self).?;
-                    if (atom_ptr.output_section_index == shndx) break atom_ptr.size;
-                } else break :blk;
-                log.debug("moving {s} from 0x{x} to 0x{x}", .{
-                    self.getShString(shdr.sh_name),
-                    shdr.sh_offset,
-                    new_offset,
-                });
+            log.debug("moving {s} from 0x{x} to 0x{x}", .{
+                self.getShString(shdr.sh_name),
+                shdr.sh_offset,
+                new_offset,
+            });
+
+            if (shdr.sh_offset > 0) {
+                const existing_size = self.sectionSize(@intCast(shndx));
                 const amt = try self.base.file.?.copyRangeAll(
                     shdr.sh_offset,
                     self.base.file.?,
@@ -4055,7 +3978,7 @@ fn writeAtoms(self: *Elf) !void {
     var has_reloc_errors = false;
     for (slice.items(.shdr), slice.items(.atom_list_2)) |shdr, atom_list| {
         if (shdr.sh_type == elf.SHT_NOBITS) continue;
-        if (atom_list.atoms.items.len == 0) continue;
+        if (atom_list.atoms.keys().len == 0) continue;
         atom_list.write(&buffer, &undefs, self) catch |err| switch (err) {
             error.UnsupportedCpuArch => {
                 try self.reportUnsupportedCpuArch();
@@ -4102,6 +4025,7 @@ pub fn updateSymtabSize(self: *Elf) !void {
     nlocals += @intCast(self.sections.slice().len);
 
     if (self.requiresThunks()) for (self.thunks.items) |*th| {
+        th.output_symtab_ctx.reset();
         th.output_symtab_ctx.ilocal = nlocals;
         th.calcSymtabSize(self);
         nlocals += th.output_symtab_ctx.nlocals;
@@ -4113,6 +4037,7 @@ pub fn updateSymtabSize(self: *Elf) !void {
         const ctx = switch (file_ptr) {
             inline else => |x| &x.output_symtab_ctx,
         };
+        ctx.reset();
         ctx.ilocal = nlocals;
         ctx.iglobal = nglobals;
         try file_ptr.updateSymtabSize(self);
@@ -4122,6 +4047,7 @@ pub fn updateSymtabSize(self: *Elf) !void {
     }
 
     if (self.got_section_index) |_| {
+        self.got.output_symtab_ctx.reset();
         self.got.output_symtab_ctx.ilocal = nlocals;
         self.got.updateSymtabSize(self);
         nlocals += self.got.output_symtab_ctx.nlocals;
@@ -4129,6 +4055,7 @@ pub fn updateSymtabSize(self: *Elf) !void {
     }
 
     if (self.plt_section_index) |_| {
+        self.plt.output_symtab_ctx.reset();
         self.plt.output_symtab_ctx.ilocal = nlocals;
         self.plt.updateSymtabSize(self);
         nlocals += self.plt.output_symtab_ctx.nlocals;
@@ -4136,6 +4063,7 @@ pub fn updateSymtabSize(self: *Elf) !void {
     }
 
     if (self.plt_got_section_index) |_| {
+        self.plt_got.output_symtab_ctx.reset();
         self.plt_got.output_symtab_ctx.ilocal = nlocals;
         self.plt_got.updateSymtabSize(self);
         nlocals += self.plt_got.output_symtab_ctx.nlocals;
@@ -4334,6 +4262,9 @@ pub fn writeSymtab(self: *Elf) !void {
 
     try self.symtab.resize(gpa, nsyms);
     const needed_strtab_size = math.cast(usize, strtab_shdr.sh_size - 1) orelse return error.Overflow;
+    // TODO we could resize instead and in ZigObject/Object always access as slice
+    self.strtab.clearRetainingCapacity();
+    self.strtab.appendAssumeCapacity(0);
     try self.strtab.ensureUnusedCapacity(gpa, needed_strtab_size);
 
     for (slice.items(.shdr), 0..) |shdr, shndx| {
@@ -4455,255 +4386,89 @@ fn shdrTo32(shdr: elf.Elf64_Shdr) elf.Elf32_Shdr {
 }
 
 fn getLDMOption(target: std.Target) ?[]const u8 {
-    switch (target.cpu.arch) {
-        .x86 => return "elf_i386",
-        .aarch64 => return "aarch64linux",
-        .aarch64_be => return "aarch64linuxb",
-        .arm, .thumb => return "armelf_linux_eabi",
-        .armeb, .thumbeb => return "armelfb_linux_eabi",
-        .powerpc => return "elf32ppclinux",
-        .powerpc64 => return "elf64ppc",
-        .powerpc64le => return "elf64lppc",
-        .sparc => return "elf32_sparc",
-        .sparc64 => return "elf64_sparc",
-        .mips => return "elf32btsmip",
-        .mipsel => return "elf32ltsmip",
-        .mips64 => {
-            if (target.abi == .gnuabin32) {
-                return "elf32btsmipn32";
-            } else {
-                return "elf64btsmip";
-            }
+    // This should only return emulations understood by LLD's parseEmulation().
+    return switch (target.cpu.arch) {
+        .aarch64 => switch (target.os.tag) {
+            .linux => "aarch64linux",
+            else => "aarch64elf",
         },
-        .mips64el => {
-            if (target.abi == .gnuabin32) {
-                return "elf32ltsmipn32";
-            } else {
-                return "elf64ltsmip";
-            }
+        .aarch64_be => switch (target.os.tag) {
+            .linux => "aarch64linuxb",
+            else => "aarch64elfb",
         },
-        .s390x => return "elf64_s390",
-        .x86_64 => {
-            if (target.abi == .gnux32) {
-                return "elf32_x86_64";
-            } else {
-                return "elf_x86_64";
-            }
+        .amdgcn => "elf64_amdgpu",
+        .arm, .thumb => switch (target.os.tag) {
+            .linux => "armelf_linux_eabi",
+            else => "armelf",
         },
-        .riscv32 => return "elf32lriscv",
-        .riscv64 => return "elf64lriscv",
-        else => return null,
-    }
+        .armeb, .thumbeb => switch (target.os.tag) {
+            .linux => "armelfb_linux_eabi",
+            else => "armelfb",
+        },
+        .hexagon => "hexagonelf",
+        .loongarch32 => "elf32loongarch",
+        .loongarch64 => "elf64loongarch",
+        .mips => switch (target.os.tag) {
+            .freebsd => "elf32btsmip_fbsd",
+            else => "elf32btsmip",
+        },
+        .mipsel => switch (target.os.tag) {
+            .freebsd => "elf32ltsmip_fbsd",
+            else => "elf32ltsmip",
+        },
+        .mips64 => switch (target.os.tag) {
+            .freebsd => switch (target.abi) {
+                .gnuabin32 => "elf32btsmipn32_fbsd",
+                else => "elf64btsmip_fbsd",
+            },
+            else => switch (target.abi) {
+                .gnuabin32 => "elf32btsmipn32",
+                else => "elf64btsmip",
+            },
+        },
+        .mips64el => switch (target.os.tag) {
+            .freebsd => switch (target.abi) {
+                .gnuabin32 => "elf32ltsmipn32_fbsd",
+                else => "elf64ltsmip_fbsd",
+            },
+            else => switch (target.abi) {
+                .gnuabin32 => "elf32ltsmipn32",
+                else => "elf64ltsmip",
+            },
+        },
+        .msp430 => "msp430elf",
+        .powerpc => switch (target.os.tag) {
+            .freebsd => "elf32ppc_fbsd",
+            .linux => "elf32ppclinux",
+            else => "elf32ppc",
+        },
+        .powerpcle => switch (target.os.tag) {
+            .linux => "elf32lppclinux",
+            else => "elf32lppc",
+        },
+        .powerpc64 => "elf64ppc",
+        .powerpc64le => "elf64lppc",
+        .riscv32 => "elf32lriscv",
+        .riscv64 => "elf64lriscv",
+        .s390x => "elf64_s390",
+        .sparc64 => "elf64_sparc",
+        .x86 => switch (target.os.tag) {
+            .elfiamcu => "elf_iamcu",
+            .freebsd => "elf_i386_fbsd",
+            else => "elf_i386",
+        },
+        .x86_64 => switch (target.abi) {
+            .gnux32, .muslx32 => "elf32_x86_64",
+            else => "elf_x86_64",
+        },
+        else => null,
+    };
 }
 
 pub fn padToIdeal(actual_size: anytype) @TypeOf(actual_size) {
     return actual_size +| (actual_size / ideal_factor);
 }
 
-// Provide a blueprint of csu (c-runtime startup) objects for supported
-// link modes.
-//
-// This is for cross-mode targets only. For host-mode targets the system
-// compiler can be probed to produce a robust blueprint.
-//
-// Targets requiring a libc for which zig does not bundle a libc are
-// host-mode targets. Unfortunately, host-mode probes are not yet
-// implemented. For now the data is hard-coded here. Such targets are
-// { freebsd, netbsd, openbsd, dragonfly }.
-const CsuObjects = struct {
-    crt0: ?[]const u8 = null,
-    crti: ?[]const u8 = null,
-    crtbegin: ?[]const u8 = null,
-    crtend: ?[]const u8 = null,
-    crtn: ?[]const u8 = null,
-
-    const InitArgs = struct {};
-
-    fn init(arena: Allocator, comp: *const Compilation) !CsuObjects {
-        // crt objects are only required for libc.
-        if (!comp.config.link_libc) return .{};
-
-        var result: CsuObjects = .{};
-
-        // Flatten crt cases.
-        const mode: enum {
-            dynamic_lib,
-            dynamic_exe,
-            dynamic_pie,
-            static_exe,
-            static_pie,
-        } = switch (comp.config.output_mode) {
-            .Obj => return CsuObjects{},
-            .Lib => switch (comp.config.link_mode) {
-                .dynamic => .dynamic_lib,
-                .static => return CsuObjects{},
-            },
-            .Exe => switch (comp.config.link_mode) {
-                .dynamic => if (comp.config.pie) .dynamic_pie else .dynamic_exe,
-                .static => if (comp.config.pie) .static_pie else .static_exe,
-            },
-        };
-
-        const target = comp.root_mod.resolved_target.result;
-
-        if (target.isAndroid()) {
-            switch (mode) {
-                // zig fmt: off
-                .dynamic_lib => result.set( null, null, "crtbegin_so.o",      "crtend_so.o",      null ),
-                .dynamic_exe,
-                .dynamic_pie => result.set( null, null, "crtbegin_dynamic.o", "crtend_android.o", null ),
-                .static_exe,
-                .static_pie  => result.set( null, null, "crtbegin_static.o",  "crtend_android.o", null ),
-                // zig fmt: on
-            }
-        } else {
-            switch (target.os.tag) {
-                .linux => {
-                    switch (mode) {
-                        // zig fmt: off
-                        .dynamic_lib => result.set( null,      "crti.o", "crtbeginS.o", "crtendS.o", "crtn.o" ),
-                        .dynamic_exe => result.set( "crt1.o",  "crti.o", "crtbegin.o",  "crtend.o",  "crtn.o" ),
-                        .dynamic_pie => result.set( "Scrt1.o", "crti.o", "crtbeginS.o", "crtendS.o", "crtn.o" ),
-                        .static_exe  => result.set( "crt1.o",  "crti.o", "crtbeginT.o", "crtend.o",  "crtn.o" ),
-                        .static_pie  => result.set( "rcrt1.o", "crti.o", "crtbeginS.o", "crtendS.o", "crtn.o" ),
-                        // zig fmt: on
-                    }
-                    if (comp.libc_installation) |_| {
-                        // hosted-glibc provides crtbegin/end objects in platform/compiler-specific dirs
-                        // and they are not known at comptime. For now null-out crtbegin/end objects;
-                        // there is no feature loss, zig has never linked those objects in before.
-                        result.crtbegin = null;
-                        result.crtend = null;
-                    } else {
-                        // Bundled glibc only has Scrt1.o .
-                        if (result.crt0 != null and target.isGnuLibC()) result.crt0 = "Scrt1.o";
-                    }
-                },
-                .dragonfly => switch (mode) {
-                    // zig fmt: off
-                    .dynamic_lib => result.set( null,      "crti.o", "crtbeginS.o",  "crtendS.o", "crtn.o" ),
-                    .dynamic_exe => result.set( "crt1.o",  "crti.o", "crtbegin.o",   "crtend.o",  "crtn.o" ),
-                    .dynamic_pie => result.set( "Scrt1.o", "crti.o", "crtbeginS.o",  "crtendS.o", "crtn.o" ),
-                    .static_exe  => result.set( "crt1.o",  "crti.o", "crtbegin.o",   "crtend.o",  "crtn.o" ),
-                    .static_pie  => result.set( "Scrt1.o", "crti.o", "crtbeginS.o",  "crtendS.o", "crtn.o" ),
-                    // zig fmt: on
-                },
-                .freebsd => switch (mode) {
-                    // zig fmt: off
-                    .dynamic_lib => result.set( null,      "crti.o", "crtbeginS.o", "crtendS.o", "crtn.o" ),
-                    .dynamic_exe => result.set( "crt1.o",  "crti.o", "crtbegin.o",  "crtend.o",  "crtn.o" ),
-                    .dynamic_pie => result.set( "Scrt1.o", "crti.o", "crtbeginS.o", "crtendS.o", "crtn.o" ),
-                    .static_exe  => result.set( "crt1.o",  "crti.o", "crtbeginT.o", "crtend.o",  "crtn.o" ),
-                    .static_pie  => result.set( "Scrt1.o", "crti.o", "crtbeginS.o", "crtendS.o", "crtn.o" ),
-                    // zig fmt: on
-                },
-                .netbsd => switch (mode) {
-                    // zig fmt: off
-                    .dynamic_lib => result.set( null,     "crti.o", "crtbeginS.o", "crtendS.o", "crtn.o" ),
-                    .dynamic_exe => result.set( "crt0.o", "crti.o", "crtbegin.o",  "crtend.o",  "crtn.o" ),
-                    .dynamic_pie => result.set( "crt0.o", "crti.o", "crtbeginS.o", "crtendS.o", "crtn.o" ),
-                    .static_exe  => result.set( "crt0.o", "crti.o", "crtbeginT.o", "crtend.o",  "crtn.o" ),
-                    .static_pie  => result.set( "crt0.o", "crti.o", "crtbeginT.o", "crtendS.o", "crtn.o" ),
-                    // zig fmt: on
-                },
-                .openbsd => switch (mode) {
-                    // zig fmt: off
-                    .dynamic_lib => result.set( null,      null, "crtbeginS.o", "crtendS.o", null ),
-                    .dynamic_exe,
-                    .dynamic_pie => result.set( "crt0.o",  null, "crtbegin.o",  "crtend.o",  null ),
-                    .static_exe,
-                    .static_pie  => result.set( "rcrt0.o", null, "crtbegin.o",  "crtend.o",  null ),
-                    // zig fmt: on
-                },
-                .haiku => switch (mode) {
-                    // zig fmt: off
-                    .dynamic_lib => result.set( null,          "crti.o", "crtbeginS.o", "crtendS.o", "crtn.o" ),
-                    .dynamic_exe => result.set( "start_dyn.o", "crti.o", "crtbegin.o",  "crtend.o",  "crtn.o" ),
-                    .dynamic_pie => result.set( "start_dyn.o", "crti.o", "crtbeginS.o", "crtendS.o", "crtn.o" ),
-                    .static_exe  => result.set( "start_dyn.o", "crti.o", "crtbegin.o",  "crtend.o",  "crtn.o" ),
-                    .static_pie  => result.set( "start_dyn.o", "crti.o", "crtbeginS.o", "crtendS.o", "crtn.o" ),
-                    // zig fmt: on
-                },
-                .solaris, .illumos => switch (mode) {
-                    // zig fmt: off
-                    .dynamic_lib => result.set( null,     "crti.o", null, null, "crtn.o" ),
-                    .dynamic_exe,
-                    .dynamic_pie => result.set( "crt1.o", "crti.o", null, null, "crtn.o" ),
-                    .static_exe,
-                    .static_pie  => result.set( null,     null,     null, null, null     ),
-                    // zig fmt: on
-                },
-                else => {},
-            }
-        }
-
-        // Convert each object to a full pathname.
-        if (comp.libc_installation) |lci| {
-            const crt_dir_path = lci.crt_dir orelse return error.LibCInstallationMissingCRTDir;
-            switch (target.os.tag) {
-                .dragonfly => {
-                    if (result.crt0) |*obj| obj.* = try fs.path.join(arena, &[_][]const u8{ crt_dir_path, obj.* });
-                    if (result.crti) |*obj| obj.* = try fs.path.join(arena, &[_][]const u8{ crt_dir_path, obj.* });
-                    if (result.crtn) |*obj| obj.* = try fs.path.join(arena, &[_][]const u8{ crt_dir_path, obj.* });
-
-                    var gccv: []const u8 = undefined;
-                    if (target.os.version_range.semver.isAtLeast(.{ .major = 5, .minor = 4, .patch = 0 }) orelse true) {
-                        gccv = "gcc80";
-                    } else {
-                        gccv = "gcc54";
-                    }
-
-                    if (result.crtbegin) |*obj| obj.* = try fs.path.join(arena, &[_][]const u8{ crt_dir_path, gccv, obj.* });
-                    if (result.crtend) |*obj| obj.* = try fs.path.join(arena, &[_][]const u8{ crt_dir_path, gccv, obj.* });
-                },
-                .haiku => {
-                    const gcc_dir_path = lci.gcc_dir orelse return error.LibCInstallationMissingCRTDir;
-                    if (result.crt0) |*obj| obj.* = try fs.path.join(arena, &[_][]const u8{ crt_dir_path, obj.* });
-                    if (result.crti) |*obj| obj.* = try fs.path.join(arena, &[_][]const u8{ crt_dir_path, obj.* });
-                    if (result.crtn) |*obj| obj.* = try fs.path.join(arena, &[_][]const u8{ crt_dir_path, obj.* });
-
-                    if (result.crtbegin) |*obj| obj.* = try fs.path.join(arena, &[_][]const u8{ gcc_dir_path, obj.* });
-                    if (result.crtend) |*obj| obj.* = try fs.path.join(arena, &[_][]const u8{ gcc_dir_path, obj.* });
-                },
-                else => {
-                    inline for (std.meta.fields(@TypeOf(result))) |f| {
-                        if (@field(result, f.name)) |*obj| {
-                            obj.* = try fs.path.join(arena, &[_][]const u8{ crt_dir_path, obj.* });
-                        }
-                    }
-                },
-            }
-        } else {
-            inline for (std.meta.fields(@TypeOf(result))) |f| {
-                if (@field(result, f.name)) |*obj| {
-                    if (comp.crt_files.get(obj.*)) |crtf| {
-                        obj.* = crtf.full_object_path;
-                    } else {
-                        @field(result, f.name) = null;
-                    }
-                }
-            }
-        }
-
-        return result;
-    }
-
-    fn set(
-        self: *CsuObjects,
-        crt0: ?[]const u8,
-        crti: ?[]const u8,
-        crtbegin: ?[]const u8,
-        crtend: ?[]const u8,
-        crtn: ?[]const u8,
-    ) void {
-        self.crt0 = crt0;
-        self.crti = crti;
-        self.crtbegin = crtbegin;
-        self.crtend = crtend;
-        self.crtn = crtn;
-    }
-};
-
 /// If a target compiles other output modes as dynamic libraries,
 /// this function returns true for those too.
 pub fn isEffectivelyDynLib(self: Elf) bool {
@@ -4714,7 +4479,20 @@ pub fn isEffectivelyDynLib(self: Elf) bool {
     };
 }
 
-pub fn addPhdr(self: *Elf, opts: struct {
+fn getPhdr(self: *Elf, opts: struct {
+    type: u32 = 0,
+    flags: u32 = 0,
+}) ?u16 {
+    for (self.phdrs.items, 0..) |phdr, phndx| {
+        if (self.phdr_table_load_index) |index| {
+            if (phndx == index) continue;
+        }
+        if (phdr.p_type == opts.type and phdr.p_flags == opts.flags) return @intCast(phndx);
+    }
+    return null;
+}
+
+fn addPhdr(self: *Elf, opts: struct {
     type: u32 = 0,
     flags: u32 = 0,
     @"align": u64 = 0,
@@ -4754,7 +4532,6 @@ pub fn addRelaShdr(self: *Elf, name: u32, shndx: u32) !u32 {
         .entsize = entsize,
         .info = shndx,
         .addralign = addralign,
-        .offset = std.math.maxInt(u64),
     });
 }
 
@@ -4766,7 +4543,6 @@ pub const AddSectionOpts = struct {
     info: u32 = 0,
     addralign: u64 = 0,
     entsize: u64 = 0,
-    offset: u64 = 0,
 };
 
 pub fn addSection(self: *Elf, opts: AddSectionOpts) !u32 {
@@ -4778,7 +4554,7 @@ pub fn addSection(self: *Elf, opts: AddSectionOpts) !u32 {
             .sh_type = opts.type,
             .sh_flags = opts.flags,
             .sh_addr = 0,
-            .sh_offset = opts.offset,
+            .sh_offset = 0,
             .sh_size = 0,
             .sh_link = opts.link,
             .sh_info = opts.info,
@@ -4801,6 +4577,7 @@ const RelaDyn = struct {
     sym: u64 = 0,
     type: u32,
     addend: i64 = 0,
+    target: ?*const Symbol = null,
 };
 
 pub fn addRelaDyn(self: *Elf, opts: RelaDyn) !void {
@@ -4809,6 +4586,13 @@ pub fn addRelaDyn(self: *Elf, opts: RelaDyn) !void {
 }
 
 pub fn addRelaDynAssumeCapacity(self: *Elf, opts: RelaDyn) void {
+    relocs_log.debug("  {s}: [{x} => {d}({s})] + {x}", .{
+        relocation.fmtRelocType(opts.type, self.getTarget().cpu.arch),
+        opts.offset,
+        opts.sym,
+        if (opts.target) |sym| sym.name(self) else "",
+        opts.addend,
+    });
     self.rela_dyn.appendAssumeCapacity(.{
         .r_offset = opts.offset,
         .r_info = (opts.sym << 32) | opts.type,
@@ -5096,18 +4880,18 @@ fn reportUnsupportedCpuArch(self: *Elf) error{OutOfMemory}!void {
     });
 }
 
-pub fn reportParseError(
+pub fn addParseError(
     self: *Elf,
-    path: []const u8,
+    path: Path,
     comptime format: []const u8,
     args: anytype,
 ) error{OutOfMemory}!void {
     var err = try self.base.addErrorWithNotes(1);
     try err.addMsg(format, args);
-    try err.addNote("while parsing {s}", .{path});
+    try err.addNote("while parsing {}", .{path});
 }
 
-pub fn reportParseError2(
+pub fn addFileError(
     self: *Elf,
     file_index: File.Index,
     comptime format: []const u8,
@@ -5118,6 +4902,26 @@ pub fn reportParseError2(
     try err.addNote("while parsing {}", .{self.file(file_index).?.fmtPath()});
 }
 
+pub fn failFile(
+    self: *Elf,
+    file_index: File.Index,
+    comptime format: []const u8,
+    args: anytype,
+) error{ OutOfMemory, LinkFailure } {
+    try addFileError(self, file_index, format, args);
+    return error.LinkFailure;
+}
+
+pub fn failParse(
+    self: *Elf,
+    path: Path,
+    comptime format: []const u8,
+    args: anytype,
+) error{ OutOfMemory, LinkFailure } {
+    try addParseError(self, path, format, args);
+    return error.LinkFailure;
+}
+
 const FormatShdrCtx = struct {
     elf_file: *Elf,
     shdr: elf.Elf64_Shdr,
@@ -5263,7 +5067,7 @@ fn fmtDumpState(
     _ = options;
 
     if (self.zigObjectPtr()) |zig_object| {
-        try writer.print("zig_object({d}) : {s}\n", .{ zig_object.index, zig_object.path });
+        try writer.print("zig_object({d}) : {s}\n", .{ zig_object.index, zig_object.basename });
         try writer.print("{}{}", .{
             zig_object.fmtAtoms(self),
             zig_object.fmtSymtab(self),
@@ -5288,7 +5092,7 @@ fn fmtDumpState(
     for (self.shared_objects.items) |index| {
         const shared_object = self.file(index).?.shared_object;
         try writer.print("shared_object({d}) : ", .{index});
-        try writer.print("{s}", .{shared_object.path});
+        try writer.print("{}", .{shared_object.path});
         try writer.print(" : needed({})", .{shared_object.needed});
         if (!shared_object.alive) try writer.writeAll(" : [*]");
         try writer.writeByte('\n');
@@ -5305,7 +5109,7 @@ fn fmtDumpState(
     {
         try writer.writeAll("atom lists\n");
         for (slice.items(.shdr), slice.items(.atom_list_2), 0..) |shdr, atom_list, shndx| {
-            try writer.print("shdr({d}) : {s} : {}", .{ shndx, self.getShString(shdr.sh_name), atom_list.fmt(self) });
+            try writer.print("shdr({d}) : {s} : {}\n", .{ shndx, self.getShString(shdr.sh_name), atom_list.fmt(self) });
         }
     }
 
@@ -5437,6 +5241,14 @@ pub const SymtabCtx = struct {
     nlocals: u32 = 0,
     nglobals: u32 = 0,
     strsize: u32 = 0,
+
+    pub fn reset(ctx: *SymtabCtx) void {
+        ctx.ilocal = 0;
+        ctx.iglobal = 0;
+        ctx.nlocals = 0;
+        ctx.nglobals = 0;
+        ctx.strsize = 0;
+    }
 };
 
 pub const null_sym = elf.Elf64_Sym{
@@ -5463,7 +5275,7 @@ pub const null_shdr = elf.Elf64_Shdr{
 
 pub const SystemLib = struct {
     needed: bool = false,
-    path: []const u8,
+    path: Path,
 };
 
 pub const Ref = struct {
@@ -5613,6 +5425,12 @@ const Section = struct {
     free_list: std.ArrayListUnmanaged(Ref) = .empty,
 };
 
+pub fn sectionSize(self: *Elf, shndx: u32) u64 {
+    const last_atom_ref = self.sections.items(.last_atom)[shndx];
+    const atom_ptr = self.atom(last_atom_ref) orelse return 0;
+    return @as(u64, @intCast(atom_ptr.value)) + atom_ptr.size;
+}
+
 fn defaultEntrySymbolName(cpu_arch: std.Target.Cpu.Arch) []const u8 {
     return switch (cpu_arch) {
         .mips, .mipsel, .mips64, .mips64el => "__start",
@@ -5642,20 +5460,20 @@ fn createThunks(elf_file: *Elf, atom_list: *AtomList) !void {
         }
     }.advance;
 
-    for (atom_list.atoms.items) |ref| {
+    for (atom_list.atoms.keys()) |ref| {
         elf_file.atom(ref).?.value = -1;
     }
 
     var i: usize = 0;
-    while (i < atom_list.atoms.items.len) {
+    while (i < atom_list.atoms.keys().len) {
         const start = i;
-        const start_atom = elf_file.atom(atom_list.atoms.items[start]).?;
+        const start_atom = elf_file.atom(atom_list.atoms.keys()[start]).?;
         assert(start_atom.alive);
         start_atom.value = try advance(atom_list, start_atom.size, start_atom.alignment);
         i += 1;
 
-        while (i < atom_list.atoms.items.len) : (i += 1) {
-            const atom_ptr = elf_file.atom(atom_list.atoms.items[i]).?;
+        while (i < atom_list.atoms.keys().len) : (i += 1) {
+            const atom_ptr = elf_file.atom(atom_list.atoms.keys()[i]).?;
             assert(atom_ptr.alive);
             if (@as(i64, @intCast(atom_ptr.alignment.forward(atom_list.size))) - start_atom.value >= max_distance)
                 break;
@@ -5668,7 +5486,7 @@ fn createThunks(elf_file: *Elf, atom_list: *AtomList) !void {
         thunk_ptr.output_section_index = atom_list.output_section_index;
 
         // Scan relocs in the group and create trampolines for any unreachable callsite
-        for (atom_list.atoms.items[start..i]) |ref| {
+        for (atom_list.atoms.keys()[start..i]) |ref| {
             const atom_ptr = elf_file.atom(ref).?;
             const file_ptr = atom_ptr.file(elf_file).?;
             log.debug("atom({}) {s}", .{ ref, atom_ptr.name(elf_file) });
@@ -5711,6 +5529,7 @@ const assert = std.debug.assert;
 const elf = std.elf;
 const fs = std.fs;
 const log = std.log.scoped(.link);
+const relocs_log = std.log.scoped(.link_relocs);
 const state_log = std.log.scoped(.link_state);
 const math = std.math;
 const mem = std.mem;
diff --git a/zig/src/link/Elf/Archive.zig b/zig/src/link/Elf/Archive.zig
index 8a97161034..7cc454f10c 100644
--- a/zig/src/link/Elf/Archive.zig
+++ b/zig/src/link/Elf/Archive.zig
@@ -1,8 +1,8 @@
 objects: std.ArrayListUnmanaged(Object) = .empty,
 strtab: std.ArrayListUnmanaged(u8) = .empty,
 
-pub fn isArchive(path: []const u8) !bool {
-    const file = try std.fs.cwd().openFile(path, .{});
+pub fn isArchive(path: Path) !bool {
+    const file = try path.root_dir.handle.openFile(path.sub_path, .{});
     defer file.close();
     const reader = file.reader();
     const magic = reader.readBytesNoEof(elf.ARMAG.len) catch return false;
@@ -15,7 +15,7 @@ pub fn deinit(self: *Archive, allocator: Allocator) void {
     self.strtab.deinit(allocator);
 }
 
-pub fn parse(self: *Archive, elf_file: *Elf, path: []const u8, handle_index: File.HandleIndex) !void {
+pub fn parse(self: *Archive, elf_file: *Elf, path: Path, handle_index: File.HandleIndex) !void {
     const comp = elf_file.base.comp;
     const gpa = comp.gpa;
     const handle = elf_file.fileHandle(handle_index);
@@ -35,10 +35,9 @@ pub fn parse(self: *Archive, elf_file: *Elf, path: []const u8, handle_index: Fil
         pos += @sizeOf(elf.ar_hdr);
 
         if (!mem.eql(u8, &hdr.ar_fmag, elf.ARFMAG)) {
-            try elf_file.reportParseError(path, "invalid archive header delimiter: {s}", .{
+            return elf_file.failParse(path, "invalid archive header delimiter: {s}", .{
                 std.fmt.fmtSliceEscapeLower(&hdr.ar_fmag),
             });
-            return error.MalformedArchive;
         }
 
         const obj_size = try hdr.size();
@@ -60,19 +59,24 @@ pub fn parse(self: *Archive, elf_file: *Elf, path: []const u8, handle_index: Fil
         else
             unreachable;
 
-        const object = Object{
+        const object: Object = .{
             .archive = .{
-                .path = try gpa.dupe(u8, path),
+                .path = .{
+                    .root_dir = path.root_dir,
+                    .sub_path = try gpa.dupe(u8, path.sub_path),
+                },
                 .offset = pos,
                 .size = obj_size,
             },
-            .path = try gpa.dupe(u8, name),
+            .path = Path.initCwd(try gpa.dupe(u8, name)),
             .file_handle = handle_index,
             .index = undefined,
             .alive = false,
         };
 
-        log.debug("extracting object '{s}' from archive '{s}'", .{ object.path, path });
+        log.debug("extracting object '{}' from archive '{}'", .{
+            @as(Path, object.path), @as(Path, path),
+        });
 
         try self.objects.append(gpa, object);
     }
@@ -293,6 +297,7 @@ const elf = std.elf;
 const fs = std.fs;
 const log = std.log.scoped(.link);
 const mem = std.mem;
+const Path = std.Build.Cache.Path;
 
 const Allocator = mem.Allocator;
 const Archive = @This();
diff --git a/zig/src/link/Elf/Atom.zig b/zig/src/link/Elf/Atom.zig
index ab0e98440b..20aa249ea5 100644
--- a/zig/src/link/Elf/Atom.zig
+++ b/zig/src/link/Elf/Atom.zig
@@ -118,10 +118,19 @@ pub fn capacity(self: Atom, elf_file: *Elf) u64 {
     return @intCast(next_addr - self.address(elf_file));
 }
 
+pub fn fileCapacity(self: Atom, elf_file: *Elf) u64 {
+    const self_off = self.offset(elf_file);
+    const next_off = if (self.nextAtom(elf_file)) |next_atom|
+        next_atom.offset(elf_file)
+    else
+        self_off + elf_file.allocatedSize(self_off);
+    return @intCast(next_off - self_off);
+}
+
 pub fn freeListEligible(self: Atom, elf_file: *Elf) bool {
     // No need to keep a free list node for the last block.
     const next = self.nextAtom(elf_file) orelse return false;
-    const cap: u64 = @intCast(next.address(elf_file) - self.address(elf_file));
+    const cap: u64 = @intCast(next.value - self.value);
     const ideal_cap = Elf.padToIdeal(self.size);
     if (cap <= ideal_cap) return false;
     const surplus = cap - ideal_cap;
@@ -723,6 +732,7 @@ fn resolveDynAbsReloc(
                     .sym = target.extra(elf_file).dynamic,
                     .type = relocation.encode(.abs, cpu_arch),
                     .addend = A,
+                    .target = target,
                 });
                 try applyDynamicReloc(A, elf_file, writer);
             } else {
@@ -737,6 +747,7 @@ fn resolveDynAbsReloc(
                     .sym = target.extra(elf_file).dynamic,
                     .type = relocation.encode(.abs, cpu_arch),
                     .addend = A,
+                    .target = target,
                 });
                 try applyDynamicReloc(A, elf_file, writer);
             } else {
@@ -750,6 +761,7 @@ fn resolveDynAbsReloc(
                 .sym = target.extra(elf_file).dynamic,
                 .type = relocation.encode(.abs, cpu_arch),
                 .addend = A,
+                .target = target,
             });
             try applyDynamicReloc(A, elf_file, writer);
         },
@@ -759,6 +771,7 @@ fn resolveDynAbsReloc(
                 .offset = P,
                 .type = relocation.encode(.rel, cpu_arch),
                 .addend = S + A,
+                .target = target,
             });
             try applyDynamicReloc(S + A, elf_file, writer);
         },
@@ -769,6 +782,7 @@ fn resolveDynAbsReloc(
                 .offset = P,
                 .type = relocation.encode(.irel, cpu_arch),
                 .addend = S_ + A,
+                .target = target,
             });
             try applyDynamicReloc(S_ + A, elf_file, writer);
         },
@@ -868,15 +882,7 @@ pub fn resolveRelocsNonAlloc(self: Atom, elf_file: *Elf, code: []u8, undefs: any
     if (has_reloc_errors) return error.RelocFailure;
 }
 
-const AddExtraOpts = struct {
-    thunk: ?u32 = null,
-    fde_start: ?u32 = null,
-    fde_count: ?u32 = null,
-    rel_index: ?u32 = null,
-    rel_count: ?u32 = null,
-};
-
-pub fn addExtra(atom: *Atom, opts: AddExtraOpts, elf_file: *Elf) void {
+pub fn addExtra(atom: *Atom, opts: Extra.AsOptionals, elf_file: *Elf) void {
     const file_ptr = atom.file(elf_file).?;
     var extras = file_ptr.atomExtra(atom.extra_index);
     inline for (@typeInfo(@TypeOf(opts)).@"struct".fields) |field| {
@@ -887,11 +893,11 @@ pub fn addExtra(atom: *Atom, opts: AddExtraOpts, elf_file: *Elf) void {
     file_ptr.setAtomExtra(atom.extra_index, extras);
 }
 
-pub inline fn extra(atom: Atom, elf_file: *Elf) Extra {
+pub fn extra(atom: Atom, elf_file: *Elf) Extra {
     return atom.file(elf_file).?.atomExtra(atom.extra_index);
 }
 
-pub inline fn setExtra(atom: Atom, extras: Extra, elf_file: *Elf) void {
+pub fn setExtra(atom: Atom, extras: Extra, elf_file: *Elf) void {
     atom.file(elf_file).?.setAtomExtra(atom.extra_index, extras);
 }
 
@@ -930,9 +936,10 @@ fn format2(
     _ = unused_fmt_string;
     const atom = ctx.atom;
     const elf_file = ctx.elf_file;
-    try writer.print("atom({d}) : {s} : @{x} : shdr({d}) : align({x}) : size({x})", .{
+    try writer.print("atom({d}) : {s} : @{x} : shdr({d}) : align({x}) : size({x}) : prev({}) : next({})", .{
         atom.atom_index,           atom.name(elf_file),                   atom.address(elf_file),
         atom.output_section_index, atom.alignment.toByteUnits() orelse 0, atom.size,
+        atom.prev_atom_ref,        atom.next_atom_ref,
     });
     if (atom.fdes(elf_file).len > 0) {
         try writer.writeAll(" : fdes{ ");
@@ -2103,6 +2110,14 @@ pub const Extra = struct {
 
     /// Count of relocations belonging to this atom.
     rel_count: u32 = 0,
+
+    pub const AsOptionals = struct {
+        thunk: ?u32 = null,
+        fde_start: ?u32 = null,
+        fde_count: ?u32 = null,
+        rel_index: ?u32 = null,
+        rel_count: ?u32 = null,
+    };
 };
 
 const std = @import("std");
diff --git a/zig/src/link/Elf/AtomList.zig b/zig/src/link/Elf/AtomList.zig
index 5fc1893376..bab4726f24 100644
--- a/zig/src/link/Elf/AtomList.zig
+++ b/zig/src/link/Elf/AtomList.zig
@@ -2,7 +2,10 @@ value: i64 = 0,
 size: u64 = 0,
 alignment: Atom.Alignment = .@"1",
 output_section_index: u32 = 0,
-atoms: std.ArrayListUnmanaged(Elf.Ref) = .empty,
+// atoms: std.ArrayListUnmanaged(Elf.Ref) = .empty,
+atoms: std.AutoArrayHashMapUnmanaged(Elf.Ref, void) = .empty,
+
+dirty: bool = true,
 
 pub fn deinit(list: *AtomList, allocator: Allocator) void {
     list.atoms.deinit(allocator);
@@ -19,7 +22,8 @@ pub fn offset(list: AtomList, elf_file: *Elf) u64 {
 }
 
 pub fn updateSize(list: *AtomList, elf_file: *Elf) void {
-    for (list.atoms.items) |ref| {
+    assert(list.dirty);
+    for (list.atoms.keys()) |ref| {
         const atom_ptr = elf_file.atom(ref).?;
         assert(atom_ptr.alive);
         const off = atom_ptr.alignment.forward(list.size);
@@ -31,6 +35,8 @@ pub fn updateSize(list: *AtomList, elf_file: *Elf) void {
 }
 
 pub fn allocate(list: *AtomList, elf_file: *Elf) !void {
+    assert(list.dirty);
+
     const alloc_res = try elf_file.allocateChunk(.{
         .shndx = list.output_section_index,
         .size = list.size,
@@ -39,6 +45,8 @@ pub fn allocate(list: *AtomList, elf_file: *Elf) !void {
     });
     list.value = @intCast(alloc_res.value);
 
+    log.debug("allocated atom_list({d}) at 0x{x}", .{ list.output_section_index, list.address(elf_file) });
+
     const slice = elf_file.sections.slice();
     const shdr = &slice.items(.shdr)[list.output_section_index];
     const last_atom_ref = &slice.items(.last_atom)[list.output_section_index];
@@ -53,13 +61,13 @@ pub fn allocate(list: *AtomList, elf_file: *Elf) !void {
     // FIXME:JK this currently ignores Thunks as valid chunks.
     {
         var idx: usize = 0;
-        while (idx < list.atoms.items.len) : (idx += 1) {
-            const curr_atom_ptr = elf_file.atom(list.atoms.items[idx]).?;
+        while (idx < list.atoms.keys().len) : (idx += 1) {
+            const curr_atom_ptr = elf_file.atom(list.atoms.keys()[idx]).?;
             if (idx > 0) {
-                curr_atom_ptr.prev_atom_ref = list.atoms.items[idx - 1];
+                curr_atom_ptr.prev_atom_ref = list.atoms.keys()[idx - 1];
             }
-            if (idx + 1 < list.atoms.items.len) {
-                curr_atom_ptr.next_atom_ref = list.atoms.items[idx + 1];
+            if (idx + 1 < list.atoms.keys().len) {
+                curr_atom_ptr.next_atom_ref = list.atoms.keys()[idx + 1];
             }
         }
     }
@@ -71,17 +79,20 @@ pub fn allocate(list: *AtomList, elf_file: *Elf) !void {
     }
 
     // FIXME:JK if we had a link from Atom to parent AtomList we would not need to update Atom's value or osec index
-    for (list.atoms.items) |ref| {
+    for (list.atoms.keys()) |ref| {
         const atom_ptr = elf_file.atom(ref).?;
         atom_ptr.output_section_index = list.output_section_index;
         atom_ptr.value += list.value;
     }
+
+    list.dirty = false;
 }
 
 pub fn write(list: AtomList, buffer: *std.ArrayList(u8), undefs: anytype, elf_file: *Elf) !void {
     const gpa = elf_file.base.comp.gpa;
     const osec = elf_file.sections.items(.shdr)[list.output_section_index];
     assert(osec.sh_type != elf.SHT_NOBITS);
+    assert(!list.dirty);
 
     log.debug("writing atoms in section '{s}'", .{elf_file.getShString(osec.sh_name)});
 
@@ -89,7 +100,7 @@ pub fn write(list: AtomList, buffer: *std.ArrayList(u8), undefs: anytype, elf_fi
     try buffer.ensureUnusedCapacity(list_size);
     buffer.appendNTimesAssumeCapacity(0, list_size);
 
-    for (list.atoms.items) |ref| {
+    for (list.atoms.keys()) |ref| {
         const atom_ptr = elf_file.atom(ref).?;
         assert(atom_ptr.alive);
 
@@ -125,7 +136,7 @@ pub fn writeRelocatable(list: AtomList, buffer: *std.ArrayList(u8), elf_file: *E
     try buffer.ensureUnusedCapacity(list_size);
     buffer.appendNTimesAssumeCapacity(0, list_size);
 
-    for (list.atoms.items) |ref| {
+    for (list.atoms.keys()) |ref| {
         const atom_ptr = elf_file.atom(ref).?;
         assert(atom_ptr.alive);
 
@@ -146,13 +157,13 @@ pub fn writeRelocatable(list: AtomList, buffer: *std.ArrayList(u8), elf_file: *E
 }
 
 pub fn firstAtom(list: AtomList, elf_file: *Elf) *Atom {
-    assert(list.atoms.items.len > 0);
-    return elf_file.atom(list.atoms.items[0]).?;
+    assert(list.atoms.keys().len > 0);
+    return elf_file.atom(list.atoms.keys()[0]).?;
 }
 
 pub fn lastAtom(list: AtomList, elf_file: *Elf) *Atom {
-    assert(list.atoms.items.len > 0);
-    return elf_file.atom(list.atoms.items[list.atoms.items.len - 1]).?;
+    assert(list.atoms.keys().len > 0);
+    return elf_file.atom(list.atoms.keys()[list.atoms.keys().len - 1]).?;
 }
 
 pub fn format(
@@ -188,9 +199,9 @@ fn format2(
         list.alignment.toByteUnits() orelse 0, list.size,
     });
     try writer.writeAll(" : atoms{ ");
-    for (list.atoms.items, 0..) |ref, i| {
+    for (list.atoms.keys(), 0..) |ref, i| {
         try writer.print("{}", .{ref});
-        if (i < list.atoms.items.len - 1) try writer.writeAll(", ");
+        if (i < list.atoms.keys().len - 1) try writer.writeAll(", ");
     }
     try writer.writeAll(" }");
 }
diff --git a/zig/src/link/Elf/LdScript.zig b/zig/src/link/Elf/LdScript.zig
index bf5efd2137..7bb1f62104 100644
--- a/zig/src/link/Elf/LdScript.zig
+++ b/zig/src/link/Elf/LdScript.zig
@@ -1,13 +1,18 @@
-path: []const u8,
+path: Path,
 cpu_arch: ?std.Target.Cpu.Arch = null,
-args: std.ArrayListUnmanaged(Elf.SystemLib) = .empty,
+args: std.ArrayListUnmanaged(Arg) = .empty,
+
+pub const Arg = struct {
+    needed: bool = false,
+    path: []const u8,
+};
 
 pub fn deinit(scr: *LdScript, allocator: Allocator) void {
     scr.args.deinit(allocator);
 }
 
 pub const Error = error{
-    InvalidLdScript,
+    LinkFailure,
     UnexpectedToken,
     UnknownCpuArch,
     OutOfMemory,
@@ -32,12 +37,9 @@ pub fn parse(scr: *LdScript, data: []const u8, elf_file: *Elf) Error!void {
         try line_col.append(.{ .line = line, .column = column });
         switch (tok.id) {
             .invalid => {
-                try elf_file.reportParseError(scr.path, "invalid token in LD script: '{s}' ({d}:{d})", .{
-                    std.fmt.fmtSliceEscapeLower(tok.get(data)),
-                    line,
-                    column,
+                return elf_file.failParse(scr.path, "invalid token in LD script: '{s}' ({d}:{d})", .{
+                    std.fmt.fmtSliceEscapeLower(tok.get(data)), line, column,
                 });
-                return error.InvalidLdScript;
             },
             .new_line => {
                 line += 1;
@@ -50,7 +52,7 @@ pub fn parse(scr: *LdScript, data: []const u8, elf_file: *Elf) Error!void {
 
     var it = TokenIterator{ .tokens = tokens.items };
     var parser = Parser{ .source = data, .it = &it };
-    var args = std.ArrayList(Elf.SystemLib).init(gpa);
+    var args = std.ArrayList(Arg).init(gpa);
     scr.doParse(.{
         .parser = &parser,
         .args = &args,
@@ -59,13 +61,12 @@ pub fn parse(scr: *LdScript, data: []const u8, elf_file: *Elf) Error!void {
             const last_token_id = parser.it.pos - 1;
             const last_token = parser.it.get(last_token_id);
             const lcol = line_col.items[last_token_id];
-            try elf_file.reportParseError(scr.path, "unexpected token in LD script: {s}: '{s}' ({d}:{d})", .{
+            return elf_file.failParse(scr.path, "unexpected token in LD script: {s}: '{s}' ({d}:{d})", .{
                 @tagName(last_token.id),
                 last_token.get(data),
                 lcol.line,
                 lcol.column,
             });
-            return error.InvalidLdScript;
         },
         else => |e| return e,
     };
@@ -74,7 +75,7 @@ pub fn parse(scr: *LdScript, data: []const u8, elf_file: *Elf) Error!void {
 
 fn doParse(scr: *LdScript, ctx: struct {
     parser: *Parser,
-    args: *std.ArrayList(Elf.SystemLib),
+    args: *std.ArrayList(Arg),
 }) !void {
     while (true) {
         ctx.parser.skipAny(&.{ .comment, .new_line });
@@ -146,7 +147,7 @@ const Parser = struct {
         return error.UnknownCpuArch;
     }
 
-    fn group(p: *Parser, args: *std.ArrayList(Elf.SystemLib)) !void {
+    fn group(p: *Parser, args: *std.ArrayList(Arg)) !void {
         if (!p.skip(&.{.lparen})) return error.UnexpectedToken;
 
         while (true) {
@@ -166,7 +167,7 @@ const Parser = struct {
         _ = try p.require(.rparen);
     }
 
-    fn asNeeded(p: *Parser, args: *std.ArrayList(Elf.SystemLib)) !void {
+    fn asNeeded(p: *Parser, args: *std.ArrayList(Arg)) !void {
         if (!p.skip(&.{.lparen})) return error.UnexpectedToken;
 
         while (p.maybe(.literal)) |tok_id| {
@@ -243,7 +244,7 @@ const Token = struct {
 
     const Index = usize;
 
-    inline fn get(tok: Token, source: []const u8) []const u8 {
+    fn get(tok: Token, source: []const u8) []const u8 {
         return source[tok.start..tok.end];
     }
 };
@@ -403,11 +404,11 @@ const TokenIterator = struct {
         return it.tokens[it.pos];
     }
 
-    inline fn reset(it: *TokenIterator) void {
+    fn reset(it: *TokenIterator) void {
         it.pos = 0;
     }
 
-    inline fn seekTo(it: *TokenIterator, pos: Token.Index) void {
+    fn seekTo(it: *TokenIterator, pos: Token.Index) void {
         it.pos = pos;
     }
 
@@ -420,7 +421,7 @@ const TokenIterator = struct {
         }
     }
 
-    inline fn get(it: *TokenIterator, pos: Token.Index) Token {
+    fn get(it: *TokenIterator, pos: Token.Index) Token {
         assert(pos < it.tokens.len);
         return it.tokens[pos];
     }
@@ -430,6 +431,7 @@ const LdScript = @This();
 
 const std = @import("std");
 const assert = std.debug.assert;
+const Path = std.Build.Cache.Path;
 
 const Allocator = std.mem.Allocator;
 const Elf = @import("../Elf.zig");
diff --git a/zig/src/link/Elf/LinkerDefined.zig b/zig/src/link/Elf/LinkerDefined.zig
index 59aea19efa..9515dfcd43 100644
--- a/zig/src/link/Elf/LinkerDefined.zig
+++ b/zig/src/link/Elf/LinkerDefined.zig
@@ -47,7 +47,7 @@ fn newSymbolAssumeCapacity(self: *LinkerDefined, name_off: u32, elf_file: *Elf)
     const esym = self.symtab.addOneAssumeCapacity();
     esym.* = .{
         .st_name = name_off,
-        .st_info = elf.STB_GLOBAL << 4,
+        .st_info = elf.STB_WEAK << 4,
         .st_other = @intFromEnum(elf.STV.HIDDEN),
         .st_shndx = elf.SHN_ABS,
         .st_value = 0,
@@ -145,6 +145,7 @@ pub fn initStartStopSymbols(self: *LinkerDefined, elf_file: *Elf) !void {
     try self.symbols_resolver.ensureUnusedCapacity(gpa, nsyms);
 
     for (slice.items(.shdr)) |shdr| {
+        // TODO use getOrPut for incremental so that we don't create duplicates
         if (elf_file.getStartStopBasename(shdr)) |name| {
             const start_name = try std.fmt.allocPrintZ(gpa, "__start_{s}", .{name});
             defer gpa.free(start_name);
@@ -158,7 +159,6 @@ pub fn initStartStopSymbols(self: *LinkerDefined, elf_file: *Elf) !void {
                     .index = index,
                     .file = self.index,
                 }, elf_file);
-                assert(!gop.found_existing);
                 gop.ref.* = .{ .index = index, .file = self.index };
                 self.symbols_resolver.appendAssumeCapacity(gop.index);
             }
@@ -255,8 +255,10 @@ pub fn allocateSymbols(self: *LinkerDefined, elf_file: *Elf) void {
 
     // __dso_handle
     if (self.dso_handle_index) |index| {
-        const shdr = shdrs[1];
-        allocSymbol(self, index, shdr.sh_addr, 0, elf_file);
+        if (self.resolveSymbol(index, elf_file).file == self.index) {
+            const shdr = shdrs[1];
+            allocSymbol(self, index, shdr.sh_addr, 0, elf_file);
+        }
     }
 
     // __GNU_EH_FRAME_HDR
diff --git a/zig/src/link/Elf/Object.zig b/zig/src/link/Elf/Object.zig
index a7091b7394..23216020a6 100644
--- a/zig/src/link/Elf/Object.zig
+++ b/zig/src/link/Elf/Object.zig
@@ -1,5 +1,7 @@
 archive: ?InArchive = null,
-path: []const u8,
+/// Archive files cannot contain subdirectories, so only the basename is needed
+/// for output. However, the full path is kept for error reporting.
+path: Path,
 file_handle: File.HandleIndex,
 index: File.Index,
 
@@ -29,26 +31,15 @@ cies: std.ArrayListUnmanaged(Cie) = .empty,
 eh_frame_data: std.ArrayListUnmanaged(u8) = .empty,
 
 alive: bool = true,
+dirty: bool = true,
 num_dynrelocs: u32 = 0,
 
 output_symtab_ctx: Elf.SymtabCtx = .{},
 output_ar_state: Archive.ArState = .{},
 
-pub fn isObject(path: []const u8) !bool {
-    const file = try std.fs.cwd().openFile(path, .{});
-    defer file.close();
-    const reader = file.reader();
-    const header = reader.readStruct(elf.Elf64_Ehdr) catch return false;
-    if (!mem.eql(u8, header.e_ident[0..4], "\x7fELF")) return false;
-    if (header.e_ident[elf.EI_VERSION] != 1) return false;
-    if (header.e_type != elf.ET.REL) return false;
-    if (header.e_version != 1) return false;
-    return true;
-}
-
 pub fn deinit(self: *Object, allocator: Allocator) void {
-    if (self.archive) |*ar| allocator.free(ar.path);
-    allocator.free(self.path);
+    if (self.archive) |*ar| allocator.free(ar.path.sub_path);
+    allocator.free(self.path.sub_path);
     self.shdrs.deinit(allocator);
     self.symtab.deinit(allocator);
     self.strtab.deinit(allocator);
@@ -107,12 +98,9 @@ fn parseCommon(self: *Object, allocator: Allocator, handle: std.fs.File, elf_fil
 
     const em = elf_file.base.comp.root_mod.resolved_target.result.toElfMachine();
     if (em != self.header.?.e_machine) {
-        try elf_file.reportParseError2(
-            self.index,
-            "invalid ELF machine type: {s}",
-            .{@tagName(self.header.?.e_machine)},
-        );
-        return error.InvalidMachineType;
+        return elf_file.failFile(self.index, "invalid ELF machine type: {s}", .{
+            @tagName(self.header.?.e_machine),
+        });
     }
     try elf_file.validateEFlags(self.index, self.header.?.e_flags);
 
@@ -122,12 +110,7 @@ fn parseCommon(self: *Object, allocator: Allocator, handle: std.fs.File, elf_fil
     const shnum = math.cast(usize, self.header.?.e_shnum) orelse return error.Overflow;
     const shsize = shnum * @sizeOf(elf.Elf64_Shdr);
     if (file_size < offset + shoff or file_size < offset + shoff + shsize) {
-        try elf_file.reportParseError2(
-            self.index,
-            "corrupt header: section header table extends past the end of file",
-            .{},
-        );
-        return error.MalformedObject;
+        return elf_file.failFile(self.index, "corrupt header: section header table extends past the end of file", .{});
     }
 
     const shdrs_buffer = try Elf.preadAllAlloc(allocator, handle, offset + shoff, shsize);
@@ -138,8 +121,7 @@ fn parseCommon(self: *Object, allocator: Allocator, handle: std.fs.File, elf_fil
     for (self.shdrs.items) |shdr| {
         if (shdr.sh_type != elf.SHT_NOBITS) {
             if (file_size < offset + shdr.sh_offset or file_size < offset + shdr.sh_offset + shdr.sh_size) {
-                try elf_file.reportParseError2(self.index, "corrupt section: extends past the end of file", .{});
-                return error.MalformedObject;
+                return elf_file.failFile(self.index, "corrupt section: extends past the end of file", .{});
             }
         }
     }
@@ -148,8 +130,7 @@ fn parseCommon(self: *Object, allocator: Allocator, handle: std.fs.File, elf_fil
     defer allocator.free(shstrtab);
     for (self.shdrs.items) |shdr| {
         if (shdr.sh_name >= shstrtab.len) {
-            try elf_file.reportParseError2(self.index, "corrupt section name offset", .{});
-            return error.MalformedObject;
+            return elf_file.failFile(self.index, "corrupt section name offset", .{});
         }
     }
     try self.strtab.appendSlice(allocator, shstrtab);
@@ -166,8 +147,7 @@ fn parseCommon(self: *Object, allocator: Allocator, handle: std.fs.File, elf_fil
         const raw_symtab = try self.preadShdrContentsAlloc(allocator, handle, index);
         defer allocator.free(raw_symtab);
         const nsyms = math.divExact(usize, raw_symtab.len, @sizeOf(elf.Elf64_Sym)) catch {
-            try elf_file.reportParseError2(self.index, "symbol table not evenly divisible", .{});
-            return error.MalformedObject;
+            return elf_file.failFile(self.index, "symbol table not evenly divisible", .{});
         };
         const symtab = @as([*]align(1) const elf.Elf64_Sym, @ptrCast(raw_symtab.ptr))[0..nsyms];
 
@@ -189,6 +169,9 @@ fn parseCommon(self: *Object, allocator: Allocator, handle: std.fs.File, elf_fil
 }
 
 fn initAtoms(self: *Object, allocator: Allocator, handle: std.fs.File, elf_file: *Elf) !void {
+    const comp = elf_file.base.comp;
+    const debug_fmt_strip = comp.config.debug_format == .strip;
+    const target = comp.root_mod.resolved_target.result;
     const shdrs = self.shdrs.items;
     try self.atoms.ensureTotalCapacityPrecise(allocator, shdrs.len);
     try self.atoms_extra.ensureTotalCapacityPrecise(allocator, shdrs.len * @sizeOf(Atom.Extra));
@@ -217,37 +200,22 @@ fn initAtoms(self: *Object, allocator: Allocator, handle: std.fs.File, elf_file:
                     break :blk group_info_sym.st_name;
                 };
 
-                const shndx = @as(u32, @intCast(i));
+                const shndx: u32 = @intCast(i);
                 const group_raw_data = try self.preadShdrContentsAlloc(allocator, handle, shndx);
                 defer allocator.free(group_raw_data);
                 const group_nmembers = math.divExact(usize, group_raw_data.len, @sizeOf(u32)) catch {
-                    try elf_file.reportParseError2(
-                        self.index,
-                        "corrupt section group: not evenly divisible ",
-                        .{},
-                    );
-                    return error.MalformedObject;
+                    return elf_file.failFile(self.index, "corrupt section group: not evenly divisible ", .{});
                 };
                 if (group_nmembers == 0) {
-                    try elf_file.reportParseError2(
-                        self.index,
-                        "corrupt section group: empty section",
-                        .{},
-                    );
-                    return error.MalformedObject;
+                    return elf_file.failFile(self.index, "corrupt section group: empty section", .{});
                 }
                 const group_members = @as([*]align(1) const u32, @ptrCast(group_raw_data.ptr))[0..group_nmembers];
 
                 if (group_members[0] != elf.GRP_COMDAT) {
-                    try elf_file.reportParseError2(
-                        self.index,
-                        "corrupt section group: unknown SHT_GROUP format",
-                        .{},
-                    );
-                    return error.MalformedObject;
+                    return elf_file.failFile(self.index, "corrupt section group: unknown SHT_GROUP format", .{});
                 }
 
-                const group_start = @as(u32, @intCast(self.comdat_group_data.items.len));
+                const group_start: u32 = @intCast(self.comdat_group_data.items.len);
                 try self.comdat_group_data.appendUnalignedSlice(allocator, group_members[1..]);
 
                 const comdat_group_index = try self.addComdatGroup(allocator);
@@ -271,8 +239,8 @@ fn initAtoms(self: *Object, allocator: Allocator, handle: std.fs.File, elf_file:
             => {},
 
             else => {
-                const shndx = @as(u32, @intCast(i));
-                if (self.skipShdr(shndx, elf_file)) continue;
+                const shndx: u32 = @intCast(i);
+                if (self.skipShdr(shndx, debug_fmt_strip)) continue;
                 const size, const alignment = if (shdr.sh_flags & elf.SHF_COMPRESSED != 0) blk: {
                     const data = try self.preadShdrContentsAlloc(allocator, handle, shndx);
                     defer allocator.free(data);
@@ -300,9 +268,9 @@ fn initAtoms(self: *Object, allocator: Allocator, handle: std.fs.File, elf_file:
                 atom_ptr.relocs_section_index = @intCast(i);
                 const rel_index: u32 = @intCast(self.relocs.items.len);
                 const rel_count: u32 = @intCast(relocs.len);
-                atom_ptr.addExtra(.{ .rel_index = rel_index, .rel_count = rel_count }, elf_file);
+                self.setAtomFields(atom_ptr, .{ .rel_index = rel_index, .rel_count = rel_count });
                 try self.relocs.appendUnalignedSlice(allocator, relocs);
-                if (elf_file.getTarget().cpu.arch == .riscv64) {
+                if (target.cpu.arch == .riscv64) {
                     sortRelocs(self.relocs.items[rel_index..][0..rel_count]);
                 }
             }
@@ -311,15 +279,14 @@ fn initAtoms(self: *Object, allocator: Allocator, handle: std.fs.File, elf_file:
     };
 }
 
-fn skipShdr(self: *Object, index: u32, elf_file: *Elf) bool {
-    const comp = elf_file.base.comp;
+fn skipShdr(self: *Object, index: u32, debug_fmt_strip: bool) bool {
     const shdr = self.shdrs.items[index];
     const name = self.getString(shdr.sh_name);
     const ignore = blk: {
         if (mem.startsWith(u8, name, ".note")) break :blk true;
         if (mem.startsWith(u8, name, ".llvm_addrsig")) break :blk true;
         if (mem.startsWith(u8, name, ".riscv.attributes")) break :blk true; // TODO: riscv attributes
-        if (comp.config.debug_format == .strip and shdr.sh_flags & elf.SHF_ALLOC == 0 and
+        if (debug_fmt_strip and shdr.sh_flags & elf.SHF_ALLOC == 0 and
             mem.startsWith(u8, name, ".debug")) break :blk true;
         break :blk false;
     };
@@ -509,8 +476,7 @@ pub fn scanRelocs(self: *Object, elf_file: *Elf, undefs: anytype) !void {
                 if (sym.type(elf_file) != elf.STT_FUNC)
                     // TODO convert into an error
                     log.debug("{s}: {s}: CIE referencing external data reference", .{
-                        self.fmtPath(),
-                        sym.name(elf_file),
+                        self.fmtPath(), sym.name(elf_file),
                     });
                 sym.flags.needs_plt = true;
             }
@@ -524,12 +490,6 @@ pub fn resolveSymbols(self: *Object, elf_file: *Elf) !void {
     const first_global = self.first_global orelse return;
     for (self.globals(), first_global..) |_, i| {
         const esym = self.symtab.items[i];
-        if (esym.st_shndx != elf.SHN_ABS and esym.st_shndx != elf.SHN_COMMON and esym.st_shndx != elf.SHN_UNDEF) {
-            const atom_index = self.atoms_indexes.items[esym.st_shndx];
-            const atom_ptr = self.atom(atom_index) orelse continue;
-            if (!atom_ptr.alive) continue;
-        }
-
         const resolv = &self.symbols_resolver.items[i - first_global];
         const gop = try elf_file.resolver.getOrPut(gpa, .{
             .index = @intCast(i),
@@ -541,6 +501,11 @@ pub fn resolveSymbols(self: *Object, elf_file: *Elf) !void {
         resolv.* = gop.index;
 
         if (esym.st_shndx == elf.SHN_UNDEF) continue;
+        if (esym.st_shndx != elf.SHN_ABS and esym.st_shndx != elf.SHN_COMMON) {
+            const atom_index = self.atoms_indexes.items[esym.st_shndx];
+            const atom_ptr = self.atom(atom_index) orelse continue;
+            if (!atom_ptr.alive) continue;
+        }
         if (elf_file.symbol(gop.ref.*) == null) {
             gop.ref.* = .{ .index = @intCast(i), .file = self.index };
             continue;
@@ -723,7 +688,7 @@ pub fn initInputMergeSections(self: *Object, elf_file: *Elf) !void {
                     var err = try elf_file.base.addErrorWithNotes(1);
                     try err.addMsg("string not null terminated", .{});
                     try err.addNote("in {}:{s}", .{ self.fmtPath(), atom_ptr.name(elf_file) });
-                    return error.MalformedObject;
+                    return error.LinkFailure;
                 }
                 end += sh_entsize;
                 const string = data[start..end];
@@ -738,7 +703,7 @@ pub fn initInputMergeSections(self: *Object, elf_file: *Elf) !void {
                 var err = try elf_file.base.addErrorWithNotes(1);
                 try err.addMsg("size not a multiple of sh_entsize", .{});
                 try err.addNote("in {}:{s}", .{ self.fmtPath(), atom_ptr.name(elf_file) });
-                return error.MalformedObject;
+                return error.LinkFailure;
             }
 
             var pos: u32 = 0;
@@ -766,7 +731,12 @@ pub fn initOutputMergeSections(self: *Object, elf_file: *Elf) !void {
     }
 }
 
-pub fn resolveMergeSubsections(self: *Object, elf_file: *Elf) !void {
+pub fn resolveMergeSubsections(self: *Object, elf_file: *Elf) error{
+    LinkFailure,
+    OutOfMemory,
+    /// TODO report the error and remove this
+    Overflow,
+}!void {
     const gpa = elf_file.base.comp.gpa;
 
     for (self.input_merge_sections_indexes.items) |index| {
@@ -810,7 +780,7 @@ pub fn resolveMergeSubsections(self: *Object, elf_file: *Elf) !void {
             try err.addMsg("invalid symbol value: {x}", .{esym.st_value});
             try err.addNote("for symbol {s}", .{sym.name(elf_file)});
             try err.addNote("in {}", .{self.fmtPath()});
-            return error.MalformedObject;
+            return error.LinkFailure;
         };
 
         sym.ref = .{ .index = res.msub_index, .file = imsec.merge_section_index };
@@ -835,7 +805,7 @@ pub fn resolveMergeSubsections(self: *Object, elf_file: *Elf) !void {
                 var err = try elf_file.base.addErrorWithNotes(1);
                 try err.addMsg("invalid relocation at offset 0x{x}", .{rel.r_offset});
                 try err.addNote("in {}:{s}", .{ self.fmtPath(), atom_ptr.name(elf_file) });
-                return error.MalformedObject;
+                return error.LinkFailure;
             };
 
             const sym_index = try self.addSymbol(gpa);
@@ -949,7 +919,7 @@ pub fn initOutputSections(self: *Object, elf_file: *Elf) !void {
         });
         const atom_list = &elf_file.sections.items(.atom_list_2)[osec];
         atom_list.output_section_index = osec;
-        try atom_list.atoms.append(elf_file.base.comp.gpa, atom_ptr.ref());
+        _ = try atom_list.atoms.getOrPut(elf_file.base.comp.gpa, atom_ptr.ref());
     }
 }
 
@@ -1027,7 +997,7 @@ pub fn updateArSize(self: *Object, elf_file: *Elf) !void {
 pub fn writeAr(self: Object, elf_file: *Elf, writer: anytype) !void {
     const size = std.math.cast(usize, self.output_ar_state.size) orelse return error.Overflow;
     const offset: u64 = if (self.archive) |ar| ar.offset else 0;
-    const name = self.path;
+    const name = std.fs.path.basename(self.path.sub_path);
     const hdr = Archive.setArHdr(.{
         .name = if (name.len <= Archive.max_member_name_len)
             .{ .name = name }
@@ -1291,7 +1261,7 @@ pub fn addAtomExtra(self: *Object, allocator: Allocator, extra: Atom.Extra) !u32
 }
 
 pub fn addAtomExtraAssumeCapacity(self: *Object, extra: Atom.Extra) u32 {
-    const index = @as(u32, @intCast(self.atoms_extra.items.len));
+    const index: u32 = @intCast(self.atoms_extra.items.len);
     const fields = @typeInfo(Atom.Extra).@"struct".fields;
     inline for (fields) |field| {
         self.atoms_extra.appendAssumeCapacity(switch (field.type) {
@@ -1326,6 +1296,15 @@ pub fn setAtomExtra(self: *Object, index: u32, extra: Atom.Extra) void {
     }
 }
 
+fn setAtomFields(o: *Object, atom_ptr: *Atom, opts: Atom.Extra.AsOptionals) void {
+    assert(o.index == atom_ptr.file_index);
+    var extras = o.atomExtra(atom_ptr.extra_index);
+    inline for (@typeInfo(@TypeOf(opts)).@"struct".fields) |field| {
+        if (@field(opts, field.name)) |x| @field(extras, field.name) = x;
+    }
+    o.setAtomExtra(atom_ptr.extra_index, extras);
+}
+
 fn addInputMergeSection(self: *Object, allocator: Allocator) !InputMergeSection.Index {
     const index: InputMergeSection.Index = @intCast(self.input_merge_sections.items.len);
     const msec = try self.input_merge_sections.addOne(allocator);
@@ -1511,15 +1490,14 @@ fn formatPath(
     _ = unused_fmt_string;
     _ = options;
     if (object.archive) |ar| {
-        try writer.writeAll(ar.path);
-        try writer.writeByte('(');
-        try writer.writeAll(object.path);
-        try writer.writeByte(')');
-    } else try writer.writeAll(object.path);
+        try writer.print("{}({})", .{ ar.path, object.path });
+    } else {
+        try writer.print("{}", .{object.path});
+    }
 }
 
 const InArchive = struct {
-    path: []const u8,
+    path: Path,
     offset: u64,
     size: u32,
 };
@@ -1534,8 +1512,9 @@ const fs = std.fs;
 const log = std.log.scoped(.link);
 const math = std.math;
 const mem = std.mem;
-
+const Path = std.Build.Cache.Path;
 const Allocator = mem.Allocator;
+
 const Archive = @import("Archive.zig");
 const Atom = @import("Atom.zig");
 const AtomList = @import("AtomList.zig");
diff --git a/zig/src/link/Elf/SharedObject.zig b/zig/src/link/Elf/SharedObject.zig
index 3000af39ca..7e6aabea38 100644
--- a/zig/src/link/Elf/SharedObject.zig
+++ b/zig/src/link/Elf/SharedObject.zig
@@ -1,4 +1,4 @@
-path: []const u8,
+path: Path,
 index: File.Index,
 
 header: ?elf.Elf64_Ehdr = null,
@@ -22,8 +22,8 @@ alive: bool,
 
 output_symtab_ctx: Elf.SymtabCtx = .{},
 
-pub fn isSharedObject(path: []const u8) !bool {
-    const file = try std.fs.cwd().openFile(path, .{});
+pub fn isSharedObject(path: Path) !bool {
+    const file = try path.root_dir.handle.openFile(path.sub_path, .{});
     defer file.close();
     const reader = file.reader();
     const header = reader.readStruct(elf.Elf64_Ehdr) catch return false;
@@ -34,7 +34,7 @@ pub fn isSharedObject(path: []const u8) !bool {
 }
 
 pub fn deinit(self: *SharedObject, allocator: Allocator) void {
-    allocator.free(self.path);
+    allocator.free(self.path.sub_path);
     self.shdrs.deinit(allocator);
     self.symtab.deinit(allocator);
     self.strtab.deinit(allocator);
@@ -58,24 +58,16 @@ pub fn parse(self: *SharedObject, elf_file: *Elf, handle: std.fs.File) !void {
 
     const em = elf_file.base.comp.root_mod.resolved_target.result.toElfMachine();
     if (em != self.header.?.e_machine) {
-        try elf_file.reportParseError2(
-            self.index,
-            "invalid ELF machine type: {s}",
-            .{@tagName(self.header.?.e_machine)},
-        );
-        return error.InvalidMachineType;
+        return elf_file.failFile(self.index, "invalid ELF machine type: {s}", .{
+            @tagName(self.header.?.e_machine),
+        });
     }
 
     const shoff = std.math.cast(usize, self.header.?.e_shoff) orelse return error.Overflow;
     const shnum = std.math.cast(usize, self.header.?.e_shnum) orelse return error.Overflow;
     const shsize = shnum * @sizeOf(elf.Elf64_Shdr);
     if (file_size < shoff or file_size < shoff + shsize) {
-        try elf_file.reportParseError2(
-            self.index,
-            "corrupted header: section header table extends past the end of file",
-            .{},
-        );
-        return error.MalformedObject;
+        return elf_file.failFile(self.index, "corrupted header: section header table extends past the end of file", .{});
     }
 
     const shdrs_buffer = try Elf.preadAllAlloc(gpa, handle, shoff, shsize);
@@ -90,8 +82,7 @@ pub fn parse(self: *SharedObject, elf_file: *Elf, handle: std.fs.File) !void {
     for (self.shdrs.items, 0..) |shdr, i| {
         if (shdr.sh_type != elf.SHT_NOBITS) {
             if (file_size < shdr.sh_offset or file_size < shdr.sh_offset + shdr.sh_size) {
-                try elf_file.reportParseError2(self.index, "corrupted section header", .{});
-                return error.MalformedObject;
+                return elf_file.failFile(self.index, "corrupted section header", .{});
             }
         }
         switch (shdr.sh_type) {
@@ -328,7 +319,7 @@ pub fn asFile(self: *SharedObject) File {
 
 fn verdefNum(self: *SharedObject) u32 {
     for (self.dynamic_table.items) |entry| switch (entry.d_tag) {
-        elf.DT_VERDEFNUM => return @as(u32, @intCast(entry.d_val)),
+        elf.DT_VERDEFNUM => return @intCast(entry.d_val),
         else => {},
     };
     return 0;
@@ -336,10 +327,10 @@ fn verdefNum(self: *SharedObject) u32 {
 
 pub fn soname(self: *SharedObject) []const u8 {
     for (self.dynamic_table.items) |entry| switch (entry.d_tag) {
-        elf.DT_SONAME => return self.getString(@as(u32, @intCast(entry.d_val))),
+        elf.DT_SONAME => return self.getString(@intCast(entry.d_val)),
         else => {},
     };
-    return std.fs.path.basename(self.path);
+    return std.fs.path.basename(self.path.sub_path);
 }
 
 pub fn initSymbolAliases(self: *SharedObject, elf_file: *Elf) !void {
@@ -517,6 +508,7 @@ const assert = std.debug.assert;
 const elf = std.elf;
 const log = std.log.scoped(.elf);
 const mem = std.mem;
+const Path = std.Build.Cache.Path;
 
 const Allocator = mem.Allocator;
 const Elf = @import("../Elf.zig");
diff --git a/zig/src/link/Elf/Symbol.zig b/zig/src/link/Elf/Symbol.zig
index 821f9e0bb9..6eaaedf28c 100644
--- a/zig/src/link/Elf/Symbol.zig
+++ b/zig/src/link/Elf/Symbol.zig
@@ -112,13 +112,16 @@ pub fn address(symbol: Symbol, opts: struct { plt: bool = true, trampoline: bool
     if (symbol.flags.has_trampoline and opts.trampoline) {
         return symbol.trampolineAddress(elf_file);
     }
-    if (symbol.flags.has_plt and opts.plt) {
-        if (!symbol.flags.is_canonical and symbol.flags.has_got) {
+    if (opts.plt) {
+        if (symbol.flags.has_pltgot) {
+            assert(!symbol.flags.is_canonical);
             // We have a non-lazy bound function pointer, use that!
             return symbol.pltGotAddress(elf_file);
         }
-        // Lazy-bound function it is!
-        return symbol.pltAddress(elf_file);
+        if (symbol.flags.has_plt) {
+            // Lazy-bound function it is!
+            return symbol.pltAddress(elf_file);
+        }
     }
     if (symbol.atom(elf_file)) |atom_ptr| {
         if (!atom_ptr.alive) {
@@ -171,7 +174,7 @@ pub fn gotAddress(symbol: Symbol, elf_file: *Elf) i64 {
 }
 
 pub fn pltGotAddress(symbol: Symbol, elf_file: *Elf) i64 {
-    if (!(symbol.flags.has_plt and symbol.flags.has_got)) return 0;
+    if (!symbol.flags.has_pltgot) return 0;
     const extras = symbol.extra(elf_file);
     const shdr = elf_file.sections.items(.shdr)[elf_file.plt_got_section_index.?];
     const cpu_arch = elf_file.getTarget().cpu.arch;
@@ -430,6 +433,8 @@ pub const Flags = packed struct {
     has_plt: bool = false,
     /// Whether the PLT entry is canonical.
     is_canonical: bool = false,
+    /// Whether the PLT entry is indirected via GOT.
+    has_pltgot: bool = false,
 
     /// Whether the symbol contains COPYREL directive.
     needs_copy_rel: bool = false,
@@ -471,7 +476,6 @@ pub const Extra = struct {
     tlsgd: u32 = 0,
     gottp: u32 = 0,
     tlsdesc: u32 = 0,
-    merge_section: u32 = 0,
     trampoline: u32 = 0,
 };
 
diff --git a/zig/src/link/Elf/ZigObject.zig b/zig/src/link/Elf/ZigObject.zig
index 671049919d..54d15297d5 100644
--- a/zig/src/link/Elf/ZigObject.zig
+++ b/zig/src/link/Elf/ZigObject.zig
@@ -5,7 +5,7 @@
 
 data: std.ArrayListUnmanaged(u8) = .empty,
 /// Externally owned memory.
-path: []const u8,
+basename: []const u8,
 index: File.Index,
 
 symtab: std.MultiArrayList(ElfSym) = .{},
@@ -88,7 +88,7 @@ pub fn init(self: *ZigObject, elf_file: *Elf, options: InitOptions) !void {
     try self.strtab.buffer.append(gpa, 0);
 
     {
-        const name_off = try self.strtab.insert(gpa, self.path);
+        const name_off = try self.strtab.insert(gpa, self.basename);
         const symbol_index = try self.newLocalSymbol(gpa, name_off);
         const sym = self.symbol(symbol_index);
         const esym = &self.symtab.items(.elf_sym)[sym.esym_index];
@@ -101,6 +101,28 @@ pub fn init(self: *ZigObject, elf_file: *Elf, options: InitOptions) !void {
         .dwarf => |v| {
             var dwarf = Dwarf.init(&elf_file.base, v);
 
+            const addSectionSymbolWithAtom = struct {
+                fn addSectionSymbolWithAtom(
+                    zo: *ZigObject,
+                    allocator: Allocator,
+                    name: [:0]const u8,
+                    alignment: Atom.Alignment,
+                    shndx: u32,
+                ) !Symbol.Index {
+                    const name_off = try zo.addString(allocator, name);
+                    const sym_index = try zo.addSectionSymbol(allocator, name_off, shndx);
+                    const sym = zo.symbol(sym_index);
+                    const atom_index = try zo.newAtom(allocator, name_off);
+                    const atom_ptr = zo.atom(atom_index).?;
+                    atom_ptr.alignment = alignment;
+                    atom_ptr.output_section_index = shndx;
+                    sym.ref = .{ .index = atom_index, .file = zo.index };
+                    zo.symtab.items(.shndx)[sym.esym_index] = atom_index;
+                    zo.symtab.items(.elf_sym)[sym.esym_index].st_shndx = SHN_ATOM;
+                    return sym_index;
+                }
+            }.addSectionSymbolWithAtom;
+
             if (self.debug_str_index == null) {
                 const osec = try elf_file.addSection(.{
                     .name = try elf_file.insertShString(".debug_str"),
@@ -110,8 +132,7 @@ pub fn init(self: *ZigObject, elf_file: *Elf, options: InitOptions) !void {
                     .addralign = 1,
                 });
                 self.debug_str_section_dirty = true;
-                self.debug_str_index = try self.addSectionSymbol(gpa, ".debug_str", .@"1", osec);
-                elf_file.sections.items(.last_atom)[osec] = self.symbol(self.debug_str_index.?).ref;
+                self.debug_str_index = try addSectionSymbolWithAtom(self, gpa, ".debug_str", .@"1", osec);
             }
 
             if (self.debug_info_index == null) {
@@ -121,8 +142,7 @@ pub fn init(self: *ZigObject, elf_file: *Elf, options: InitOptions) !void {
                     .addralign = 1,
                 });
                 self.debug_info_section_dirty = true;
-                self.debug_info_index = try self.addSectionSymbol(gpa, ".debug_info", .@"1", osec);
-                elf_file.sections.items(.last_atom)[osec] = self.symbol(self.debug_info_index.?).ref;
+                self.debug_info_index = try addSectionSymbolWithAtom(self, gpa, ".debug_info", .@"1", osec);
             }
 
             if (self.debug_abbrev_index == null) {
@@ -132,8 +152,7 @@ pub fn init(self: *ZigObject, elf_file: *Elf, options: InitOptions) !void {
                     .addralign = 1,
                 });
                 self.debug_abbrev_section_dirty = true;
-                self.debug_abbrev_index = try self.addSectionSymbol(gpa, ".debug_abbrev", .@"1", osec);
-                elf_file.sections.items(.last_atom)[osec] = self.symbol(self.debug_abbrev_index.?).ref;
+                self.debug_abbrev_index = try addSectionSymbolWithAtom(self, gpa, ".debug_abbrev", .@"1", osec);
             }
 
             if (self.debug_aranges_index == null) {
@@ -143,8 +162,7 @@ pub fn init(self: *ZigObject, elf_file: *Elf, options: InitOptions) !void {
                     .addralign = 16,
                 });
                 self.debug_aranges_section_dirty = true;
-                self.debug_aranges_index = try self.addSectionSymbol(gpa, ".debug_aranges", .@"16", osec);
-                elf_file.sections.items(.last_atom)[osec] = self.symbol(self.debug_aranges_index.?).ref;
+                self.debug_aranges_index = try addSectionSymbolWithAtom(self, gpa, ".debug_aranges", .@"16", osec);
             }
 
             if (self.debug_line_index == null) {
@@ -154,8 +172,7 @@ pub fn init(self: *ZigObject, elf_file: *Elf, options: InitOptions) !void {
                     .addralign = 1,
                 });
                 self.debug_line_section_dirty = true;
-                self.debug_line_index = try self.addSectionSymbol(gpa, ".debug_line", .@"1", osec);
-                elf_file.sections.items(.last_atom)[osec] = self.symbol(self.debug_line_index.?).ref;
+                self.debug_line_index = try addSectionSymbolWithAtom(self, gpa, ".debug_line", .@"1", osec);
             }
 
             if (self.debug_line_str_index == null) {
@@ -167,8 +184,7 @@ pub fn init(self: *ZigObject, elf_file: *Elf, options: InitOptions) !void {
                     .addralign = 1,
                 });
                 self.debug_line_str_section_dirty = true;
-                self.debug_line_str_index = try self.addSectionSymbol(gpa, ".debug_line_str", .@"1", osec);
-                elf_file.sections.items(.last_atom)[osec] = self.symbol(self.debug_line_str_index.?).ref;
+                self.debug_line_str_index = try addSectionSymbolWithAtom(self, gpa, ".debug_line_str", .@"1", osec);
             }
 
             if (self.debug_loclists_index == null) {
@@ -178,8 +194,7 @@ pub fn init(self: *ZigObject, elf_file: *Elf, options: InitOptions) !void {
                     .addralign = 1,
                 });
                 self.debug_loclists_section_dirty = true;
-                self.debug_loclists_index = try self.addSectionSymbol(gpa, ".debug_loclists", .@"1", osec);
-                elf_file.sections.items(.last_atom)[osec] = self.symbol(self.debug_loclists_index.?).ref;
+                self.debug_loclists_index = try addSectionSymbolWithAtom(self, gpa, ".debug_loclists", .@"1", osec);
             }
 
             if (self.debug_rnglists_index == null) {
@@ -189,8 +204,7 @@ pub fn init(self: *ZigObject, elf_file: *Elf, options: InitOptions) !void {
                     .addralign = 1,
                 });
                 self.debug_rnglists_section_dirty = true;
-                self.debug_rnglists_index = try self.addSectionSymbol(gpa, ".debug_rnglists", .@"1", osec);
-                elf_file.sections.items(.last_atom)[osec] = self.symbol(self.debug_rnglists_index.?).ref;
+                self.debug_rnglists_index = try addSectionSymbolWithAtom(self, gpa, ".debug_rnglists", .@"1", osec);
             }
 
             if (self.eh_frame_index == null) {
@@ -204,8 +218,7 @@ pub fn init(self: *ZigObject, elf_file: *Elf, options: InitOptions) !void {
                     .addralign = ptr_size,
                 });
                 self.eh_frame_section_dirty = true;
-                self.eh_frame_index = try self.addSectionSymbol(gpa, ".eh_frame", Atom.Alignment.fromNonzeroByteUnits(ptr_size), osec);
-                elf_file.sections.items(.last_atom)[osec] = self.symbol(self.eh_frame_index.?).ref;
+                self.eh_frame_index = try addSectionSymbolWithAtom(self, gpa, ".eh_frame", Atom.Alignment.fromNonzeroByteUnits(ptr_size), osec);
             }
 
             try dwarf.initMetadata();
@@ -336,8 +349,6 @@ pub fn flushModule(self: *ZigObject, elf_file: *Elf, tid: Zcu.PerThread.Id) !voi
             const atom_ptr = self.atom(sym.ref.index).?;
             if (!atom_ptr.alive) continue;
 
-            log.debug("parsing relocs in {s}", .{sym.name(elf_file)});
-
             const relocs = &self.relocs.items[atom_ptr.relocsShndx().?];
             for (sect.units.items) |*unit| {
                 try relocs.ensureUnusedCapacity(gpa, unit.cross_unit_relocs.items.len +
@@ -350,12 +361,6 @@ pub fn flushModule(self: *ZigObject, elf_file: *Elf, tid: Zcu.PerThread.Id) !voi
                     else
                         0));
                     const r_type = relocation.dwarf.crossSectionRelocType(dwarf.format, cpu_arch);
-                    log.debug("  {s} <- r_off={x}, r_add={x}, r_type={}", .{
-                        self.symbol(sym_index).name(elf_file),
-                        r_offset,
-                        r_addend,
-                        relocation.fmtRelocType(r_type, cpu_arch),
-                    });
                     atom_ptr.addRelocAssumeCapacity(.{
                         .r_offset = r_offset,
                         .r_addend = r_addend,
@@ -384,12 +389,6 @@ pub fn flushModule(self: *ZigObject, elf_file: *Elf, tid: Zcu.PerThread.Id) !voi
                     else
                         0));
                     const r_type = relocation.dwarf.crossSectionRelocType(dwarf.format, cpu_arch);
-                    log.debug("  {s} <- r_off={x}, r_add={x}, r_type={}", .{
-                        self.symbol(target_sym_index).name(elf_file),
-                        r_offset,
-                        r_addend,
-                        relocation.fmtRelocType(r_type, cpu_arch),
-                    });
                     atom_ptr.addRelocAssumeCapacity(.{
                         .r_offset = r_offset,
                         .r_addend = r_addend,
@@ -410,12 +409,6 @@ pub fn flushModule(self: *ZigObject, elf_file: *Elf, tid: Zcu.PerThread.Id) !voi
                         else
                             0));
                         const r_type = relocation.dwarf.crossSectionRelocType(dwarf.format, cpu_arch);
-                        log.debug("  {s} <- r_off={x}, r_add={x}, r_type={}", .{
-                            self.symbol(sym_index).name(elf_file),
-                            r_offset,
-                            r_addend,
-                            relocation.fmtRelocType(r_type, cpu_arch),
-                        });
                         atom_ptr.addRelocAssumeCapacity(.{
                             .r_offset = r_offset,
                             .r_addend = r_addend,
@@ -430,12 +423,6 @@ pub fn flushModule(self: *ZigObject, elf_file: *Elf, tid: Zcu.PerThread.Id) !voi
                         else
                             0));
                         const r_type = relocation.dwarf.crossSectionRelocType(dwarf.format, cpu_arch);
-                        log.debug("  {s} <- r_off={x}, r_add={x}, r_type={}", .{
-                            self.symbol(sym_index).name(elf_file),
-                            r_offset,
-                            r_addend,
-                            relocation.fmtRelocType(r_type, cpu_arch),
-                        });
                         atom_ptr.addRelocAssumeCapacity(.{
                             .r_offset = r_offset,
                             .r_addend = r_addend,
@@ -464,12 +451,6 @@ pub fn flushModule(self: *ZigObject, elf_file: *Elf, tid: Zcu.PerThread.Id) !voi
                         else
                             0));
                         const r_type = relocation.dwarf.crossSectionRelocType(dwarf.format, cpu_arch);
-                        log.debug("  {s} <- r_off={x}, r_add={x}, r_type={}", .{
-                            self.symbol(target_sym_index).name(elf_file),
-                            r_offset,
-                            r_addend,
-                            relocation.fmtRelocType(r_type, cpu_arch),
-                        });
                         atom_ptr.addRelocAssumeCapacity(.{
                             .r_offset = r_offset,
                             .r_addend = r_addend,
@@ -481,12 +462,6 @@ pub fn flushModule(self: *ZigObject, elf_file: *Elf, tid: Zcu.PerThread.Id) !voi
                         const r_offset = entry_off + reloc.source_off;
                         const r_addend: i64 = @intCast(reloc.target_off);
                         const r_type = relocation.dwarf.externalRelocType(target_sym.*, sect_index, dwarf.address_size, cpu_arch);
-                        log.debug("  {s} <- r_off={x}, r_add={x}, r_type={}", .{
-                            target_sym.name(elf_file),
-                            r_offset,
-                            r_addend,
-                            relocation.fmtRelocType(r_type, cpu_arch),
-                        });
                         atom_ptr.addRelocAssumeCapacity(.{
                             .r_offset = r_offset,
                             .r_addend = r_addend,
@@ -603,12 +578,6 @@ pub fn resolveSymbols(self: *ZigObject, elf_file: *Elf) !void {
         const global = &self.symbols.items[index];
         const esym = global.elfSym(elf_file);
         const shndx = self.symtab.items(.shndx)[global.esym_index];
-        if (esym.st_shndx != elf.SHN_ABS and esym.st_shndx != elf.SHN_COMMON and esym.st_shndx != elf.SHN_UNDEF) {
-            assert(esym.st_shndx == SHN_ATOM);
-            const atom_ptr = self.atom(shndx) orelse continue;
-            if (!atom_ptr.alive) continue;
-        }
-
         const resolv = &self.symbols_resolver.items[i];
         const gop = try elf_file.resolver.getOrPut(gpa, .{
             .index = @intCast(i | global_symbol_bit),
@@ -620,6 +589,11 @@ pub fn resolveSymbols(self: *ZigObject, elf_file: *Elf) !void {
         resolv.* = gop.index;
 
         if (esym.st_shndx == elf.SHN_UNDEF) continue;
+        if (esym.st_shndx != elf.SHN_ABS and esym.st_shndx != elf.SHN_COMMON) {
+            assert(esym.st_shndx == SHN_ATOM);
+            const atom_ptr = self.atom(shndx) orelse continue;
+            if (!atom_ptr.alive) continue;
+        }
         if (elf_file.symbol(gop.ref.*) == null) {
             gop.ref.* = .{ .index = @intCast(i | global_symbol_bit), .file = self.index };
             continue;
@@ -800,7 +774,7 @@ pub fn updateArSize(self: *ZigObject) void {
 }
 
 pub fn writeAr(self: ZigObject, writer: anytype) !void {
-    const name = self.path;
+    const name = self.basename;
     const hdr = Archive.setArHdr(.{
         .name = if (name.len <= Archive.max_member_name_len)
             .{ .name = name }
@@ -1036,16 +1010,15 @@ pub fn lowerUav(
     }
 
     const osec = if (self.data_relro_index) |sym_index|
-        self.symbol(sym_index).atom(elf_file).?.output_section_index
+        self.symbol(sym_index).outputShndx(elf_file).?
     else osec: {
         const osec = try elf_file.addSection(.{
             .name = try elf_file.insertShString(".data.rel.ro"),
             .type = elf.SHT_PROGBITS,
             .addralign = 1,
             .flags = elf.SHF_ALLOC | elf.SHF_WRITE,
-            .offset = std.math.maxInt(u64),
         });
-        self.data_relro_index = try self.addSectionSymbol(gpa, ".data.rel.ro", .@"1", osec);
+        self.data_relro_index = try self.addSectionSymbol(gpa, try self.addString(gpa, ".data.rel.ro"), osec);
         break :osec osec;
     };
 
@@ -1151,24 +1124,14 @@ pub fn getOrCreateMetadataForNav(
     return gop.value_ptr.symbol_index;
 }
 
-// FIXME: we always create an atom to basically store size and alignment, however, this is only true for
-// sections that have a single atom like the debug sections. It would be a better solution to decouple this
-// concept from the atom, maybe.
-fn addSectionSymbol(
-    self: *ZigObject,
-    allocator: Allocator,
-    name: [:0]const u8,
-    alignment: Atom.Alignment,
-    shndx: u32,
-) !Symbol.Index {
-    const name_off = try self.addString(allocator, name);
-    const index = try self.newSymbolWithAtom(allocator, name_off);
+fn addSectionSymbol(self: *ZigObject, allocator: Allocator, name_off: u32, shndx: u32) !Symbol.Index {
+    const index = try self.newLocalSymbol(allocator, name_off);
     const sym = self.symbol(index);
     const esym = &self.symtab.items(.elf_sym)[sym.esym_index];
     esym.st_info |= elf.STT_SECTION;
-    const atom_ptr = self.atom(sym.ref.index).?;
-    atom_ptr.alignment = alignment;
-    atom_ptr.output_section_index = shndx;
+    // TODO create fake shdrs?
+    // esym.st_shndx = shndx;
+    sym.output_section_index = shndx;
     return index;
 }
 
@@ -1187,15 +1150,14 @@ fn getNavShdrIndex(
     const nav_val = zcu.navValue(nav_index);
     if (ip.isFunctionType(nav_val.typeOf(zcu).toIntern())) {
         if (self.text_index) |symbol_index|
-            return self.symbol(symbol_index).atom(elf_file).?.output_section_index;
+            return self.symbol(symbol_index).outputShndx(elf_file).?;
         const osec = try elf_file.addSection(.{
             .type = elf.SHT_PROGBITS,
             .flags = elf.SHF_ALLOC | elf.SHF_EXECINSTR,
             .name = try elf_file.insertShString(".text"),
             .addralign = 1,
-            .offset = std.math.maxInt(u64),
         });
-        self.text_index = try self.addSectionSymbol(gpa, ".text", .@"1", osec);
+        self.text_index = try self.addSectionSymbol(gpa, try self.addString(gpa, ".text"), osec);
         return osec;
     }
     const is_const, const is_threadlocal, const nav_init = switch (ip.indexToKey(nav_val.toIntern())) {
@@ -1210,71 +1172,63 @@ fn getNavShdrIndex(
         } else true;
         if (is_bss) {
             if (self.tbss_index) |symbol_index|
-                return self.symbol(symbol_index).atom(elf_file).?.output_section_index;
+                return self.symbol(symbol_index).outputShndx(elf_file).?;
             const osec = try elf_file.addSection(.{
                 .name = try elf_file.insertShString(".tbss"),
                 .flags = elf.SHF_ALLOC | elf.SHF_WRITE | elf.SHF_TLS,
                 .type = elf.SHT_NOBITS,
                 .addralign = 1,
             });
-            self.tbss_index = try self.addSectionSymbol(gpa, ".tbss", .@"1", osec);
+            self.tbss_index = try self.addSectionSymbol(gpa, try self.addString(gpa, ".tbss"), osec);
             return osec;
         }
         if (self.tdata_index) |symbol_index|
-            return self.symbol(symbol_index).atom(elf_file).?.output_section_index;
+            return self.symbol(symbol_index).outputShndx(elf_file).?;
         const osec = try elf_file.addSection(.{
             .type = elf.SHT_PROGBITS,
             .flags = elf.SHF_ALLOC | elf.SHF_WRITE | elf.SHF_TLS,
             .name = try elf_file.insertShString(".tdata"),
             .addralign = 1,
-            .offset = std.math.maxInt(u64),
         });
-        self.tdata_index = try self.addSectionSymbol(gpa, ".tdata", .@"1", osec);
+        self.tdata_index = try self.addSectionSymbol(gpa, try self.addString(gpa, ".tdata"), osec);
         return osec;
     }
     if (is_const) {
         if (self.data_relro_index) |symbol_index|
-            return self.symbol(symbol_index).atom(elf_file).?.output_section_index;
+            return self.symbol(symbol_index).outputShndx(elf_file).?;
         const osec = try elf_file.addSection(.{
             .name = try elf_file.insertShString(".data.rel.ro"),
             .type = elf.SHT_PROGBITS,
             .addralign = 1,
             .flags = elf.SHF_ALLOC | elf.SHF_WRITE,
-            .offset = std.math.maxInt(u64),
         });
-        self.data_relro_index = try self.addSectionSymbol(gpa, ".data.rel.ro", .@"1", osec);
+        self.data_relro_index = try self.addSectionSymbol(gpa, try self.addString(gpa, ".data.rel.ro"), osec);
         return osec;
     }
     if (nav_init != .none and Value.fromInterned(nav_init).isUndefDeep(zcu))
         return switch (zcu.navFileScope(nav_index).mod.optimize_mode) {
             .Debug, .ReleaseSafe => {
                 if (self.data_index) |symbol_index|
-                    return self.symbol(symbol_index).atom(elf_file).?.output_section_index;
+                    return self.symbol(symbol_index).outputShndx(elf_file).?;
                 const osec = try elf_file.addSection(.{
                     .name = try elf_file.insertShString(".data"),
                     .type = elf.SHT_PROGBITS,
                     .addralign = ptr_size,
                     .flags = elf.SHF_ALLOC | elf.SHF_WRITE,
-                    .offset = std.math.maxInt(u64),
                 });
-                self.data_index = try self.addSectionSymbol(
-                    gpa,
-                    ".data",
-                    Atom.Alignment.fromNonzeroByteUnits(ptr_size),
-                    osec,
-                );
+                self.data_index = try self.addSectionSymbol(gpa, try self.addString(gpa, ".data"), osec);
                 return osec;
             },
             .ReleaseFast, .ReleaseSmall => {
                 if (self.bss_index) |symbol_index|
-                    return self.symbol(symbol_index).atom(elf_file).?.output_section_index;
+                    return self.symbol(symbol_index).outputShndx(elf_file).?;
                 const osec = try elf_file.addSection(.{
                     .type = elf.SHT_NOBITS,
                     .flags = elf.SHF_ALLOC | elf.SHF_WRITE,
                     .name = try elf_file.insertShString(".bss"),
                     .addralign = 1,
                 });
-                self.bss_index = try self.addSectionSymbol(gpa, ".bss", .@"1", osec);
+                self.bss_index = try self.addSectionSymbol(gpa, try self.addString(gpa, ".bss"), osec);
                 return osec;
             },
         };
@@ -1283,31 +1237,25 @@ fn getNavShdrIndex(
     } else true;
     if (is_bss) {
         if (self.bss_index) |symbol_index|
-            return self.symbol(symbol_index).atom(elf_file).?.output_section_index;
+            return self.symbol(symbol_index).outputShndx(elf_file).?;
         const osec = try elf_file.addSection(.{
             .type = elf.SHT_NOBITS,
             .flags = elf.SHF_ALLOC | elf.SHF_WRITE,
             .name = try elf_file.insertShString(".bss"),
             .addralign = 1,
         });
-        self.bss_index = try self.addSectionSymbol(gpa, ".bss", .@"1", osec);
+        self.bss_index = try self.addSectionSymbol(gpa, try self.addString(gpa, ".bss"), osec);
         return osec;
     }
     if (self.data_index) |symbol_index|
-        return self.symbol(symbol_index).atom(elf_file).?.output_section_index;
+        return self.symbol(symbol_index).outputShndx(elf_file).?;
     const osec = try elf_file.addSection(.{
         .name = try elf_file.insertShString(".data"),
         .type = elf.SHT_PROGBITS,
         .addralign = ptr_size,
         .flags = elf.SHF_ALLOC | elf.SHF_WRITE,
-        .offset = std.math.maxInt(u64),
     });
-    self.data_index = try self.addSectionSymbol(
-        gpa,
-        ".data",
-        Atom.Alignment.fromNonzeroByteUnits(ptr_size),
-        osec,
-    );
+    self.data_index = try self.addSectionSymbol(gpa, try self.addString(gpa, ".data"), osec);
     return osec;
 }
 
@@ -1355,7 +1303,7 @@ fn updateNavCode(
         const capacity = atom_ptr.capacity(elf_file);
         const need_realloc = code.len > capacity or !required_alignment.check(@intCast(atom_ptr.value));
         if (need_realloc) {
-            try self.growAtom(atom_ptr, elf_file);
+            try self.allocateAtom(atom_ptr, true, elf_file);
             log.debug("growing {} from 0x{x} to 0x{x}", .{ nav.fqn.fmt(ip), old_vaddr, atom_ptr.value });
             if (old_vaddr != atom_ptr.value) {
                 sym.value = 0;
@@ -1365,7 +1313,7 @@ fn updateNavCode(
             // TODO shrink section size
         }
     } else {
-        try self.allocateAtom(atom_ptr, elf_file);
+        try self.allocateAtom(atom_ptr, true, elf_file);
         errdefer self.freeNavMetadata(elf_file, sym_index);
         sym.value = 0;
         esym.st_value = 0;
@@ -1440,7 +1388,7 @@ fn updateTlv(
     const gop = try self.tls_variables.getOrPut(gpa, atom_ptr.atom_index);
     assert(!gop.found_existing); // TODO incremental updates
 
-    try self.allocateAtom(atom_ptr, elf_file);
+    try self.allocateAtom(atom_ptr, true, elf_file);
     sym.value = 0;
     esym.st_value = 0;
 
@@ -1558,9 +1506,8 @@ pub fn updateFunc(
                     .flags = elf.SHF_ALLOC | elf.SHF_EXECINSTR,
                     .type = elf.SHT_PROGBITS,
                     .addralign = 1,
-                    .offset = std.math.maxInt(u64),
                 });
-                self.text_index = try self.addSectionSymbol(gpa, ".text", .@"1", osec);
+                self.text_index = try self.addSectionSymbol(gpa, try self.addString(gpa, ".text"), osec);
                 break :osec osec;
             };
             const name_off = try self.addString(gpa, name);
@@ -1727,29 +1674,27 @@ fn updateLazySymbol(
 
     const output_section_index = switch (sym.kind) {
         .code => if (self.text_index) |sym_index|
-            self.symbol(sym_index).atom(elf_file).?.output_section_index
+            self.symbol(sym_index).outputShndx(elf_file).?
         else osec: {
             const osec = try elf_file.addSection(.{
                 .name = try elf_file.insertShString(".text"),
                 .type = elf.SHT_PROGBITS,
                 .addralign = 1,
                 .flags = elf.SHF_ALLOC | elf.SHF_EXECINSTR,
-                .offset = std.math.maxInt(u64),
             });
-            self.text_index = try self.addSectionSymbol(gpa, ".text", .@"1", osec);
+            self.text_index = try self.addSectionSymbol(gpa, try self.addString(gpa, ".text"), osec);
             break :osec osec;
         },
         .const_data => if (self.rodata_index) |sym_index|
-            self.symbol(sym_index).atom(elf_file).?.output_section_index
+            self.symbol(sym_index).outputShndx(elf_file).?
         else osec: {
             const osec = try elf_file.addSection(.{
                 .name = try elf_file.insertShString(".rodata"),
                 .type = elf.SHT_PROGBITS,
                 .addralign = 1,
                 .flags = elf.SHF_ALLOC,
-                .offset = std.math.maxInt(u64),
             });
-            self.rodata_index = try self.addSectionSymbol(gpa, ".rodata", .@"1", osec);
+            self.rodata_index = try self.addSectionSymbol(gpa, try self.addString(gpa, ".rodata"), osec);
             break :osec osec;
         },
     };
@@ -1766,7 +1711,7 @@ fn updateLazySymbol(
     atom_ptr.size = code.len;
     atom_ptr.output_section_index = output_section_index;
 
-    try self.allocateAtom(atom_ptr, elf_file);
+    try self.allocateAtom(atom_ptr, true, elf_file);
     errdefer self.freeNavMetadata(elf_file, symbol_index);
 
     local_sym.value = 0;
@@ -1821,7 +1766,7 @@ fn lowerConst(
     atom_ptr.size = code.len;
     atom_ptr.output_section_index = output_section_index;
 
-    try self.allocateAtom(atom_ptr, elf_file);
+    try self.allocateAtom(atom_ptr, true, elf_file);
     errdefer self.freeNavMetadata(elf_file, sym_index);
 
     try elf_file.base.file.?.pwriteAll(code, atom_ptr.offset(elf_file));
@@ -2018,17 +1963,27 @@ fn writeTrampoline(tr_sym: Symbol, target: Symbol, elf_file: *Elf) !void {
     }
 }
 
-fn allocateAtom(self: *ZigObject, atom_ptr: *Atom, elf_file: *Elf) !void {
+pub fn allocateAtom(self: *ZigObject, atom_ptr: *Atom, requires_padding: bool, elf_file: *Elf) !void {
+    const slice = elf_file.sections.slice();
+    const shdr = &slice.items(.shdr)[atom_ptr.output_section_index];
+    const last_atom_ref = &slice.items(.last_atom)[atom_ptr.output_section_index];
+
+    // FIXME:JK this only works if this atom is the only atom in the output section
+    // In every other case, we need to redo the prev/next links
+    if (last_atom_ref.eql(atom_ptr.ref())) last_atom_ref.* = .{};
+
     const alloc_res = try elf_file.allocateChunk(.{
         .shndx = atom_ptr.output_section_index,
         .size = atom_ptr.size,
         .alignment = atom_ptr.alignment,
+        .requires_padding = requires_padding,
     });
     atom_ptr.value = @intCast(alloc_res.value);
-
-    const slice = elf_file.sections.slice();
-    const shdr = &slice.items(.shdr)[atom_ptr.output_section_index];
-    const last_atom_ref = &slice.items(.last_atom)[atom_ptr.output_section_index];
+    log.debug("allocated {s} at {x}\n  placement {?}", .{
+        atom_ptr.name(elf_file),
+        atom_ptr.offset(elf_file),
+        alloc_res.placement,
+    });
 
     const expand_section = if (elf_file.atom(alloc_res.placement)) |placement_atom|
         placement_atom.nextAtom(elf_file) == null
@@ -2050,22 +2005,6 @@ fn allocateAtom(self: *ZigObject, atom_ptr: *Atom, elf_file: *Elf) !void {
     }
     shdr.sh_addralign = @max(shdr.sh_addralign, atom_ptr.alignment.toByteUnits().?);
 
-    const sect_atom_ptr = for ([_]?Symbol.Index{
-        self.text_index,
-        self.rodata_index,
-        self.data_relro_index,
-        self.data_index,
-        self.tdata_index,
-    }) |maybe_sym_index| {
-        const sect_sym_index = maybe_sym_index orelse continue;
-        const sect_atom_ptr = self.symbol(sect_sym_index).atom(elf_file).?;
-        if (sect_atom_ptr.output_section_index == atom_ptr.output_section_index) break sect_atom_ptr;
-    } else null;
-    if (sect_atom_ptr) |sap| {
-        sap.size = shdr.sh_size;
-        sap.alignment = Atom.Alignment.fromNonzeroByteUnits(shdr.sh_addralign);
-    }
-
     // This function can also reallocate an atom.
     // In this case we need to "unplug" it from its previous location before
     // plugging it in to its new location.
@@ -2084,11 +2023,37 @@ fn allocateAtom(self: *ZigObject, atom_ptr: *Atom, elf_file: *Elf) !void {
         atom_ptr.prev_atom_ref = .{ .index = 0, .file = 0 };
         atom_ptr.next_atom_ref = .{ .index = 0, .file = 0 };
     }
+
+    log.debug("  prev {?}, next {?}", .{ atom_ptr.prev_atom_ref, atom_ptr.next_atom_ref });
 }
 
-fn growAtom(self: *ZigObject, atom_ptr: *Atom, elf_file: *Elf) !void {
-    if (!atom_ptr.alignment.check(@intCast(atom_ptr.value)) or atom_ptr.size > atom_ptr.capacity(elf_file)) {
-        try self.allocateAtom(atom_ptr, elf_file);
+pub fn resetShdrIndexes(self: *ZigObject, backlinks: anytype) void {
+    for (self.atoms_indexes.items) |atom_index| {
+        const atom_ptr = self.atom(atom_index) orelse continue;
+        atom_ptr.output_section_index = backlinks[atom_ptr.output_section_index];
+    }
+    inline for ([_]?Symbol.Index{
+        self.text_index,
+        self.rodata_index,
+        self.data_relro_index,
+        self.data_index,
+        self.bss_index,
+        self.tdata_index,
+        self.tbss_index,
+        self.eh_frame_index,
+        self.debug_info_index,
+        self.debug_abbrev_index,
+        self.debug_aranges_index,
+        self.debug_str_index,
+        self.debug_line_index,
+        self.debug_line_str_index,
+        self.debug_loclists_index,
+        self.debug_rnglists_index,
+    }) |maybe_sym_index| {
+        if (maybe_sym_index) |sym_index| {
+            const sym = self.symbol(sym_index);
+            sym.output_section_index = backlinks[sym.output_section_index];
+        }
     }
 }
 
@@ -2096,6 +2061,33 @@ pub fn asFile(self: *ZigObject) File {
     return .{ .zig_object = self };
 }
 
+pub fn sectionSymbol(self: *ZigObject, shndx: u32, elf_file: *Elf) ?*Symbol {
+    inline for ([_]?Symbol.Index{
+        self.text_index,
+        self.rodata_index,
+        self.data_relro_index,
+        self.data_index,
+        self.bss_index,
+        self.tdata_index,
+        self.tbss_index,
+        self.eh_frame_index,
+        self.debug_info_index,
+        self.debug_abbrev_index,
+        self.debug_aranges_index,
+        self.debug_str_index,
+        self.debug_line_index,
+        self.debug_line_str_index,
+        self.debug_loclists_index,
+        self.debug_rnglists_index,
+    }) |maybe_sym_index| {
+        if (maybe_sym_index) |sym_index| {
+            const sym = self.symbol(sym_index);
+            if (sym.outputShndx(elf_file) == shndx) return sym;
+        }
+    }
+    return null;
+}
+
 pub fn addString(self: *ZigObject, allocator: Allocator, string: []const u8) !u32 {
     return self.strtab.insert(allocator, string);
 }
@@ -2392,9 +2384,9 @@ const relocation = @import("relocation.zig");
 const target_util = @import("../../target.zig");
 const trace = @import("../../tracy.zig").trace;
 const std = @import("std");
+const Allocator = std.mem.Allocator;
 
 const Air = @import("../../Air.zig");
-const Allocator = std.mem.Allocator;
 const Archive = @import("Archive.zig");
 const Atom = @import("Atom.zig");
 const Dwarf = @import("../Dwarf.zig");
diff --git a/zig/src/link/Elf/file.zig b/zig/src/link/Elf/file.zig
index 88dc807274..6eb4c2201f 100644
--- a/zig/src/link/Elf/file.zig
+++ b/zig/src/link/Elf/file.zig
@@ -23,10 +23,10 @@ pub const File = union(enum) {
         _ = unused_fmt_string;
         _ = options;
         switch (file) {
-            .zig_object => |x| try writer.print("{s}", .{x.path}),
+            .zig_object => |zo| try writer.writeAll(zo.basename),
             .linker_defined => try writer.writeAll("(linker defined)"),
             .object => |x| try writer.print("{}", .{x.fmtPath()}),
-            .shared_object => |x| try writer.writeAll(x.path),
+            .shared_object => |x| try writer.print("{}", .{@as(Path, x.path)}),
         }
     }
 
@@ -95,19 +95,19 @@ pub const File = union(enum) {
                     log.debug("'{s}' is non-local", .{sym.name(ef)});
                     try ef.dynsym.addSymbol(ref, ef);
                 }
-                if (sym.flags.needs_got) {
+                if (sym.flags.needs_got and !sym.flags.has_got) {
                     log.debug("'{s}' needs GOT", .{sym.name(ef)});
                     _ = try ef.got.addGotSymbol(ref, ef);
                 }
                 if (sym.flags.needs_plt) {
-                    if (sym.flags.is_canonical) {
+                    if (sym.flags.is_canonical and !sym.flags.has_plt) {
                         log.debug("'{s}' needs CPLT", .{sym.name(ef)});
                         sym.flags.@"export" = true;
                         try ef.plt.addSymbol(ref, ef);
-                    } else if (sym.flags.needs_got) {
+                    } else if (sym.flags.needs_got and !sym.flags.has_pltgot) {
                         log.debug("'{s}' needs PLTGOT", .{sym.name(ef)});
                         try ef.plt_got.addSymbol(ref, ef);
-                    } else {
+                    } else if (!sym.flags.has_plt) {
                         log.debug("'{s}' needs PLT", .{sym.name(ef)});
                         try ef.plt.addSymbol(ref, ef);
                     }
@@ -116,15 +116,15 @@ pub const File = union(enum) {
                     log.debug("'{s}' needs COPYREL", .{sym.name(ef)});
                     try ef.copy_rel.addSymbol(ref, ef);
                 }
-                if (sym.flags.needs_tlsgd) {
+                if (sym.flags.needs_tlsgd and !sym.flags.has_tlsgd) {
                     log.debug("'{s}' needs TLSGD", .{sym.name(ef)});
                     try ef.got.addTlsGdSymbol(ref, ef);
                 }
-                if (sym.flags.needs_gottp) {
+                if (sym.flags.needs_gottp and !sym.flags.has_gottp) {
                     log.debug("'{s}' needs GOTTP", .{sym.name(ef)});
                     try ef.got.addGotTpSymbol(ref, ef);
                 }
-                if (sym.flags.needs_tlsdesc) {
+                if (sym.flags.needs_tlsdesc and !sym.flags.has_tlsdesc) {
                     log.debug("'{s}' needs TLSDESC", .{sym.name(ef)});
                     try ef.got.addTlsDescSymbol(ref, ef);
                 }
@@ -240,30 +240,31 @@ pub const File = union(enum) {
         return switch (file) {
             .zig_object => |x| x.updateArSymtab(ar_symtab, elf_file),
             .object => |x| x.updateArSymtab(ar_symtab, elf_file),
-            inline else => unreachable,
+            else => unreachable,
         };
     }
 
     pub fn updateArStrtab(file: File, allocator: Allocator, ar_strtab: *Archive.ArStrtab) !void {
-        const path = switch (file) {
-            .zig_object => |x| x.path,
-            .object => |x| x.path,
-            inline else => unreachable,
-        };
-        const state = switch (file) {
-            .zig_object => |x| &x.output_ar_state,
-            .object => |x| &x.output_ar_state,
-            inline else => unreachable,
-        };
-        if (path.len <= Archive.max_member_name_len) return;
-        state.name_off = try ar_strtab.insert(allocator, path);
+        switch (file) {
+            .zig_object => |zo| {
+                const basename = zo.basename;
+                if (basename.len <= Archive.max_member_name_len) return;
+                zo.output_ar_state.name_off = try ar_strtab.insert(allocator, basename);
+            },
+            .object => |o| {
+                const basename = std.fs.path.basename(o.path.sub_path);
+                if (basename.len <= Archive.max_member_name_len) return;
+                o.output_ar_state.name_off = try ar_strtab.insert(allocator, basename);
+            },
+            else => unreachable,
+        }
     }
 
     pub fn updateArSize(file: File, elf_file: *Elf) !void {
         return switch (file) {
             .zig_object => |x| x.updateArSize(),
             .object => |x| x.updateArSize(elf_file),
-            inline else => unreachable,
+            else => unreachable,
         };
     }
 
@@ -271,7 +272,7 @@ pub const File = union(enum) {
         return switch (file) {
             .zig_object => |x| x.writeAr(writer),
             .object => |x| x.writeAr(elf_file, writer),
-            inline else => unreachable,
+            else => unreachable,
         };
     }
 
@@ -292,8 +293,9 @@ pub const File = union(enum) {
 const std = @import("std");
 const elf = std.elf;
 const log = std.log.scoped(.link);
-
+const Path = std.Build.Cache.Path;
 const Allocator = std.mem.Allocator;
+
 const Archive = @import("Archive.zig");
 const Atom = @import("Atom.zig");
 const Cie = @import("eh_frame.zig").Cie;
diff --git a/zig/src/link/Elf/merge_section.zig b/zig/src/link/Elf/merge_section.zig
index cf6506a9ea..dc6239d738 100644
--- a/zig/src/link/Elf/merge_section.zig
+++ b/zig/src/link/Elf/merge_section.zig
@@ -95,6 +95,10 @@ pub const MergeSection = struct {
     }
 
     pub fn updateSize(msec: *MergeSection) void {
+        // TODO a 'stale' flag would be better here perhaps?
+        msec.size = 0;
+        msec.alignment = .@"1";
+        msec.entsize = 0;
         for (msec.finalized_subsections.items) |msub_index| {
             const msub = msec.mergeSubsection(msub_index);
             assert(msub.alive);
diff --git a/zig/src/link/Elf/relocatable.zig b/zig/src/link/Elf/relocatable.zig
index 5fc0d5790b..bdf0d378ff 100644
--- a/zig/src/link/Elf/relocatable.zig
+++ b/zig/src/link/Elf/relocatable.zig
@@ -1,36 +1,24 @@
-pub fn flushStaticLib(elf_file: *Elf, comp: *Compilation, module_obj_path: ?[]const u8) link.File.FlushError!void {
+pub fn flushStaticLib(elf_file: *Elf, comp: *Compilation, module_obj_path: ?Path) link.File.FlushError!void {
     const gpa = comp.gpa;
 
-    var positionals = std.ArrayList(Compilation.LinkObject).init(gpa);
-    defer positionals.deinit();
-
-    try positionals.ensureUnusedCapacity(comp.objects.len);
-    positionals.appendSliceAssumeCapacity(comp.objects);
+    for (comp.objects) |obj| {
+        switch (Compilation.classifyFileExt(obj.path.sub_path)) {
+            .object => try parseObjectStaticLibReportingFailure(elf_file, obj.path),
+            .static_library => try parseArchiveStaticLibReportingFailure(elf_file, obj.path),
+            else => try elf_file.addParseError(obj.path, "unrecognized file extension", .{}),
+        }
+    }
 
     for (comp.c_object_table.keys()) |key| {
-        try positionals.append(.{ .path = key.status.success.object_path });
+        try parseObjectStaticLibReportingFailure(elf_file, key.status.success.object_path);
     }
 
-    if (module_obj_path) |path| try positionals.append(.{ .path = path });
+    if (module_obj_path) |path| {
+        try parseObjectStaticLibReportingFailure(elf_file, path);
+    }
 
     if (comp.include_compiler_rt) {
-        try positionals.append(.{ .path = comp.compiler_rt_obj.?.full_object_path });
-    }
-
-    for (positionals.items) |obj| {
-        parsePositionalStaticLib(elf_file, obj.path) catch |err| switch (err) {
-            error.MalformedObject,
-            error.MalformedArchive,
-            error.InvalidMachineType,
-            error.MismatchedEflags,
-            => continue, // already reported
-            error.UnknownFileType => try elf_file.reportParseError(obj.path, "unknown file type for an object file", .{}),
-            else => |e| try elf_file.reportParseError(
-                obj.path,
-                "unexpected error: parsing input file failed with error {s}",
-                .{@errorName(e)},
-            ),
-        };
+        try parseObjectStaticLibReportingFailure(elf_file, comp.compiler_rt_obj.?.full_object_path);
     }
 
     if (elf_file.base.hasErrors()) return error.FlushFailure;
@@ -152,38 +140,24 @@ pub fn flushStaticLib(elf_file: *Elf, comp: *Compilation, module_obj_path: ?[]co
     if (elf_file.base.hasErrors()) return error.FlushFailure;
 }
 
-pub fn flushObject(elf_file: *Elf, comp: *Compilation, module_obj_path: ?[]const u8) link.File.FlushError!void {
-    const gpa = elf_file.base.comp.gpa;
-
-    var positionals = std.ArrayList(Compilation.LinkObject).init(gpa);
-    defer positionals.deinit();
-    try positionals.ensureUnusedCapacity(comp.objects.len);
-    positionals.appendSliceAssumeCapacity(comp.objects);
+pub fn flushObject(elf_file: *Elf, comp: *Compilation, module_obj_path: ?Path) link.File.FlushError!void {
+    for (comp.objects) |obj| {
+        if (obj.isObject()) {
+            try elf_file.parseObjectReportingFailure(obj.path);
+        } else {
+            try elf_file.parseLibraryReportingFailure(.{ .path = obj.path }, obj.must_link);
+        }
+    }
 
     // This is a set of object files emitted by clang in a single `build-exe` invocation.
     // For instance, the implicit `a.o` as compiled by `zig build-exe a.c` will end up
     // in this set.
     for (comp.c_object_table.keys()) |key| {
-        try positionals.append(.{ .path = key.status.success.object_path });
-    }
-
-    if (module_obj_path) |path| try positionals.append(.{ .path = path });
-
-    for (positionals.items) |obj| {
-        elf_file.parsePositional(obj.path, obj.must_link) catch |err| switch (err) {
-            error.MalformedObject,
-            error.MalformedArchive,
-            error.InvalidMachineType,
-            error.MismatchedEflags,
-            => continue, // already reported
-            else => |e| try elf_file.reportParseError(
-                obj.path,
-                "unexpected error: parsing input file failed with error {s}",
-                .{@errorName(e)},
-            ),
-        };
+        try elf_file.parseObjectReportingFailure(key.status.success.object_path);
     }
 
+    if (module_obj_path) |path| try elf_file.parseObjectReportingFailure(path);
+
     if (elf_file.base.hasErrors()) return error.FlushFailure;
 
     // Now, we are ready to resolve the symbols across all input files.
@@ -224,24 +198,33 @@ pub fn flushObject(elf_file: *Elf, comp: *Compilation, module_obj_path: ?[]const
     if (elf_file.base.hasErrors()) return error.FlushFailure;
 }
 
-fn parsePositionalStaticLib(elf_file: *Elf, path: []const u8) Elf.ParseError!void {
-    if (try Object.isObject(path)) {
-        try parseObjectStaticLib(elf_file, path);
-    } else if (try Archive.isArchive(path)) {
-        try parseArchiveStaticLib(elf_file, path);
-    } else return error.UnknownFileType;
-    // TODO: should we check for LD script?
-    // Actually, should we even unpack an archive?
+fn parseObjectStaticLibReportingFailure(elf_file: *Elf, path: Path) error{OutOfMemory}!void {
+    parseObjectStaticLib(elf_file, path) catch |err| switch (err) {
+        error.LinkFailure => return,
+        error.OutOfMemory => return error.OutOfMemory,
+        else => |e| try elf_file.addParseError(path, "parsing object failed: {s}", .{@errorName(e)}),
+    };
+}
+
+fn parseArchiveStaticLibReportingFailure(elf_file: *Elf, path: Path) error{OutOfMemory}!void {
+    parseArchiveStaticLib(elf_file, path) catch |err| switch (err) {
+        error.LinkFailure => return,
+        error.OutOfMemory => return error.OutOfMemory,
+        else => |e| try elf_file.addParseError(path, "parsing static library failed: {s}", .{@errorName(e)}),
+    };
 }
 
-fn parseObjectStaticLib(elf_file: *Elf, path: []const u8) Elf.ParseError!void {
+fn parseObjectStaticLib(elf_file: *Elf, path: Path) Elf.ParseError!void {
     const gpa = elf_file.base.comp.gpa;
-    const handle = try std.fs.cwd().openFile(path, .{});
+    const handle = try path.root_dir.handle.openFile(path.sub_path, .{});
     const fh = try elf_file.addFileHandle(handle);
 
-    const index = @as(File.Index, @intCast(try elf_file.files.addOne(gpa)));
+    const index: File.Index = @intCast(try elf_file.files.addOne(gpa));
     elf_file.files.set(index, .{ .object = .{
-        .path = try gpa.dupe(u8, path),
+        .path = .{
+            .root_dir = path.root_dir,
+            .sub_path = try gpa.dupe(u8, path.sub_path),
+        },
         .file_handle = fh,
         .index = index,
     } });
@@ -251,9 +234,9 @@ fn parseObjectStaticLib(elf_file: *Elf, path: []const u8) Elf.ParseError!void {
     try object.parseAr(elf_file);
 }
 
-fn parseArchiveStaticLib(elf_file: *Elf, path: []const u8) Elf.ParseError!void {
+fn parseArchiveStaticLib(elf_file: *Elf, path: Path) Elf.ParseError!void {
     const gpa = elf_file.base.comp.gpa;
-    const handle = try std.fs.cwd().openFile(path, .{});
+    const handle = try path.root_dir.handle.openFile(path.sub_path, .{});
     const fh = try elf_file.addFileHandle(handle);
 
     var archive = Archive{};
@@ -315,7 +298,6 @@ fn initSections(elf_file: *Elf) !void {
                     elf.SHT_PROGBITS,
                 .flags = elf.SHF_ALLOC,
                 .addralign = elf_file.ptrWidthBytes(),
-                .offset = std.math.maxInt(u64),
             });
         }
         elf_file.eh_frame_rela_section_index = elf_file.sectionByName(".rela.eh_frame") orelse
@@ -344,7 +326,6 @@ fn initComdatGroups(elf_file: *Elf) !void {
                     .type = elf.SHT_GROUP,
                     .entsize = @sizeOf(u32),
                     .addralign = @alignOf(u32),
-                    .offset = std.math.maxInt(u64),
                 }),
                 .cg_ref = .{ .index = @intCast(cg_index), .file = index },
             };
@@ -355,9 +336,11 @@ fn initComdatGroups(elf_file: *Elf) !void {
 fn updateSectionSizes(elf_file: *Elf) !void {
     const slice = elf_file.sections.slice();
     for (slice.items(.atom_list_2)) |*atom_list| {
-        if (atom_list.atoms.items.len == 0) continue;
+        if (atom_list.atoms.keys().len == 0) continue;
+        if (!atom_list.dirty) continue;
         atom_list.updateSize(elf_file);
         try atom_list.allocate(elf_file);
+        atom_list.dirty = false;
     }
 
     for (slice.items(.shdr), 0..) |*shdr, shndx| {
@@ -412,24 +395,14 @@ fn allocateAllocSections(elf_file: *Elf) !void {
             shdr.sh_size = 0;
             const new_offset = try elf_file.findFreeSpace(needed_size, shdr.sh_addralign);
 
-            if (elf_file.zigObjectPtr()) |zo| blk: {
-                const existing_size = for ([_]?Symbol.Index{
-                    zo.text_index,
-                    zo.rodata_index,
-                    zo.data_relro_index,
-                    zo.data_index,
-                    zo.tdata_index,
-                    zo.eh_frame_index,
-                }) |maybe_sym_index| {
-                    const sect_sym_index = maybe_sym_index orelse continue;
-                    const sect_atom_ptr = zo.symbol(sect_sym_index).atom(elf_file).?;
-                    if (sect_atom_ptr.output_section_index == shndx) break sect_atom_ptr.size;
-                } else break :blk;
-                log.debug("moving {s} from 0x{x} to 0x{x}", .{
-                    elf_file.getShString(shdr.sh_name),
-                    shdr.sh_offset,
-                    new_offset,
-                });
+            log.debug("moving {s} from 0x{x} to 0x{x}", .{
+                elf_file.getShString(shdr.sh_name),
+                shdr.sh_offset,
+                new_offset,
+            });
+
+            if (shdr.sh_offset > 0) {
+                const existing_size = elf_file.sectionSize(@intCast(shndx));
                 const amt = try elf_file.base.file.?.copyRangeAll(
                     shdr.sh_offset,
                     elf_file.base.file.?,
@@ -454,7 +427,7 @@ fn writeAtoms(elf_file: *Elf) !void {
     const slice = elf_file.sections.slice();
     for (slice.items(.shdr), slice.items(.atom_list_2)) |shdr, atom_list| {
         if (shdr.sh_type == elf.SHT_NOBITS) continue;
-        if (atom_list.atoms.items.len == 0) continue;
+        if (atom_list.atoms.keys().len == 0) continue;
         try atom_list.writeRelocatable(&buffer, elf_file);
     }
 }
@@ -561,6 +534,7 @@ const log = std.log.scoped(.link);
 const math = std.math;
 const mem = std.mem;
 const state_log = std.log.scoped(.link_state);
+const Path = std.Build.Cache.Path;
 const std = @import("std");
 
 const Archive = @import("Archive.zig");
diff --git a/zig/src/link/Elf/synthetic_sections.zig b/zig/src/link/Elf/synthetic_sections.zig
index f914bb8d84..987ee4bf9a 100644
--- a/zig/src/link/Elf/synthetic_sections.zig
+++ b/zig/src/link/Elf/synthetic_sections.zig
@@ -435,6 +435,8 @@ pub const GotSection = struct {
         const cpu_arch = elf_file.getTarget().cpu.arch;
         try elf_file.rela_dyn.ensureUnusedCapacity(gpa, got.numRela(elf_file));
 
+        relocs_log.debug(".got", .{});
+
         for (got.entries.items) |entry| {
             const symbol = elf_file.symbol(entry.ref);
             const extra = if (symbol) |s| s.extra(elf_file) else null;
@@ -447,6 +449,7 @@ pub const GotSection = struct {
                             .offset = offset,
                             .sym = extra.?.dynamic,
                             .type = relocation.encode(.glob_dat, cpu_arch),
+                            .target = symbol,
                         });
                         continue;
                     }
@@ -455,6 +458,7 @@ pub const GotSection = struct {
                             .offset = offset,
                             .type = relocation.encode(.irel, cpu_arch),
                             .addend = symbol.?.address(.{ .plt = false }, elf_file),
+                            .target = symbol,
                         });
                         continue;
                     }
@@ -465,6 +469,7 @@ pub const GotSection = struct {
                             .offset = offset,
                             .type = relocation.encode(.rel, cpu_arch),
                             .addend = symbol.?.address(.{ .plt = false }, elf_file),
+                            .target = symbol,
                         });
                     }
                 },
@@ -486,17 +491,20 @@ pub const GotSection = struct {
                             .offset = offset,
                             .sym = extra.?.dynamic,
                             .type = relocation.encode(.dtpmod, cpu_arch),
+                            .target = symbol,
                         });
                         elf_file.addRelaDynAssumeCapacity(.{
                             .offset = offset + 8,
                             .sym = extra.?.dynamic,
                             .type = relocation.encode(.dtpoff, cpu_arch),
+                            .target = symbol,
                         });
                     } else if (is_dyn_lib) {
                         elf_file.addRelaDynAssumeCapacity(.{
                             .offset = offset,
                             .sym = extra.?.dynamic,
                             .type = relocation.encode(.dtpmod, cpu_arch),
+                            .target = symbol,
                         });
                     }
                 },
@@ -508,12 +516,14 @@ pub const GotSection = struct {
                             .offset = offset,
                             .sym = extra.?.dynamic,
                             .type = relocation.encode(.tpoff, cpu_arch),
+                            .target = symbol,
                         });
                     } else if (is_dyn_lib) {
                         elf_file.addRelaDynAssumeCapacity(.{
                             .offset = offset,
                             .type = relocation.encode(.tpoff, cpu_arch),
                             .addend = symbol.?.address(.{}, elf_file) - elf_file.tlsAddress(),
+                            .target = symbol,
                         });
                     }
                 },
@@ -525,6 +535,7 @@ pub const GotSection = struct {
                         .sym = if (symbol.?.flags.import) extra.?.dynamic else 0,
                         .type = relocation.encode(.tlsdesc, cpu_arch),
                         .addend = if (symbol.?.flags.import) 0 else symbol.?.address(.{}, elf_file) - elf_file.tlsAddress(),
+                        .target = symbol,
                     });
                 },
             }
@@ -681,6 +692,9 @@ pub const PltSection = struct {
         const gpa = comp.gpa;
         const cpu_arch = elf_file.getTarget().cpu.arch;
         try elf_file.rela_plt.ensureUnusedCapacity(gpa, plt.numRela());
+
+        relocs_log.debug(".plt", .{});
+
         for (plt.symbols.items) |ref| {
             const sym = elf_file.symbol(ref).?;
             assert(sym.flags.import);
@@ -688,6 +702,14 @@ pub const PltSection = struct {
             const r_offset: u64 = @intCast(sym.gotPltAddress(elf_file));
             const r_sym: u64 = extra.dynamic;
             const r_type = relocation.encode(.jump_slot, cpu_arch);
+
+            relocs_log.debug("  {s}: [{x} => {d}({s})] + 0", .{
+                relocation.fmtRelocType(r_type, cpu_arch),
+                r_offset,
+                r_sym,
+                sym.name(elf_file),
+            });
+
             elf_file.rela_plt.appendAssumeCapacity(.{
                 .r_offset = r_offset,
                 .r_info = (r_sym << 32) | r_type,
@@ -895,8 +917,7 @@ pub const PltGotSection = struct {
         const gpa = comp.gpa;
         const index = @as(u32, @intCast(plt_got.symbols.items.len));
         const symbol = elf_file.symbol(ref).?;
-        symbol.flags.has_plt = true;
-        symbol.flags.has_got = true;
+        symbol.flags.has_pltgot = true;
         symbol.addExtra(.{ .plt_got = index }, elf_file);
         try plt_got.symbols.append(gpa, ref);
     }
@@ -1054,6 +1075,9 @@ pub const CopyRelSection = struct {
         const gpa = comp.gpa;
         const cpu_arch = elf_file.getTarget().cpu.arch;
         try elf_file.rela_dyn.ensureUnusedCapacity(gpa, copy_rel.numRela());
+
+        relocs_log.debug(".copy.rel", .{});
+
         for (copy_rel.symbols.items) |ref| {
             const sym = elf_file.symbol(ref).?;
             assert(sym.flags.import and sym.flags.has_copy_rel);
@@ -1526,6 +1550,7 @@ const elf = std.elf;
 const math = std.math;
 const mem = std.mem;
 const log = std.log.scoped(.link);
+const relocs_log = std.log.scoped(.link_relocs);
 const relocation = @import("relocation.zig");
 const std = @import("std");
 
diff --git a/zig/src/link/MachO.zig b/zig/src/link/MachO.zig
index 42923ecfba..38684e4d6a 100644
--- a/zig/src/link/MachO.zig
+++ b/zig/src/link/MachO.zig
@@ -1,5 +1,7 @@
 base: link.File,
 
+rpath_list: []const []const u8,
+
 /// If this is not null, an object file is created by LLVM and emitted to zcu_object_sub_path.
 llvm_object: ?LlvmObject.Ptr = null,
 
@@ -25,7 +27,7 @@ sections: std.MultiArrayList(Section) = .{},
 resolver: SymbolResolver = .{},
 /// This table will be populated after `scanRelocs` has run.
 /// Key is symbol index.
-undefs: std.AutoArrayHashMapUnmanaged(SymbolResolver.Index, std.ArrayListUnmanaged(Ref)) = .empty,
+undefs: std.AutoArrayHashMapUnmanaged(SymbolResolver.Index, UndefRefs) = .empty,
 undefs_mutex: std.Thread.Mutex = .{},
 dupes: std.AutoArrayHashMapUnmanaged(SymbolResolver.Index, std.ArrayListUnmanaged(File.Index)) = .empty,
 dupes_mutex: std.Thread.Mutex = .{},
@@ -142,14 +144,14 @@ hot_state: if (is_hot_update_compatible) HotUpdateState else struct {} = .{},
 pub const Framework = struct {
     needed: bool = false,
     weak: bool = false,
-    path: []const u8,
+    path: Path,
 };
 
 pub fn hashAddFrameworks(man: *Cache.Manifest, hm: []const Framework) !void {
     for (hm) |value| {
         man.hash.add(value.needed);
         man.hash.add(value.weak);
-        _ = try man.addFile(value.path, null);
+        _ = try man.addFilePath(value.path, null);
     }
 }
 
@@ -192,8 +194,8 @@ pub fn createEmpty(
             .file = null,
             .disable_lld_caching = options.disable_lld_caching,
             .build_id = options.build_id,
-            .rpath_list = options.rpath_list,
         },
+        .rpath_list = options.rpath_list,
         .pagezero_size = options.pagezero_size,
         .headerpad_size = options.headerpad_size,
         .headerpad_max_install_names = options.headerpad_max_install_names,
@@ -237,9 +239,9 @@ pub fn createEmpty(
             const index: File.Index = @intCast(try self.files.addOne(gpa));
             self.files.set(index, .{ .zig_object = .{
                 .index = index,
-                .path = try std.fmt.allocPrint(arena, "{s}.o", .{fs.path.stem(
-                    zcu.main_mod.root_src_path,
-                )}),
+                .basename = try std.fmt.allocPrint(arena, "{s}.o", .{
+                    fs.path.stem(zcu.main_mod.root_src_path),
+                }),
             } });
             self.zig_object = index;
             const zo = self.getZigObject().?;
@@ -354,13 +356,12 @@ pub fn flushModule(self: *MachO, arena: Allocator, tid: Zcu.PerThread.Id, prog_n
     defer sub_prog_node.end();
 
     const directory = self.base.emit.root_dir;
-    const full_out_path = try directory.join(arena, &[_][]const u8{self.base.emit.sub_path});
-    const module_obj_path: ?[]const u8 = if (self.base.zcu_object_sub_path) |path| blk: {
-        if (fs.path.dirname(full_out_path)) |dirname| {
-            break :blk try fs.path.join(arena, &.{ dirname, path });
-        } else {
-            break :blk path;
-        }
+    const module_obj_path: ?Path = if (self.base.zcu_object_sub_path) |path| .{
+        .root_dir = directory,
+        .sub_path = if (fs.path.dirname(self.base.emit.sub_path)) |dirname|
+            try fs.path.join(arena, &.{ dirname, path })
+        else
+            path,
     } else null;
 
     // --verbose-link
@@ -453,7 +454,7 @@ pub fn flushModule(self: *MachO, arena: Allocator, tid: Zcu.PerThread.Id, prog_n
     }
 
     // Finally, link against compiler_rt.
-    const compiler_rt_path: ?[]const u8 = blk: {
+    const compiler_rt_path: ?Path = blk: {
         if (comp.compiler_rt_lib) |x| break :blk x.full_object_path;
         if (comp.compiler_rt_obj) |x| break :blk x.full_object_path;
         break :blk null;
@@ -565,7 +566,7 @@ pub fn flushModule(self: *MachO, arena: Allocator, tid: Zcu.PerThread.Id, prog_n
         // The most important here is to have the correct vm and filesize of the __LINKEDIT segment
         // where the code signature goes into.
         var codesig = CodeSignature.init(self.getPageSize());
-        codesig.code_directory.ident = fs.path.basename(full_out_path);
+        codesig.code_directory.ident = fs.path.basename(self.base.emit.sub_path);
         if (self.entitlements) |path| try codesig.addEntitlements(gpa, path);
         try self.writeCodeSignaturePadding(&codesig);
         break :blk codesig;
@@ -623,11 +624,11 @@ fn dumpArgv(self: *MachO, comp: *Compilation) !void {
 
     if (self.base.isRelocatable()) {
         for (comp.objects) |obj| {
-            try argv.append(obj.path);
+            try argv.append(try obj.path.toString(arena));
         }
 
         for (comp.c_object_table.keys()) |key| {
-            try argv.append(key.status.success.object_path);
+            try argv.append(try key.status.success.object_path.toString(arena));
         }
 
         if (module_obj_path) |p| {
@@ -662,9 +663,8 @@ fn dumpArgv(self: *MachO, comp: *Compilation) !void {
             try argv.append(syslibroot);
         }
 
-        for (self.base.rpath_list) |rpath| {
-            try argv.append("-rpath");
-            try argv.append(rpath);
+        for (self.rpath_list) |rpath| {
+            try argv.appendSlice(&.{ "-rpath", rpath });
         }
 
         if (self.pagezero_size) |size| {
@@ -710,11 +710,11 @@ fn dumpArgv(self: *MachO, comp: *Compilation) !void {
             if (obj.must_link) {
                 try argv.append("-force_load");
             }
-            try argv.append(obj.path);
+            try argv.append(try obj.path.toString(arena));
         }
 
         for (comp.c_object_table.keys()) |key| {
-            try argv.append(key.status.success.object_path);
+            try argv.append(try key.status.success.object_path.toString(arena));
         }
 
         if (module_obj_path) |p| {
@@ -722,13 +722,12 @@ fn dumpArgv(self: *MachO, comp: *Compilation) !void {
         }
 
         if (comp.config.any_sanitize_thread) {
-            const path = comp.tsan_lib.?.full_object_path;
-            try argv.append(path);
-            try argv.appendSlice(&.{ "-rpath", std.fs.path.dirname(path) orelse "." });
+            const path = try comp.tsan_lib.?.full_object_path.toString(arena);
+            try argv.appendSlice(&.{ path, "-rpath", std.fs.path.dirname(path) orelse "." });
         }
 
         if (comp.config.any_fuzz) {
-            try argv.append(comp.fuzzer_lib.?.full_object_path);
+            try argv.append(try comp.fuzzer_lib.?.full_object_path.toString(arena));
         }
 
         for (self.lib_dirs) |lib_dir| {
@@ -753,7 +752,7 @@ fn dumpArgv(self: *MachO, comp: *Compilation) !void {
         }
 
         for (self.frameworks) |framework| {
-            const name = fs.path.stem(framework.path);
+            const name = framework.path.stem();
             const arg = if (framework.needed)
                 try std.fmt.allocPrint(arena, "-needed_framework {s}", .{name})
             else if (framework.weak)
@@ -764,14 +763,16 @@ fn dumpArgv(self: *MachO, comp: *Compilation) !void {
         }
 
         if (comp.config.link_libcpp) {
-            try argv.append(comp.libcxxabi_static_lib.?.full_object_path);
-            try argv.append(comp.libcxx_static_lib.?.full_object_path);
+            try argv.appendSlice(&.{
+                try comp.libcxxabi_static_lib.?.full_object_path.toString(arena),
+                try comp.libcxx_static_lib.?.full_object_path.toString(arena),
+            });
         }
 
         try argv.append("-lSystem");
 
-        if (comp.compiler_rt_lib) |lib| try argv.append(lib.full_object_path);
-        if (comp.compiler_rt_obj) |obj| try argv.append(obj.full_object_path);
+        if (comp.compiler_rt_lib) |lib| try argv.append(try lib.full_object_path.toString(arena));
+        if (comp.compiler_rt_obj) |obj| try argv.append(try obj.full_object_path.toString(arena));
     }
 
     Compilation.dump_argv(argv.items);
@@ -806,20 +807,20 @@ pub fn resolveLibSystem(
         return error.MissingLibSystem;
     }
 
-    const libsystem_path = try arena.dupe(u8, test_path.items);
+    const libsystem_path = Path.initCwd(try arena.dupe(u8, test_path.items));
     try out_libs.append(.{
         .needed = true,
         .path = libsystem_path,
     });
 }
 
-pub fn classifyInputFile(self: *MachO, path: []const u8, lib: SystemLib, must_link: bool) !void {
+pub fn classifyInputFile(self: *MachO, path: Path, lib: SystemLib, must_link: bool) !void {
     const tracy = trace(@src());
     defer tracy.end();
 
-    log.debug("classifying input file {s}", .{path});
+    log.debug("classifying input file {}", .{path});
 
-    const file = try std.fs.cwd().openFile(path, .{});
+    const file = try path.root_dir.handle.openFile(path.sub_path, .{});
     const fh = try self.addFileHandle(file);
     var buffer: [Archive.SARMAG]u8 = undefined;
 
@@ -843,7 +844,7 @@ pub fn classifyInputFile(self: *MachO, path: []const u8, lib: SystemLib, must_li
     _ = try self.addTbd(lib, true, fh);
 }
 
-fn parseFatFile(self: *MachO, file: std.fs.File, path: []const u8) !?fat.Arch {
+fn parseFatFile(self: *MachO, file: std.fs.File, path: Path) !?fat.Arch {
     const fat_h = fat.readFatHeader(file) catch return null;
     if (fat_h.magic != macho.FAT_MAGIC and fat_h.magic != macho.FAT_MAGIC_64) return null;
     var fat_archs_buffer: [2]fat.Arch = undefined;
@@ -872,7 +873,7 @@ pub fn readArMagic(file: std.fs.File, offset: usize, buffer: *[Archive.SARMAG]u8
     return buffer[0..Archive.SARMAG];
 }
 
-fn addObject(self: *MachO, path: []const u8, handle: File.HandleIndex, offset: u64) !void {
+fn addObject(self: *MachO, path: Path, handle: File.HandleIndex, offset: u64) !void {
     const tracy = trace(@src());
     defer tracy.end();
 
@@ -885,7 +886,10 @@ fn addObject(self: *MachO, path: []const u8, handle: File.HandleIndex, offset: u
     const index = @as(File.Index, @intCast(try self.files.addOne(gpa)));
     self.files.set(index, .{ .object = .{
         .offset = offset,
-        .path = try gpa.dupe(u8, path),
+        .path = .{
+            .root_dir = path.root_dir,
+            .sub_path = try gpa.dupe(u8, path.sub_path),
+        },
         .file_handle = handle,
         .mtime = mtime,
         .index = index,
@@ -936,7 +940,7 @@ fn addArchive(self: *MachO, lib: SystemLib, must_link: bool, handle: File.Handle
 
     const gpa = self.base.comp.gpa;
 
-    var archive = Archive{};
+    var archive: Archive = .{};
     defer archive.deinit(gpa);
     try archive.unpack(self, lib.path, handle, fat_arch);
 
@@ -962,7 +966,10 @@ fn addDylib(self: *MachO, lib: SystemLib, explicit: bool, handle: File.HandleInd
         .offset = offset,
         .file_handle = handle,
         .tag = .dylib,
-        .path = try gpa.dupe(u8, lib.path),
+        .path = .{
+            .root_dir = lib.path.root_dir,
+            .sub_path = try gpa.dupe(u8, lib.path.sub_path),
+        },
         .index = index,
         .needed = lib.needed,
         .weak = lib.weak,
@@ -985,7 +992,10 @@ fn addTbd(self: *MachO, lib: SystemLib, explicit: bool, handle: File.HandleIndex
         .offset = 0,
         .file_handle = handle,
         .tag = .tbd,
-        .path = try gpa.dupe(u8, lib.path),
+        .path = .{
+            .root_dir = lib.path.root_dir,
+            .sub_path = try gpa.dupe(u8, lib.path.sub_path),
+        },
         .index = index,
         .needed = lib.needed,
         .weak = lib.weak,
@@ -1174,11 +1184,11 @@ fn parseDependentDylibs(self: *MachO) !void {
                     continue;
                 }
             };
-            const lib = SystemLib{
-                .path = full_path,
+            const lib: SystemLib = .{
+                .path = Path.initCwd(full_path),
                 .weak = is_weak,
             };
-            const file = try std.fs.cwd().openFile(lib.path, .{});
+            const file = try lib.path.root_dir.handle.openFile(lib.path.sub_path, .{});
             const fh = try self.addFileHandle(file);
             const fat_arch = try self.parseFatFile(file, lib.path);
             const offset = if (fat_arch) |fa| fa.offset else 0;
@@ -1469,6 +1479,9 @@ fn scanRelocs(self: *MachO) !void {
 
     if (self.has_errors.swap(false, .seq_cst)) return error.FlushFailure;
 
+    if (self.getInternalObject()) |obj| {
+        try obj.checkUndefs(self);
+    }
     try self.reportUndefs();
 
     if (self.getZigObject()) |zo| {
@@ -1529,29 +1542,43 @@ fn reportUndefs(self: *MachO) !void {
         }
     }.lessThan;
 
-    for (self.undefs.values()) |*refs| {
-        mem.sort(Ref, refs.items, {}, refLessThan);
-    }
+    for (self.undefs.values()) |*undefs| switch (undefs.*) {
+        .refs => |refs| mem.sort(Ref, refs.items, {}, refLessThan),
+        else => {},
+    };
 
     for (keys.items) |key| {
         const undef_sym = self.resolver.keys.items[key - 1];
         const notes = self.undefs.get(key).?;
-        const nnotes = @min(notes.items.len, max_notes) + @intFromBool(notes.items.len > max_notes);
+        const nnotes = nnotes: {
+            const nnotes = switch (notes) {
+                .refs => |refs| refs.items.len,
+                else => 1,
+            };
+            break :nnotes @min(nnotes, max_notes) + @intFromBool(nnotes > max_notes);
+        };
 
         var err = try self.base.addErrorWithNotes(nnotes);
         try err.addMsg("undefined symbol: {s}", .{undef_sym.getName(self)});
 
-        var inote: usize = 0;
-        while (inote < @min(notes.items.len, max_notes)) : (inote += 1) {
-            const note = notes.items[inote];
-            const file = self.getFile(note.file).?;
-            const atom = note.getAtom(self).?;
-            try err.addNote("referenced by {}:{s}", .{ file.fmtPath(), atom.getName(self) });
-        }
+        switch (notes) {
+            .force_undefined => try err.addNote("referenced with linker flag -u", .{}),
+            .entry => try err.addNote("referenced with linker flag -e", .{}),
+            .dyld_stub_binder, .objc_msgsend => try err.addNote("referenced implicitly", .{}),
+            .refs => |refs| {
+                var inote: usize = 0;
+                while (inote < @min(refs.items.len, max_notes)) : (inote += 1) {
+                    const ref = refs.items[inote];
+                    const file = self.getFile(ref.file).?;
+                    const atom = ref.getAtom(self).?;
+                    try err.addNote("referenced by {}:{s}", .{ file.fmtPath(), atom.getName(self) });
+                }
 
-        if (notes.items.len > max_notes) {
-            const remaining = notes.items.len - max_notes;
-            try err.addNote("referenced {d} more times", .{remaining});
+                if (refs.items.len > max_notes) {
+                    const remaining = refs.items.len - max_notes;
+                    try err.addNote("referenced {d} more times", .{remaining});
+                }
+            },
         }
     }
 
@@ -2842,12 +2869,13 @@ fn writeLoadCommands(self: *MachO) !struct { usize, usize, u64 } {
         ncmds += 1;
     }
 
-    for (self.base.rpath_list) |rpath| {
+    for (self.rpath_list) |rpath| {
         try load_commands.writeRpathLC(rpath, writer);
         ncmds += 1;
     }
     if (comp.config.any_sanitize_thread) {
-        const path = comp.tsan_lib.?.full_object_path;
+        const path = try comp.tsan_lib.?.full_object_path.toString(gpa);
+        defer gpa.free(path);
         const rpath = std.fs.path.dirname(path) orelse ".";
         try load_commands.writeRpathLC(rpath, writer);
         ncmds += 1;
@@ -3230,7 +3258,7 @@ fn initMetadata(self: *MachO, options: InitMetadataOptions) !void {
             self.zig_text_seg_index = try self.addSegment("__TEXT_ZIG", .{
                 .fileoff = off,
                 .filesize = filesize,
-                .vmaddr = base_vmaddr + 0x8000000,
+                .vmaddr = base_vmaddr + 0x4000000,
                 .vmsize = filesize,
                 .prot = macho.PROT.READ | macho.PROT.EXEC,
             });
@@ -3542,8 +3570,8 @@ pub fn requiresCodeSig(self: MachO) bool {
     const target = self.getTarget();
     return switch (target.cpu.arch) {
         .aarch64 => switch (target.os.tag) {
-            .macos => true,
-            .watchos, .tvos, .ios, .visionos => target.abi == .simulator,
+            .bridgeos, .driverkit, .macos => true,
+            .ios, .tvos, .visionos, .watchos => target.abi == .simulator,
             else => false,
         },
         .x86_64 => false,
@@ -3740,13 +3768,13 @@ pub fn eatPrefix(path: []const u8, prefix: []const u8) ?[]const u8 {
 
 pub fn reportParseError(
     self: *MachO,
-    path: []const u8,
+    path: Path,
     comptime format: []const u8,
     args: anytype,
 ) error{OutOfMemory}!void {
     var err = try self.base.addErrorWithNotes(1);
     try err.addMsg(format, args);
-    try err.addNote("while parsing {s}", .{path});
+    try err.addNote("while parsing {}", .{path});
 }
 
 pub fn reportParseError2(
@@ -3895,7 +3923,7 @@ fn fmtDumpState(
     _ = options;
     _ = unused_fmt_string;
     if (self.getZigObject()) |zo| {
-        try writer.print("zig_object({d}) : {s}\n", .{ zo.index, zo.path });
+        try writer.print("zig_object({d}) : {s}\n", .{ zo.index, zo.basename });
         try writer.print("{}{}\n", .{
             zo.fmtAtoms(self),
             zo.fmtSymtab(self),
@@ -3920,9 +3948,9 @@ fn fmtDumpState(
     }
     for (self.dylibs.items) |index| {
         const dylib = self.getFile(index).?.dylib;
-        try writer.print("dylib({d}) : {s} : needed({}) : weak({})", .{
+        try writer.print("dylib({d}) : {} : needed({}) : weak({})", .{
             index,
-            dylib.path,
+            @as(Path, dylib.path),
             dylib.needed,
             dylib.weak,
         });
@@ -4172,36 +4200,38 @@ pub const Platform = struct {
                 const cmd = lc.cast(macho.build_version_command).?;
                 return .{
                     .os_tag = switch (cmd.platform) {
-                        .MACOS => .macos,
+                        .BRIDGEOS => .bridgeos,
+                        .DRIVERKIT => .driverkit,
                         .IOS, .IOSSIMULATOR => .ios,
-                        .TVOS, .TVOSSIMULATOR => .tvos,
-                        .WATCHOS, .WATCHOSSIMULATOR => .watchos,
                         .MACCATALYST => .ios,
+                        .MACOS => .macos,
+                        .TVOS, .TVOSSIMULATOR => .tvos,
                         .VISIONOS, .VISIONOSSIMULATOR => .visionos,
+                        .WATCHOS, .WATCHOSSIMULATOR => .watchos,
                         else => @panic("TODO"),
                     },
                     .abi = switch (cmd.platform) {
                         .MACCATALYST => .macabi,
                         .IOSSIMULATOR,
                         .TVOSSIMULATOR,
-                        .WATCHOSSIMULATOR,
                         .VISIONOSSIMULATOR,
+                        .WATCHOSSIMULATOR,
                         => .simulator,
                         else => .none,
                     },
                     .version = appleVersionToSemanticVersion(cmd.minos),
                 };
             },
-            .VERSION_MIN_MACOSX,
             .VERSION_MIN_IPHONEOS,
+            .VERSION_MIN_MACOSX,
             .VERSION_MIN_TVOS,
             .VERSION_MIN_WATCHOS,
             => {
                 const cmd = lc.cast(macho.version_min_command).?;
                 return .{
                     .os_tag = switch (lc.cmd()) {
-                        .VERSION_MIN_MACOSX => .macos,
                         .VERSION_MIN_IPHONEOS => .ios,
+                        .VERSION_MIN_MACOSX => .macos,
                         .VERSION_MIN_TVOS => .tvos,
                         .VERSION_MIN_WATCHOS => .watchos,
                         else => unreachable,
@@ -4228,15 +4258,17 @@ pub const Platform = struct {
 
     pub fn toApplePlatform(plat: Platform) macho.PLATFORM {
         return switch (plat.os_tag) {
-            .macos => .MACOS,
+            .bridgeos => .BRIDGEOS,
+            .driverkit => .DRIVERKIT,
             .ios => switch (plat.abi) {
-                .simulator => .IOSSIMULATOR,
                 .macabi => .MACCATALYST,
+                .simulator => .IOSSIMULATOR,
                 else => .IOS,
             },
+            .macos => .MACOS,
             .tvos => if (plat.abi == .simulator) .TVOSSIMULATOR else .TVOS,
-            .watchos => if (plat.abi == .simulator) .WATCHOSSIMULATOR else .WATCHOS,
             .visionos => if (plat.abi == .simulator) .VISIONOSSIMULATOR else .VISIONOS,
+            .watchos => if (plat.abi == .simulator) .WATCHOSSIMULATOR else .WATCHOS,
             else => unreachable,
         };
     }
@@ -4305,15 +4337,18 @@ const SupportedPlatforms = struct {
 // Source: https://github.com/apple-oss-distributions/ld64/blob/59a99ab60399c5e6c49e6945a9e1049c42b71135/src/ld/PlatformSupport.cpp#L52
 // zig fmt: off
 const supported_platforms = [_]SupportedPlatforms{
-    .{ .macos,    .none,      0xA0E00, 0xA0800 },
-    .{ .ios,      .none,      0xC0000, 0x70000 },
-    .{ .tvos,     .none,      0xC0000, 0x70000 },
-    .{ .watchos,  .none,      0x50000, 0x20000 },
-    .{ .visionos, .none,      0x10000, 0x10000 },
-    .{ .ios,      .simulator, 0xD0000, 0x80000 },
-    .{ .tvos,     .simulator, 0xD0000, 0x80000 },
-    .{ .watchos,  .simulator, 0x60000, 0x20000 },
-    .{ .visionos, .simulator, 0x10000, 0x10000 },
+    .{ .bridgeos,  .none,      0x010000, 0x010000 },
+    .{ .driverkit, .none,      0x130000, 0x130000 },
+    .{ .ios,       .none,      0x0C0000, 0x070000 },
+    .{ .ios,       .macabi,    0x0D0000, 0x0D0000 },
+    .{ .ios,       .simulator, 0x0D0000, 0x080000 },
+    .{ .macos,     .none,      0x0A0E00, 0x0A0800 },
+    .{ .tvos,      .none,      0x0C0000, 0x070000 },
+    .{ .tvos,      .simulator, 0x0D0000, 0x080000 },
+    .{ .visionos,  .none,      0x010000, 0x010000 },
+    .{ .visionos,  .simulator, 0x010000, 0x010000 },
+    .{ .watchos,   .none,      0x050000, 0x020000 },
+    .{ .watchos,   .simulator, 0x060000, 0x020000 },
 };
 // zig fmt: on
 
@@ -4417,7 +4452,7 @@ pub const default_pagezero_size: u64 = 0x100000000;
 pub const default_headerpad_size: u32 = 0x1000;
 
 const SystemLib = struct {
-    path: []const u8,
+    path: Path,
     needed: bool = false,
     weak: bool = false,
     hidden: bool = false,
@@ -4576,78 +4611,20 @@ pub const String = struct {
     len: u32 = 0,
 };
 
-const MachO = @This();
-
-const std = @import("std");
-const build_options = @import("build_options");
-const builtin = @import("builtin");
-const assert = std.debug.assert;
-const fs = std.fs;
-const log = std.log.scoped(.link);
-const state_log = std.log.scoped(.link_state);
-const macho = std.macho;
-const math = std.math;
-const mem = std.mem;
-const meta = std.meta;
+pub const UndefRefs = union(enum) {
+    force_undefined,
+    entry,
+    dyld_stub_binder,
+    objc_msgsend,
+    refs: std.ArrayListUnmanaged(Ref),
 
-const aarch64 = @import("../arch/aarch64/bits.zig");
-const bind = @import("MachO/dyld_info/bind.zig");
-const calcUuid = @import("MachO/uuid.zig").calcUuid;
-const codegen = @import("../codegen.zig");
-const dead_strip = @import("MachO/dead_strip.zig");
-const eh_frame = @import("MachO/eh_frame.zig");
-const fat = @import("MachO/fat.zig");
-const link = @import("../link.zig");
-const load_commands = @import("MachO/load_commands.zig");
-const relocatable = @import("MachO/relocatable.zig");
-const tapi = @import("tapi.zig");
-const target_util = @import("../target.zig");
-const trace = @import("../tracy.zig").trace;
-const synthetic = @import("MachO/synthetic.zig");
-
-const Air = @import("../Air.zig");
-const Alignment = Atom.Alignment;
-const Allocator = mem.Allocator;
-const Archive = @import("MachO/Archive.zig");
-pub const Atom = @import("MachO/Atom.zig");
-const AtomicBool = std.atomic.Value(bool);
-const Bind = bind.Bind;
-const Cache = std.Build.Cache;
-const Path = Cache.Path;
-const CodeSignature = @import("MachO/CodeSignature.zig");
-const Compilation = @import("../Compilation.zig");
-const DataInCode = synthetic.DataInCode;
-pub const DebugSymbols = @import("MachO/DebugSymbols.zig");
-const Dylib = @import("MachO/Dylib.zig");
-const ExportTrie = @import("MachO/dyld_info/Trie.zig");
-const File = @import("MachO/file.zig").File;
-const GotSection = synthetic.GotSection;
-const Hash = std.hash.Wyhash;
-const Indsymtab = synthetic.Indsymtab;
-const InternalObject = @import("MachO/InternalObject.zig");
-const ObjcStubsSection = synthetic.ObjcStubsSection;
-const Object = @import("MachO/Object.zig");
-const LazyBind = bind.LazyBind;
-const LaSymbolPtrSection = synthetic.LaSymbolPtrSection;
-const Liveness = @import("../Liveness.zig");
-const LlvmObject = @import("../codegen/llvm.zig").Object;
-const Md5 = std.crypto.hash.Md5;
-const Zcu = @import("../Zcu.zig");
-const InternPool = @import("../InternPool.zig");
-const Rebase = @import("MachO/dyld_info/Rebase.zig");
-pub const Relocation = @import("MachO/Relocation.zig");
-const StringTable = @import("StringTable.zig");
-const StubsSection = synthetic.StubsSection;
-const StubsHelperSection = synthetic.StubsHelperSection;
-const Symbol = @import("MachO/Symbol.zig");
-const Thunk = @import("MachO/Thunk.zig");
-const TlvPtrSection = synthetic.TlvPtrSection;
-const Value = @import("../Value.zig");
-const UnwindInfo = @import("MachO/UnwindInfo.zig");
-const WaitGroup = std.Thread.WaitGroup;
-const WeakBind = bind.WeakBind;
-const ZigObject = @import("MachO/ZigObject.zig");
-const dev = @import("../dev.zig");
+    pub fn deinit(self: *UndefRefs, allocator: Allocator) void {
+        switch (self.*) {
+            .refs => |*refs| refs.deinit(allocator),
+            else => {},
+        }
+    }
+};
 
 pub const MachError = error{
     /// Not enough permissions held to perform the requested kernel
@@ -5384,3 +5361,76 @@ const max_distance = (1 << (jump_bits - 1));
 /// mold uses 5MiB margin, while ld64 uses 4MiB margin. We will follow mold
 /// and assume margin to be 5MiB.
 const max_allowed_distance = max_distance - 0x500_000;
+
+const MachO = @This();
+
+const std = @import("std");
+const build_options = @import("build_options");
+const builtin = @import("builtin");
+const assert = std.debug.assert;
+const fs = std.fs;
+const log = std.log.scoped(.link);
+const state_log = std.log.scoped(.link_state);
+const macho = std.macho;
+const math = std.math;
+const mem = std.mem;
+const meta = std.meta;
+
+const aarch64 = @import("../arch/aarch64/bits.zig");
+const bind = @import("MachO/dyld_info/bind.zig");
+const calcUuid = @import("MachO/uuid.zig").calcUuid;
+const codegen = @import("../codegen.zig");
+const dead_strip = @import("MachO/dead_strip.zig");
+const eh_frame = @import("MachO/eh_frame.zig");
+const fat = @import("MachO/fat.zig");
+const link = @import("../link.zig");
+const load_commands = @import("MachO/load_commands.zig");
+const relocatable = @import("MachO/relocatable.zig");
+const tapi = @import("tapi.zig");
+const target_util = @import("../target.zig");
+const trace = @import("../tracy.zig").trace;
+const synthetic = @import("MachO/synthetic.zig");
+
+const Air = @import("../Air.zig");
+const Alignment = Atom.Alignment;
+const Allocator = mem.Allocator;
+const Archive = @import("MachO/Archive.zig");
+pub const Atom = @import("MachO/Atom.zig");
+const AtomicBool = std.atomic.Value(bool);
+const Bind = bind.Bind;
+const Cache = std.Build.Cache;
+const Path = Cache.Path;
+const CodeSignature = @import("MachO/CodeSignature.zig");
+const Compilation = @import("../Compilation.zig");
+const DataInCode = synthetic.DataInCode;
+pub const DebugSymbols = @import("MachO/DebugSymbols.zig");
+const Dylib = @import("MachO/Dylib.zig");
+const ExportTrie = @import("MachO/dyld_info/Trie.zig");
+const File = @import("MachO/file.zig").File;
+const GotSection = synthetic.GotSection;
+const Hash = std.hash.Wyhash;
+const Indsymtab = synthetic.Indsymtab;
+const InternalObject = @import("MachO/InternalObject.zig");
+const ObjcStubsSection = synthetic.ObjcStubsSection;
+const Object = @import("MachO/Object.zig");
+const LazyBind = bind.LazyBind;
+const LaSymbolPtrSection = synthetic.LaSymbolPtrSection;
+const Liveness = @import("../Liveness.zig");
+const LlvmObject = @import("../codegen/llvm.zig").Object;
+const Md5 = std.crypto.hash.Md5;
+const Zcu = @import("../Zcu.zig");
+const InternPool = @import("../InternPool.zig");
+const Rebase = @import("MachO/dyld_info/Rebase.zig");
+pub const Relocation = @import("MachO/Relocation.zig");
+const StringTable = @import("StringTable.zig");
+const StubsSection = synthetic.StubsSection;
+const StubsHelperSection = synthetic.StubsHelperSection;
+const Symbol = @import("MachO/Symbol.zig");
+const Thunk = @import("MachO/Thunk.zig");
+const TlvPtrSection = synthetic.TlvPtrSection;
+const Value = @import("../Value.zig");
+const UnwindInfo = @import("MachO/UnwindInfo.zig");
+const WaitGroup = std.Thread.WaitGroup;
+const WeakBind = bind.WeakBind;
+const ZigObject = @import("MachO/ZigObject.zig");
+const dev = @import("../dev.zig");
diff --git a/zig/src/link/MachO/Archive.zig b/zig/src/link/MachO/Archive.zig
index bb589dfb66..ba3c66689b 100644
--- a/zig/src/link/MachO/Archive.zig
+++ b/zig/src/link/MachO/Archive.zig
@@ -4,7 +4,7 @@ pub fn deinit(self: *Archive, allocator: Allocator) void {
     self.objects.deinit(allocator);
 }
 
-pub fn unpack(self: *Archive, macho_file: *MachO, path: []const u8, handle_index: File.HandleIndex, fat_arch: ?fat.Arch) !void {
+pub fn unpack(self: *Archive, macho_file: *MachO, path: Path, handle_index: File.HandleIndex, fat_arch: ?fat.Arch) !void {
     const gpa = macho_file.base.comp.gpa;
 
     var arena = std.heap.ArenaAllocator.init(gpa);
@@ -55,20 +55,23 @@ pub fn unpack(self: *Archive, macho_file: *MachO, path: []const u8, handle_index
             mem.eql(u8, name, SYMDEF_SORTED) or
             mem.eql(u8, name, SYMDEF64_SORTED)) continue;
 
-        const object = Object{
+        const object: Object = .{
             .offset = pos,
             .in_archive = .{
-                .path = try gpa.dupe(u8, path),
+                .path = .{
+                    .root_dir = path.root_dir,
+                    .sub_path = try gpa.dupe(u8, path.sub_path),
+                },
                 .size = hdr_size,
             },
-            .path = try gpa.dupe(u8, name),
+            .path = Path.initCwd(try gpa.dupe(u8, name)),
             .file_handle = handle_index,
             .index = undefined,
             .alive = false,
             .mtime = hdr.date() catch 0,
         };
 
-        log.debug("extracting object '{s}' from archive '{s}'", .{ object.path, path });
+        log.debug("extracting object '{}' from archive '{}'", .{ object.path, path });
 
         try self.objects.append(gpa, object);
     }
@@ -301,8 +304,9 @@ const log = std.log.scoped(.link);
 const macho = std.macho;
 const mem = std.mem;
 const std = @import("std");
-
 const Allocator = mem.Allocator;
+const Path = std.Build.Cache.Path;
+
 const Archive = @This();
 const File = @import("file.zig").File;
 const MachO = @import("../MachO.zig");
diff --git a/zig/src/link/MachO/Atom.zig b/zig/src/link/MachO/Atom.zig
index d2a6a13497..6e3b4311eb 100644
--- a/zig/src/link/MachO/Atom.zig
+++ b/zig/src/link/MachO/Atom.zig
@@ -560,9 +560,9 @@ fn reportUndefSymbol(self: Atom, rel: Relocation, macho_file: *MachO) !bool {
         const gpa = macho_file.base.comp.gpa;
         const gop = try macho_file.undefs.getOrPut(gpa, file.getGlobals()[rel.target]);
         if (!gop.found_existing) {
-            gop.value_ptr.* = .{};
+            gop.value_ptr.* = .{ .refs = .{} };
         }
-        try gop.value_ptr.append(gpa, .{ .index = self.atom_index, .file = self.file });
+        try gop.value_ptr.refs.append(gpa, .{ .index = self.atom_index, .file = self.file });
         return true;
     }
 
diff --git a/zig/src/link/MachO/Dylib.zig b/zig/src/link/MachO/Dylib.zig
index 9852cfb234..01dd25fa8c 100644
--- a/zig/src/link/MachO/Dylib.zig
+++ b/zig/src/link/MachO/Dylib.zig
@@ -1,6 +1,6 @@
 /// Non-zero for fat dylibs
 offset: u64,
-path: []const u8,
+path: Path,
 index: File.Index,
 file_handle: File.HandleIndex,
 tag: enum { dylib, tbd },
@@ -28,7 +28,7 @@ referenced: bool = false,
 output_symtab_ctx: MachO.SymtabCtx = .{},
 
 pub fn deinit(self: *Dylib, allocator: Allocator) void {
-    allocator.free(self.path);
+    allocator.free(self.path.sub_path);
     self.exports.deinit(allocator);
     self.strtab.deinit(allocator);
     if (self.id) |*id| id.deinit(allocator);
@@ -61,7 +61,7 @@ fn parseBinary(self: *Dylib, macho_file: *MachO) !void {
     const file = macho_file.getFileHandle(self.file_handle);
     const offset = self.offset;
 
-    log.debug("parsing dylib from binary: {s}", .{self.path});
+    log.debug("parsing dylib from binary: {}", .{@as(Path, self.path)});
 
     var header_buffer: [@sizeOf(macho.mach_header_64)]u8 = undefined;
     {
@@ -267,7 +267,7 @@ fn parseTbd(self: *Dylib, macho_file: *MachO) !void {
 
     const gpa = macho_file.base.comp.gpa;
 
-    log.debug("parsing dylib from stub: {s}", .{self.path});
+    log.debug("parsing dylib from stub: {}", .{self.path});
 
     const file = macho_file.getFileHandle(self.file_handle);
     var lib_stub = LibStub.loadFromFile(gpa, file) catch |err| {
@@ -959,8 +959,9 @@ const mem = std.mem;
 const tapi = @import("../tapi.zig");
 const trace = @import("../../tracy.zig").trace;
 const std = @import("std");
-
 const Allocator = mem.Allocator;
+const Path = std.Build.Cache.Path;
+
 const Dylib = @This();
 const File = @import("file.zig").File;
 const LibStub = tapi.LibStub;
diff --git a/zig/src/link/MachO/InternalObject.zig b/zig/src/link/MachO/InternalObject.zig
index ed7a05b023..f41b1aa7ef 100644
--- a/zig/src/link/MachO/InternalObject.zig
+++ b/zig/src/link/MachO/InternalObject.zig
@@ -281,7 +281,7 @@ fn addObjcMethnameSection(self: *InternalObject, methname: []const u8, macho_fil
     sym.nlist_idx = nlist_idx;
     try self.globals.append(gpa, 0);
 
-    return atom_index;
+    return sym_index;
 }
 
 fn addObjcSelrefsSection(self: *InternalObject, methname_sym_index: Symbol.Index, macho_file: *MachO) !Symbol.Index {
@@ -507,6 +507,41 @@ pub fn scanRelocs(self: *InternalObject, macho_file: *MachO) void {
     }
 }
 
+pub fn checkUndefs(self: InternalObject, macho_file: *MachO) !void {
+    const addUndef = struct {
+        fn addUndef(mf: *MachO, index: MachO.SymbolResolver.Index, tag: anytype) !void {
+            const gpa = mf.base.comp.gpa;
+            mf.undefs_mutex.lock();
+            defer mf.undefs_mutex.unlock();
+            const gop = try mf.undefs.getOrPut(gpa, index);
+            if (!gop.found_existing) {
+                gop.value_ptr.* = tag;
+            }
+        }
+    }.addUndef;
+    for (self.force_undefined.items) |index| {
+        const ref = self.getSymbolRef(index, macho_file);
+        if (ref.getFile(macho_file) == null) {
+            try addUndef(macho_file, self.globals.items[index], .force_undefined);
+        }
+    }
+    if (self.getEntryRef(macho_file)) |ref| {
+        if (ref.getFile(macho_file) == null) {
+            try addUndef(macho_file, self.globals.items[self.entry_index.?], .entry);
+        }
+    }
+    if (self.getDyldStubBinderRef(macho_file)) |ref| {
+        if (ref.getFile(macho_file) == null and macho_file.stubs.symbols.items.len > 0) {
+            try addUndef(macho_file, self.globals.items[self.dyld_stub_binder_index.?], .dyld_stub_binder);
+        }
+    }
+    if (self.getObjcMsgSendRef(macho_file)) |ref| {
+        if (ref.getFile(macho_file) == null and self.needsObjcMsgsendSymbol()) {
+            try addUndef(macho_file, self.globals.items[self.objc_msg_send_index.?], .objc_msgsend);
+        }
+    }
+}
+
 pub fn allocateSyntheticSymbols(self: *InternalObject, macho_file: *MachO) void {
     const text_seg = macho_file.getTextSegment();
 
@@ -791,6 +826,13 @@ pub fn setSymbolExtra(self: *InternalObject, index: u32, extra: Symbol.Extra) vo
     }
 }
 
+fn needsObjcMsgsendSymbol(self: InternalObject) bool {
+    for (self.sections.items(.extra)) |extra| {
+        if (extra.is_objc_methname or extra.is_objc_selref) return true;
+    }
+    return false;
+}
+
 const FormatContext = struct {
     self: *InternalObject,
     macho_file: *MachO,
diff --git a/zig/src/link/MachO/Object.zig b/zig/src/link/MachO/Object.zig
index 81f28de65a..9181112f2a 100644
--- a/zig/src/link/MachO/Object.zig
+++ b/zig/src/link/MachO/Object.zig
@@ -1,6 +1,8 @@
 /// Non-zero for fat object files or archives
 offset: u64,
-path: []const u8,
+/// Archive files cannot contain subdirectories, so only the basename is needed
+/// for output. However, the full path is kept for error reporting.
+path: Path,
 file_handle: File.HandleIndex,
 mtime: u64,
 index: File.Index,
@@ -39,8 +41,8 @@ output_symtab_ctx: MachO.SymtabCtx = .{},
 output_ar_state: Archive.ArState = .{},
 
 pub fn deinit(self: *Object, allocator: Allocator) void {
-    if (self.in_archive) |*ar| allocator.free(ar.path);
-    allocator.free(self.path);
+    if (self.in_archive) |*ar| allocator.free(ar.path.sub_path);
+    allocator.free(self.path.sub_path);
     for (self.sections.items(.relocs), self.sections.items(.subsections)) |*relocs, *sub| {
         relocs.deinit(allocator);
         sub.deinit(allocator);
@@ -1723,7 +1725,8 @@ pub fn updateArSize(self: *Object, macho_file: *MachO) !void {
 pub fn writeAr(self: Object, ar_format: Archive.Format, macho_file: *MachO, writer: anytype) !void {
     // Header
     const size = std.math.cast(usize, self.output_ar_state.size) orelse return error.Overflow;
-    try Archive.writeHeader(self.path, size, ar_format, writer);
+    const basename = std.fs.path.basename(self.path.sub_path);
+    try Archive.writeHeader(basename, size, ar_format, writer);
     // Data
     const file = macho_file.getFileHandle(self.file_handle);
     // TODO try using copyRangeAll
@@ -1774,6 +1777,11 @@ pub fn calcSymtabSize(self: *Object, macho_file: *MachO) void {
         self.calcStabsSize(macho_file);
 }
 
+fn pathLen(path: Path) usize {
+    // +1 for the path separator
+    return (if (path.root_dir.path) |p| p.len + @intFromBool(path.sub_path.len != 0) else 0) + path.sub_path.len;
+}
+
 pub fn calcStabsSize(self: *Object, macho_file: *MachO) void {
     if (self.compile_unit) |cu| {
         const comp_dir = cu.getCompDir(self.*);
@@ -1784,9 +1792,9 @@ pub fn calcStabsSize(self: *Object, macho_file: *MachO) void {
         self.output_symtab_ctx.strsize += @as(u32, @intCast(tu_name.len + 1)); // tu_name
 
         if (self.in_archive) |ar| {
-            self.output_symtab_ctx.strsize += @as(u32, @intCast(ar.path.len + 1 + self.path.len + 1 + 1));
+            self.output_symtab_ctx.strsize += @intCast(pathLen(ar.path) + 1 + self.path.basename().len + 1 + 1);
         } else {
-            self.output_symtab_ctx.strsize += @as(u32, @intCast(self.path.len + 1));
+            self.output_symtab_ctx.strsize += @intCast(pathLen(self.path) + 1);
         }
 
         for (self.symbols.items, 0..) |sym, i| {
@@ -2118,19 +2126,36 @@ pub fn writeStabs(self: Object, stroff: u32, macho_file: *MachO, ctx: anytype) v
         };
         index += 1;
         if (self.in_archive) |ar| {
-            @memcpy(ctx.strtab.items[n_strx..][0..ar.path.len], ar.path);
-            n_strx += @intCast(ar.path.len);
+            if (ar.path.root_dir.path) |p| {
+                @memcpy(ctx.strtab.items[n_strx..][0..p.len], p);
+                n_strx += @intCast(p.len);
+                if (ar.path.sub_path.len != 0) {
+                    ctx.strtab.items[n_strx] = '/';
+                    n_strx += 1;
+                }
+            }
+            @memcpy(ctx.strtab.items[n_strx..][0..ar.path.sub_path.len], ar.path.sub_path);
+            n_strx += @intCast(ar.path.sub_path.len);
             ctx.strtab.items[n_strx] = '(';
             n_strx += 1;
-            @memcpy(ctx.strtab.items[n_strx..][0..self.path.len], self.path);
-            n_strx += @intCast(self.path.len);
+            const basename = self.path.basename();
+            @memcpy(ctx.strtab.items[n_strx..][0..basename.len], basename);
+            n_strx += @intCast(basename.len);
             ctx.strtab.items[n_strx] = ')';
             n_strx += 1;
             ctx.strtab.items[n_strx] = 0;
             n_strx += 1;
         } else {
-            @memcpy(ctx.strtab.items[n_strx..][0..self.path.len], self.path);
-            n_strx += @intCast(self.path.len);
+            if (self.path.root_dir.path) |p| {
+                @memcpy(ctx.strtab.items[n_strx..][0..p.len], p);
+                n_strx += @intCast(p.len);
+                if (self.path.sub_path.len != 0) {
+                    ctx.strtab.items[n_strx] = '/';
+                    n_strx += 1;
+                }
+            }
+            @memcpy(ctx.strtab.items[n_strx..][0..self.path.sub_path.len], self.path.sub_path);
+            n_strx += @intCast(self.path.sub_path.len);
             ctx.strtab.items[n_strx] = 0;
             n_strx += 1;
         }
@@ -2666,11 +2691,12 @@ fn formatPath(
     _ = unused_fmt_string;
     _ = options;
     if (object.in_archive) |ar| {
-        try writer.writeAll(ar.path);
-        try writer.writeByte('(');
-        try writer.writeAll(object.path);
-        try writer.writeByte(')');
-    } else try writer.writeAll(object.path);
+        try writer.print("{}({s})", .{
+            @as(Path, ar.path), object.path.basename(),
+        });
+    } else {
+        try writer.print("{}", .{@as(Path, object.path)});
+    }
 }
 
 const Section = struct {
@@ -2777,7 +2803,7 @@ const CompileUnit = struct {
 };
 
 const InArchive = struct {
-    path: []const u8,
+    path: Path,
     size: u32,
 };
 
@@ -3170,6 +3196,7 @@ const math = std.math;
 const mem = std.mem;
 const trace = @import("../../tracy.zig").trace;
 const std = @import("std");
+const Path = std.Build.Cache.Path;
 
 const Allocator = mem.Allocator;
 const Archive = @import("Archive.zig");
diff --git a/zig/src/link/MachO/ZigObject.zig b/zig/src/link/MachO/ZigObject.zig
index a2d578845c..2a89e5da56 100644
--- a/zig/src/link/MachO/ZigObject.zig
+++ b/zig/src/link/MachO/ZigObject.zig
@@ -1,6 +1,6 @@
 data: std.ArrayListUnmanaged(u8) = .empty,
 /// Externally owned memory.
-path: []const u8,
+basename: []const u8,
 index: File.Index,
 
 symtab: std.MultiArrayList(Nlist) = .{},
@@ -317,7 +317,7 @@ pub fn updateArSize(self: *ZigObject) void {
 pub fn writeAr(self: ZigObject, ar_format: Archive.Format, writer: anytype) !void {
     // Header
     const size = std.math.cast(usize, self.output_ar_state.size) orelse return error.Overflow;
-    try Archive.writeHeader(self.path, size, ar_format, writer);
+    try Archive.writeHeader(self.basename, size, ar_format, writer);
     // Data
     try writer.writeAll(self.data.items);
 }
diff --git a/zig/src/link/MachO/file.zig b/zig/src/link/MachO/file.zig
index 26b5957058..554a8b1966 100644
--- a/zig/src/link/MachO/file.zig
+++ b/zig/src/link/MachO/file.zig
@@ -23,10 +23,10 @@ pub const File = union(enum) {
         _ = unused_fmt_string;
         _ = options;
         switch (file) {
-            .zig_object => |x| try writer.writeAll(x.path),
+            .zig_object => |zo| try writer.writeAll(zo.basename),
             .internal => try writer.writeAll("internal"),
             .object => |x| try writer.print("{}", .{x.fmtPath()}),
-            .dylib => |x| try writer.writeAll(x.path),
+            .dylib => |dl| try writer.print("{}", .{@as(Path, dl.path)}),
         }
     }
 
@@ -373,13 +373,14 @@ pub const File = union(enum) {
     pub const HandleIndex = Index;
 };
 
+const std = @import("std");
 const assert = std.debug.assert;
 const log = std.log.scoped(.link);
 const macho = std.macho;
-const std = @import("std");
-const trace = @import("../../tracy.zig").trace;
-
 const Allocator = std.mem.Allocator;
+const Path = std.Build.Cache.Path;
+
+const trace = @import("../../tracy.zig").trace;
 const Archive = @import("Archive.zig");
 const Atom = @import("Atom.zig");
 const InternalObject = @import("InternalObject.zig");
diff --git a/zig/src/link/MachO/load_commands.zig b/zig/src/link/MachO/load_commands.zig
index a891bedbd6..08ab11e3f9 100644
--- a/zig/src/link/MachO/load_commands.zig
+++ b/zig/src/link/MachO/load_commands.zig
@@ -63,7 +63,7 @@ pub fn calcLoadCommandsSize(macho_file: *MachO, assume_max_path_len: bool) !u32
     }
     // LC_RPATH
     {
-        for (macho_file.base.rpath_list) |rpath| {
+        for (macho_file.rpath_list) |rpath| {
             sizeofcmds += calcInstallNameLen(
                 @sizeOf(macho.rpath_command),
                 rpath,
@@ -72,7 +72,8 @@ pub fn calcLoadCommandsSize(macho_file: *MachO, assume_max_path_len: bool) !u32
         }
 
         if (comp.config.any_sanitize_thread) {
-            const path = comp.tsan_lib.?.full_object_path;
+            const path = try comp.tsan_lib.?.full_object_path.toString(gpa);
+            defer gpa.free(path);
             const rpath = std.fs.path.dirname(path) orelse ".";
             sizeofcmds += calcInstallNameLen(
                 @sizeOf(macho.rpath_command),
diff --git a/zig/src/link/MachO/relocatable.zig b/zig/src/link/MachO/relocatable.zig
index e231360928..91bb295ed6 100644
--- a/zig/src/link/MachO/relocatable.zig
+++ b/zig/src/link/MachO/relocatable.zig
@@ -1,6 +1,7 @@
-pub fn flushObject(macho_file: *MachO, comp: *Compilation, module_obj_path: ?[]const u8) link.File.FlushError!void {
+pub fn flushObject(macho_file: *MachO, comp: *Compilation, module_obj_path: ?Path) link.File.FlushError!void {
     const gpa = macho_file.base.comp.gpa;
 
+    // TODO: "positional arguments" is a CLI concept, not a linker concept. Delete this unnecessary array list.
     var positionals = std.ArrayList(Compilation.LinkObject).init(gpa);
     defer positionals.deinit();
     try positionals.ensureUnusedCapacity(comp.objects.len);
@@ -19,7 +20,7 @@ pub fn flushObject(macho_file: *MachO, comp: *Compilation, module_obj_path: ?[]c
         // TODO: in the future, when we implement `dsymutil` alternative directly in the Zig
         // compiler, investigate if we can get rid of this `if` prong here.
         const path = positionals.items[0].path;
-        const in_file = try std.fs.cwd().openFile(path, .{});
+        const in_file = try path.root_dir.handle.openFile(path.sub_path, .{});
         const stat = try in_file.stat();
         const amt = try in_file.copyRangeAll(0, macho_file.base.file.?, 0, stat.size);
         if (amt != stat.size) return error.InputOutput; // TODO: report an actual user error
@@ -72,7 +73,7 @@ pub fn flushObject(macho_file: *MachO, comp: *Compilation, module_obj_path: ?[]c
     try writeHeader(macho_file, ncmds, sizeofcmds);
 }
 
-pub fn flushStaticLib(macho_file: *MachO, comp: *Compilation, module_obj_path: ?[]const u8) link.File.FlushError!void {
+pub fn flushStaticLib(macho_file: *MachO, comp: *Compilation, module_obj_path: ?Path) link.File.FlushError!void {
     const gpa = comp.gpa;
 
     var positionals = std.ArrayList(Compilation.LinkObject).init(gpa);
@@ -173,21 +174,25 @@ pub fn flushStaticLib(macho_file: *MachO, comp: *Compilation, module_obj_path: ?
 
         for (files.items) |index| {
             const file = macho_file.getFile(index).?;
-            const state = switch (file) {
-                .zig_object => |x| &x.output_ar_state,
-                .object => |x| &x.output_ar_state,
+            switch (file) {
+                .zig_object => |zo| {
+                    const state = &zo.output_ar_state;
+                    pos = mem.alignForward(usize, pos, 2);
+                    state.file_off = pos;
+                    pos += @sizeOf(Archive.ar_hdr);
+                    pos += mem.alignForward(usize, zo.basename.len + 1, ptr_width);
+                    pos += math.cast(usize, state.size) orelse return error.Overflow;
+                },
+                .object => |o| {
+                    const state = &o.output_ar_state;
+                    pos = mem.alignForward(usize, pos, 2);
+                    state.file_off = pos;
+                    pos += @sizeOf(Archive.ar_hdr);
+                    pos += mem.alignForward(usize, o.path.basename().len + 1, ptr_width);
+                    pos += math.cast(usize, state.size) orelse return error.Overflow;
+                },
                 else => unreachable,
-            };
-            const path = switch (file) {
-                .zig_object => |x| x.path,
-                .object => |x| x.path,
-                else => unreachable,
-            };
-            pos = mem.alignForward(usize, pos, 2);
-            state.file_off = pos;
-            pos += @sizeOf(Archive.ar_hdr);
-            pos += mem.alignForward(usize, path.len + 1, ptr_width);
-            pos += math.cast(usize, state.size) orelse return error.Overflow;
+            }
         }
 
         break :blk pos;
@@ -777,6 +782,7 @@ const mem = std.mem;
 const state_log = std.log.scoped(.link_state);
 const std = @import("std");
 const trace = @import("../../tracy.zig").trace;
+const Path = std.Build.Cache.Path;
 
 const Archive = @import("Archive.zig");
 const Atom = @import("Atom.zig");
diff --git a/zig/src/link/NvPtx.zig b/zig/src/link/NvPtx.zig
index 1488f65ff9..199b13a6c6 100644
--- a/zig/src/link/NvPtx.zig
+++ b/zig/src/link/NvPtx.zig
@@ -60,7 +60,6 @@ pub fn createEmpty(
             .file = null,
             .disable_lld_caching = options.disable_lld_caching,
             .build_id = options.build_id,
-            .rpath_list = options.rpath_list,
         },
         .llvm_object = llvm_object,
     };
diff --git a/zig/src/link/Plan9.zig b/zig/src/link/Plan9.zig
index 413ab7372a..483f540699 100644
--- a/zig/src/link/Plan9.zig
+++ b/zig/src/link/Plan9.zig
@@ -304,7 +304,6 @@ pub fn createEmpty(
             .file = null,
             .disable_lld_caching = options.disable_lld_caching,
             .build_id = options.build_id,
-            .rpath_list = options.rpath_list,
         },
         .sixtyfour_bit = sixtyfour_bit,
         .bases = undefined,
diff --git a/zig/src/link/SpirV.zig b/zig/src/link/SpirV.zig
index 7263b6d28d..bbc267cbc5 100644
--- a/zig/src/link/SpirV.zig
+++ b/zig/src/link/SpirV.zig
@@ -74,7 +74,6 @@ pub fn createEmpty(
             .file = null,
             .disable_lld_caching = options.disable_lld_caching,
             .build_id = options.build_id,
-            .rpath_list = options.rpath_list,
         },
         .object = codegen.Object.init(gpa),
     };
diff --git a/zig/src/link/StringTable.zig b/zig/src/link/StringTable.zig
index b03e025ff0..f8a917b249 100644
--- a/zig/src/link/StringTable.zig
+++ b/zig/src/link/StringTable.zig
@@ -15,7 +15,7 @@ pub fn insert(self: *Self, gpa: Allocator, string: []const u8) !u32 {
     if (gop.found_existing) return gop.key_ptr.*;
 
     try self.buffer.ensureUnusedCapacity(gpa, string.len + 1);
-    const new_off = @as(u32, @intCast(self.buffer.items.len));
+    const new_off: u32 = @intCast(self.buffer.items.len);
 
     self.buffer.appendSliceAssumeCapacity(string);
     self.buffer.appendAssumeCapacity(0);
diff --git a/zig/src/link/Wasm.zig b/zig/src/link/Wasm.zig
index 7d97fb4c7d..6a27909b31 100644
--- a/zig/src/link/Wasm.zig
+++ b/zig/src/link/Wasm.zig
@@ -398,7 +398,6 @@ pub fn createEmpty(
             .file = null,
             .disable_lld_caching = options.disable_lld_caching,
             .build_id = options.build_id,
-            .rpath_list = options.rpath_list,
         },
         .name = undefined,
         .import_table = options.import_table,
@@ -2508,6 +2507,7 @@ pub fn flushModule(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_no
     } else null;
 
     // Positional arguments to the linker such as object files and static archives.
+    // TODO: "positional arguments" is a CLI concept, not a linker concept. Delete this unnecessary array list.
     var positionals = std.ArrayList([]const u8).init(arena);
     try positionals.ensureUnusedCapacity(comp.objects.len);
 
@@ -2528,23 +2528,23 @@ pub fn flushModule(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_no
             (output_mode == .Lib and link_mode == .dynamic);
         if (is_exe_or_dyn_lib) {
             for (comp.wasi_emulated_libs) |crt_file| {
-                try positionals.append(try comp.get_libc_crt_file(
+                try positionals.append(try comp.crtFileAsString(
                     arena,
                     wasi_libc.emulatedLibCRFileLibName(crt_file),
                 ));
             }
 
             if (link_libc) {
-                try positionals.append(try comp.get_libc_crt_file(
+                try positionals.append(try comp.crtFileAsString(
                     arena,
                     wasi_libc.execModelCrtFileFullName(wasi_exec_model),
                 ));
-                try positionals.append(try comp.get_libc_crt_file(arena, "libc.a"));
+                try positionals.append(try comp.crtFileAsString(arena, "libc.a"));
             }
 
             if (link_libcpp) {
-                try positionals.append(comp.libcxx_static_lib.?.full_object_path);
-                try positionals.append(comp.libcxxabi_static_lib.?.full_object_path);
+                try positionals.append(try comp.libcxx_static_lib.?.full_object_path.toString(arena));
+                try positionals.append(try comp.libcxxabi_static_lib.?.full_object_path.toString(arena));
             }
         }
     }
@@ -2554,15 +2554,15 @@ pub fn flushModule(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_no
     }
 
     for (comp.objects) |object| {
-        try positionals.append(object.path);
+        try positionals.append(try object.path.toString(arena));
     }
 
     for (comp.c_object_table.keys()) |c_object| {
-        try positionals.append(c_object.status.success.object_path);
+        try positionals.append(try c_object.status.success.object_path.toString(arena));
     }
 
-    if (comp.compiler_rt_lib) |lib| try positionals.append(lib.full_object_path);
-    if (comp.compiler_rt_obj) |obj| try positionals.append(obj.full_object_path);
+    if (comp.compiler_rt_lib) |lib| try positionals.append(try lib.full_object_path.toString(arena));
+    if (comp.compiler_rt_obj) |obj| try positionals.append(try obj.full_object_path.toString(arena));
 
     try wasm.parseInputFiles(positionals.items);
 
@@ -3366,7 +3366,7 @@ fn linkWithLLD(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_node:
     defer sub_prog_node.end();
 
     const is_obj = comp.config.output_mode == .Obj;
-    const compiler_rt_path: ?[]const u8 = blk: {
+    const compiler_rt_path: ?Path = blk: {
         if (comp.compiler_rt_lib) |lib| break :blk lib.full_object_path;
         if (comp.compiler_rt_obj) |obj| break :blk obj.full_object_path;
         break :blk null;
@@ -3388,14 +3388,14 @@ fn linkWithLLD(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_node:
         comptime assert(Compilation.link_hash_implementation_version == 14);
 
         for (comp.objects) |obj| {
-            _ = try man.addFile(obj.path, null);
+            _ = try man.addFilePath(obj.path, null);
             man.hash.add(obj.must_link);
         }
         for (comp.c_object_table.keys()) |key| {
-            _ = try man.addFile(key.status.success.object_path, null);
+            _ = try man.addFilePath(key.status.success.object_path, null);
         }
         try man.addOptionalFile(module_obj_path);
-        try man.addOptionalFile(compiler_rt_path);
+        try man.addOptionalFilePath(compiler_rt_path);
         man.hash.addOptionalBytes(wasm.entry_name);
         man.hash.add(wasm.base.stack_size);
         man.hash.add(wasm.base.build_id);
@@ -3451,17 +3451,19 @@ fn linkWithLLD(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_node:
                 break :blk comp.c_object_table.keys()[0].status.success.object_path;
 
             if (module_obj_path) |p|
-                break :blk p;
+                break :blk Path.initCwd(p);
 
             // TODO I think this is unreachable. Audit this situation when solving the above TODO
             // regarding eliding redundant object -> object transformations.
             return error.NoObjectsToLink;
         };
-        // This can happen when using --enable-cache and using the stage1 backend. In this case
-        // we can skip the file copy.
-        if (!mem.eql(u8, the_object_path, full_out_path)) {
-            try fs.cwd().copyFile(the_object_path, fs.cwd(), full_out_path, .{});
-        }
+        try std.fs.Dir.copyFile(
+            the_object_path.root_dir.handle,
+            the_object_path.sub_path,
+            directory.handle,
+            wasm.base.emit.sub_path,
+            .{},
+        );
     } else {
         // Create an LLD command line and invoke it.
         var argv = std.ArrayList([]const u8).init(gpa);
@@ -3582,23 +3584,23 @@ fn linkWithLLD(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_node:
                 (comp.config.output_mode == .Lib and comp.config.link_mode == .dynamic);
             if (is_exe_or_dyn_lib) {
                 for (comp.wasi_emulated_libs) |crt_file| {
-                    try argv.append(try comp.get_libc_crt_file(
+                    try argv.append(try comp.crtFileAsString(
                         arena,
                         wasi_libc.emulatedLibCRFileLibName(crt_file),
                     ));
                 }
 
                 if (comp.config.link_libc) {
-                    try argv.append(try comp.get_libc_crt_file(
+                    try argv.append(try comp.crtFileAsString(
                         arena,
                         wasi_libc.execModelCrtFileFullName(comp.config.wasi_exec_model),
                     ));
-                    try argv.append(try comp.get_libc_crt_file(arena, "libc.a"));
+                    try argv.append(try comp.crtFileAsString(arena, "libc.a"));
                 }
 
                 if (comp.config.link_libcpp) {
-                    try argv.append(comp.libcxx_static_lib.?.full_object_path);
-                    try argv.append(comp.libcxxabi_static_lib.?.full_object_path);
+                    try argv.append(try comp.libcxx_static_lib.?.full_object_path.toString(arena));
+                    try argv.append(try comp.libcxxabi_static_lib.?.full_object_path.toString(arena));
                 }
             }
         }
@@ -3613,7 +3615,7 @@ fn linkWithLLD(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_node:
                 try argv.append("-no-whole-archive");
                 whole_archive = false;
             }
-            try argv.append(obj.path);
+            try argv.append(try obj.path.toString(arena));
         }
         if (whole_archive) {
             try argv.append("-no-whole-archive");
@@ -3621,7 +3623,7 @@ fn linkWithLLD(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_node:
         }
 
         for (comp.c_object_table.keys()) |key| {
-            try argv.append(key.status.success.object_path);
+            try argv.append(try key.status.success.object_path.toString(arena));
         }
         if (module_obj_path) |p| {
             try argv.append(p);
@@ -3631,11 +3633,11 @@ fn linkWithLLD(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_node:
             !comp.skip_linker_dependencies and
             !comp.config.link_libc)
         {
-            try argv.append(comp.libc_static_lib.?.full_object_path);
+            try argv.append(try comp.libc_static_lib.?.full_object_path.toString(arena));
         }
 
         if (compiler_rt_path) |p| {
-            try argv.append(p);
+            try argv.append(try p.toString(arena));
         }
 
         if (comp.verbose_link) {
diff --git a/zig/src/main.zig b/zig/src/main.zig
index 95f1ad569b..4e29611d9c 100644
--- a/zig/src/main.zig
+++ b/zig/src/main.zig
@@ -13,6 +13,12 @@ const warn = std.log.warn;
 const ThreadPool = std.Thread.Pool;
 const cleanExit = std.process.cleanExit;
 const native_os = builtin.os.tag;
+const Cache = std.Build.Cache;
+const Path = std.Build.Cache.Path;
+const EnvVar = std.zig.EnvVar;
+const LibCInstallation = std.zig.LibCInstallation;
+const AstGen = std.zig.AstGen;
+const Server = std.zig.Server;
 
 const tracy = @import("tracy.zig");
 const Compilation = @import("Compilation.zig");
@@ -20,16 +26,11 @@ const link = @import("link.zig");
 const Package = @import("Package.zig");
 const build_options = @import("build_options");
 const introspect = @import("introspect.zig");
-const EnvVar = std.zig.EnvVar;
-const LibCInstallation = std.zig.LibCInstallation;
 const wasi_libc = @import("wasi_libc.zig");
-const Cache = std.Build.Cache;
 const target_util = @import("target.zig");
 const crash_report = @import("crash_report.zig");
 const Zcu = @import("Zcu.zig");
-const AstGen = std.zig.AstGen;
 const mingw = @import("mingw.zig");
-const Server = std.zig.Server;
 const dev = @import("dev.zig");
 
 pub const std_options = .{
@@ -44,8 +45,7 @@ pub const std_options = .{
     },
 };
 
-// Crash report needs to override the panic handler
-pub const panic = crash_report.panic;
+pub const Panic = crash_report.Panic;
 
 var wasi_preopens: fs.wasi.Preopens = undefined;
 pub fn wasi_cwd() std.os.wasi.fd_t {
@@ -826,7 +826,6 @@ fn buildOutputType(
     var version: std.SemanticVersion = .{ .major = 0, .minor = 0, .patch = 0 };
     var have_version = false;
     var compatibility_version: ?std.SemanticVersion = null;
-    var formatted_panics: ?bool = null;
     var function_sections = false;
     var data_sections = false;
     var no_builtin = false;
@@ -1537,9 +1536,11 @@ fn buildOutputType(
                     } else if (mem.eql(u8, arg, "-gdwarf64")) {
                         create_module.opts.debug_format = .{ .dwarf = .@"64" };
                     } else if (mem.eql(u8, arg, "-fformatted-panics")) {
-                        formatted_panics = true;
+                        // Remove this after 0.15.0 is tagged.
+                        warn("-fformatted-panics is deprecated and does nothing", .{});
                     } else if (mem.eql(u8, arg, "-fno-formatted-panics")) {
-                        formatted_panics = false;
+                        // Remove this after 0.15.0 is tagged.
+                        warn("-fno-formatted-panics is deprecated and does nothing", .{});
                     } else if (mem.eql(u8, arg, "-fsingle-threaded")) {
                         mod_opts.single_threaded = true;
                     } else if (mem.eql(u8, arg, "-fno-single-threaded")) {
@@ -1703,8 +1704,11 @@ fn buildOutputType(
                         try cc_argv.append(arena, arg);
                     } else if (mem.startsWith(u8, arg, "-I")) {
                         try cssan.addIncludePath(arena, &cc_argv, .I, arg, arg[2..], true);
-                    } else if (mem.eql(u8, arg, "-x")) {
-                        const lang = args_iter.nextOrFatal();
+                    } else if (mem.startsWith(u8, arg, "-x")) {
+                        const lang = if (arg.len == "-x".len)
+                            args_iter.nextOrFatal()
+                        else
+                            arg["-x".len..];
                         if (mem.eql(u8, lang, "none")) {
                             file_ext = null;
                         } else if (Compilation.LangToExt.get(lang)) |got_ext| {
@@ -1721,14 +1725,14 @@ fn buildOutputType(
                     }
                 } else switch (file_ext orelse Compilation.classifyFileExt(arg)) {
                     .shared_library => {
-                        try create_module.link_objects.append(arena, .{ .path = arg });
+                        try create_module.link_objects.append(arena, .{ .path = Path.initCwd(arg) });
                         create_module.opts.any_dyn_libs = true;
                     },
                     .object, .static_library => {
-                        try create_module.link_objects.append(arena, .{ .path = arg });
+                        try create_module.link_objects.append(arena, .{ .path = Path.initCwd(arg) });
                     },
                     .res => {
-                        try create_module.link_objects.append(arena, .{ .path = arg });
+                        try create_module.link_objects.append(arena, .{ .path = Path.initCwd(arg) });
                         contains_res_file = true;
                     },
                     .manifest => {
@@ -1842,20 +1846,20 @@ fn buildOutputType(
                         },
                         .shared_library => {
                             try create_module.link_objects.append(arena, .{
-                                .path = it.only_arg,
+                                .path = Path.initCwd(it.only_arg),
                                 .must_link = must_link,
                             });
                             create_module.opts.any_dyn_libs = true;
                         },
                         .unknown, .object, .static_library => {
                             try create_module.link_objects.append(arena, .{
-                                .path = it.only_arg,
+                                .path = Path.initCwd(it.only_arg),
                                 .must_link = must_link,
                             });
                         },
                         .res => {
                             try create_module.link_objects.append(arena, .{
-                                .path = it.only_arg,
+                                .path = Path.initCwd(it.only_arg),
                                 .must_link = must_link,
                             });
                             contains_res_file = true;
@@ -1891,7 +1895,7 @@ fn buildOutputType(
                             // binary: no extra rpaths and DSO filename exactly
                             // as provided. Hello, Go.
                             try create_module.link_objects.append(arena, .{
-                                .path = it.only_arg,
+                                .path = Path.initCwd(it.only_arg),
                                 .must_link = must_link,
                                 .loption = true,
                             });
@@ -2529,7 +2533,7 @@ fn buildOutputType(
                     install_name = linker_args_it.nextOrFatal();
                 } else if (mem.eql(u8, arg, "-force_load")) {
                     try create_module.link_objects.append(arena, .{
-                        .path = linker_args_it.nextOrFatal(),
+                        .path = Path.initCwd(linker_args_it.nextOrFatal()),
                         .must_link = true,
                     });
                 } else if (mem.eql(u8, arg, "-hash-style") or
@@ -2704,7 +2708,7 @@ fn buildOutputType(
                 break :b create_module.c_source_files.items[0].src_path;
 
             if (create_module.link_objects.items.len >= 1)
-                break :b create_module.link_objects.items[0].path;
+                break :b create_module.link_objects.items[0].path.sub_path;
 
             if (emit_bin == .yes)
                 break :b emit_bin.yes;
@@ -2960,7 +2964,7 @@ fn buildOutputType(
                     framework_dir_path,
                     framework_name,
                 )) {
-                    const path = try arena.dupe(u8, test_path.items);
+                    const path = Path.initCwd(try arena.dupe(u8, test_path.items));
                     try resolved_frameworks.append(.{
                         .needed = info.needed,
                         .weak = info.weak,
@@ -3405,7 +3409,6 @@ fn buildOutputType(
         .force_undefined_symbols = force_undefined_symbols,
         .stack_size = stack_size,
         .image_base = image_base,
-        .formatted_panics = formatted_panics,
         .function_sections = function_sections,
         .data_sections = data_sections,
         .no_builtin = no_builtin,
@@ -3633,7 +3636,7 @@ const CreateModule = struct {
         name: []const u8,
         lib: Compilation.SystemLib,
     }),
-    wasi_emulated_libs: std.ArrayListUnmanaged(wasi_libc.CRTFile),
+    wasi_emulated_libs: std.ArrayListUnmanaged(wasi_libc.CrtFile),
 
     c_source_files: std.ArrayListUnmanaged(Compilation.CSourceFile),
     rc_source_files: std.ArrayListUnmanaged(Compilation.RcSourceFile),
@@ -3806,7 +3809,7 @@ fn createModule(
             }
 
             if (target.os.tag == .wasi) {
-                if (wasi_libc.getEmulatedLibCRTFile(lib_name)) |crt_file| {
+                if (wasi_libc.getEmulatedLibCrtFile(lib_name)) |crt_file| {
                     try create_module.wasi_emulated_libs.append(arena, crt_file);
                     continue;
                 }
@@ -3874,7 +3877,7 @@ fn createModule(
             };
         }
 
-        if (builtin.target.os.tag == .windows and target.abi == .msvc and
+        if (builtin.target.os.tag == .windows and (target.abi == .msvc or target.abi == .itanium) and
             external_system_libs.len != 0)
         {
             if (create_module.libc_installation == null) {
@@ -3927,7 +3930,7 @@ fn createModule(
                                 target,
                                 info.preferred_mode,
                             )) {
-                                const path = try arena.dupe(u8, test_path.items);
+                                const path = Path.initCwd(try arena.dupe(u8, test_path.items));
                                 switch (info.preferred_mode) {
                                     .static => try create_module.link_objects.append(arena, .{ .path = path }),
                                     .dynamic => try create_module.resolved_system_libs.append(arena, .{
@@ -3961,7 +3964,7 @@ fn createModule(
                                 target,
                                 info.fallbackMode(),
                             )) {
-                                const path = try arena.dupe(u8, test_path.items);
+                                const path = Path.initCwd(try arena.dupe(u8, test_path.items));
                                 switch (info.fallbackMode()) {
                                     .static => try create_module.link_objects.append(arena, .{ .path = path }),
                                     .dynamic => try create_module.resolved_system_libs.append(arena, .{
@@ -3995,7 +3998,7 @@ fn createModule(
                                 target,
                                 info.preferred_mode,
                             )) {
-                                const path = try arena.dupe(u8, test_path.items);
+                                const path = Path.initCwd(try arena.dupe(u8, test_path.items));
                                 switch (info.preferred_mode) {
                                     .static => try create_module.link_objects.append(arena, .{ .path = path }),
                                     .dynamic => try create_module.resolved_system_libs.append(arena, .{
@@ -4019,7 +4022,7 @@ fn createModule(
                                 target,
                                 info.fallbackMode(),
                             )) {
-                                const path = try arena.dupe(u8, test_path.items);
+                                const path = Path.initCwd(try arena.dupe(u8, test_path.items));
                                 switch (info.fallbackMode()) {
                                     .static => try create_module.link_objects.append(arena, .{ .path = path }),
                                     .dynamic => try create_module.resolved_system_libs.append(arena, .{
@@ -6161,7 +6164,7 @@ fn cmdAstCheck(
     }
 
     file.mod = try Package.Module.createLimited(arena, .{
-        .root = Cache.Path.cwd(),
+        .root = Path.cwd(),
         .root_src_path = file.sub_file_path,
         .fully_qualified_name = "root",
     });
@@ -6521,7 +6524,7 @@ fn cmdChangelist(
     };
 
     file.mod = try Package.Module.createLimited(arena, .{
-        .root = Cache.Path.cwd(),
+        .root = Path.cwd(),
         .root_src_path = file.sub_file_path,
         .fully_qualified_name = "root",
     });
@@ -7214,8 +7217,21 @@ fn cmdFetch(
                 .path => {},
             }
         }
+
+        const location_replace = try std.fmt.allocPrint(
+            arena,
+            "\"{}\"",
+            .{std.zig.fmtEscapes(saved_path_or_url)},
+        );
+        const hash_replace = try std.fmt.allocPrint(
+            arena,
+            "\"{}\"",
+            .{std.zig.fmtEscapes(&hex_digest)},
+        );
+
         warn("overwriting existing dependency named '{s}'", .{name});
-        try fixups.replace_nodes_with_string.put(gpa, dep.node, new_node_init);
+        try fixups.replace_nodes_with_string.put(gpa, dep.location_node, location_replace);
+        try fixups.replace_nodes_with_string.put(gpa, dep.hash_node, hash_replace);
     } else if (manifest.dependencies.count() > 0) {
         // Add fixup for adding another dependency.
         const deps = manifest.dependencies.values();
diff --git a/zig/src/mingw.zig b/zig/src/mingw.zig
index ab5f4f26db..d26358450c 100644
--- a/zig/src/mingw.zig
+++ b/zig/src/mingw.zig
@@ -11,13 +11,13 @@ const build_options = @import("build_options");
 const Cache = std.Build.Cache;
 const dev = @import("dev.zig");
 
-pub const CRTFile = enum {
+pub const CrtFile = enum {
     crt2_o,
     dllcrt2_o,
     mingw32_lib,
 };
 
-pub fn buildCRTFile(comp: *Compilation, crt_file: CRTFile, prog_node: std.Progress.Node) !void {
+pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progress.Node) !void {
     if (!build_options.have_llvm) {
         return error.ZigCompilerNotBuiltWithLLVMExtensions;
     }
@@ -160,7 +160,9 @@ fn add_cc_args(
 pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {
     dev.check(.build_import_lib);
 
-    var arena_allocator = std.heap.ArenaAllocator.init(comp.gpa);
+    const gpa = comp.gpa;
+
+    var arena_allocator = std.heap.ArenaAllocator.init(gpa);
     defer arena_allocator.deinit();
     const arena = arena_allocator.allocator();
 
@@ -178,7 +180,7 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {
 
     // Use the global cache directory.
     var cache: Cache = .{
-        .gpa = comp.gpa,
+        .gpa = gpa,
         .manifest_dir = try comp.global_cache_directory.handle.makeOpenPath("h", .{}),
     };
     cache.addPrefix(.{ .path = null, .handle = std.fs.cwd() });
@@ -195,17 +197,18 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {
 
     _ = try man.addFile(def_file_path, null);
 
-    const final_lib_basename = try std.fmt.allocPrint(comp.gpa, "{s}.lib", .{lib_name});
-    errdefer comp.gpa.free(final_lib_basename);
+    const final_lib_basename = try std.fmt.allocPrint(gpa, "{s}.lib", .{lib_name});
+    errdefer gpa.free(final_lib_basename);
 
     if (try man.hit()) {
         const digest = man.final();
 
-        try comp.crt_files.ensureUnusedCapacity(comp.gpa, 1);
+        try comp.crt_files.ensureUnusedCapacity(gpa, 1);
         comp.crt_files.putAssumeCapacityNoClobber(final_lib_basename, .{
-            .full_object_path = try comp.global_cache_directory.join(comp.gpa, &[_][]const u8{
-                "o", &digest, final_lib_basename,
-            }),
+            .full_object_path = .{
+                .root_dir = comp.global_cache_directory,
+                .sub_path = try std.fs.path.join(gpa, &.{ "o", &digest, final_lib_basename }),
+            },
             .lock = man.toOwnedLock(),
         });
         return;
@@ -230,7 +233,7 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {
     };
 
     const aro = @import("aro");
-    var aro_comp = aro.Compilation.init(comp.gpa, std.fs.cwd());
+    var aro_comp = aro.Compilation.init(gpa, std.fs.cwd());
     defer aro_comp.deinit();
 
     const include_dir = try comp.zig_lib_directory.join(arena, &[_][]const u8{ "libc", "mingw", "def-include" });
@@ -244,7 +247,7 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {
         nosuspend stderr.print("output path: {s}\n", .{def_final_path}) catch break :print;
     }
 
-    try aro_comp.include_dirs.append(comp.gpa, include_dir);
+    try aro_comp.include_dirs.append(gpa, include_dir);
 
     const builtin_macros = try aro_comp.generateBuiltinMacros(.include_system_defines);
     const user_macros = try aro_comp.addSourceFromBuffer("<command line>", target_defines);
@@ -271,17 +274,15 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {
         try pp.prettyPrintTokens(def_final_file.writer(), .result_only);
     }
 
-    const lib_final_path = try comp.global_cache_directory.join(comp.gpa, &[_][]const u8{
-        "o", &digest, final_lib_basename,
-    });
-    errdefer comp.gpa.free(lib_final_path);
+    const lib_final_path = try std.fs.path.join(gpa, &.{ "o", &digest, final_lib_basename });
+    errdefer gpa.free(lib_final_path);
 
     if (!build_options.have_llvm) return error.ZigCompilerNotBuiltWithLLVMExtensions;
     const llvm_bindings = @import("codegen/llvm/bindings.zig");
     const llvm = @import("codegen/llvm.zig");
     const arch_tag = llvm.targetArch(target.cpu.arch);
     const def_final_path_z = try arena.dupeZ(u8, def_final_path);
-    const lib_final_path_z = try arena.dupeZ(u8, lib_final_path);
+    const lib_final_path_z = try comp.global_cache_directory.joinZ(arena, &.{lib_final_path});
     if (llvm_bindings.WriteImportLibrary(def_final_path_z.ptr, arch_tag, lib_final_path_z.ptr, true)) {
         // TODO surface a proper error here
         log.err("unable to turn {s}.def into {s}.lib", .{ lib_name, lib_name });
@@ -292,8 +293,11 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {
         log.warn("failed to write cache manifest for DLL import {s}.lib: {s}", .{ lib_name, @errorName(err) });
     };
 
-    try comp.crt_files.putNoClobber(comp.gpa, final_lib_basename, .{
-        .full_object_path = lib_final_path,
+    try comp.crt_files.putNoClobber(gpa, final_lib_basename, .{
+        .full_object_path = .{
+            .root_dir = comp.global_cache_directory,
+            .sub_path = lib_final_path,
+        },
         .lock = man.toOwnedLock(),
     });
 }
diff --git a/zig/src/musl.zig b/zig/src/musl.zig
index 5ddbcb6652..48717dc5a1 100644
--- a/zig/src/musl.zig
+++ b/zig/src/musl.zig
@@ -9,7 +9,7 @@ const archName = std.zig.target.muslArchName;
 const Compilation = @import("Compilation.zig");
 const build_options = @import("build_options");
 
-pub const CRTFile = enum {
+pub const CrtFile = enum {
     crti_o,
     crtn_o,
     crt1_o,
@@ -19,7 +19,7 @@ pub const CRTFile = enum {
     libc_so,
 };
 
-pub fn buildCRTFile(comp: *Compilation, crt_file: CRTFile, prog_node: std.Progress.Node) !void {
+pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progress.Node) !void {
     if (!build_options.have_llvm) {
         return error.ZigCompilerNotBuiltWithLLVMExtensions;
     }
diff --git a/zig/src/mutable_value.zig b/zig/src/mutable_value.zig
index 49826c2fb2..9e63494d12 100644
--- a/zig/src/mutable_value.zig
+++ b/zig/src/mutable_value.zig
@@ -88,11 +88,11 @@ pub const MutableValue = union(enum) {
                 .ptr = (try s.ptr.intern(pt, arena)).toIntern(),
                 .len = (try s.len.intern(pt, arena)).toIntern(),
             } }),
-            .un => |u| try pt.intern(.{ .un = .{
+            .un => |u| try pt.internUnion(.{
                 .ty = u.ty,
                 .tag = u.tag,
                 .val = (try u.payload.intern(pt, arena)).toIntern(),
-            } }),
+            }),
         });
     }
 
diff --git a/zig/src/print_air.zig b/zig/src/print_air.zig
index 7ff727ff0c..6a3f31a27c 100644
--- a/zig/src/print_air.zig
+++ b/zig/src/print_air.zig
@@ -303,7 +303,6 @@ const Writer = struct {
             .try_ptr, .try_ptr_cold => try w.writeTryPtr(s, inst),
             .loop_switch_br, .switch_br => try w.writeSwitchBr(s, inst),
             .cmpxchg_weak, .cmpxchg_strong => try w.writeCmpxchg(s, inst),
-            .fence => try w.writeFence(s, inst),
             .atomic_load => try w.writeAtomicLoad(s, inst),
             .prefetch => try w.writePrefetch(s, inst),
             .atomic_store_unordered => try w.writeAtomicStore(s, inst, .unordered),
@@ -552,12 +551,6 @@ const Writer = struct {
         try w.writeOperand(s, inst, 2, extra.rhs);
     }
 
-    fn writeFence(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
-        const atomic_order = w.air.instructions.items(.data)[@intFromEnum(inst)].fence;
-
-        try s.print("{s}", .{@tagName(atomic_order)});
-    }
-
     fn writeAtomicLoad(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
         const atomic_load = w.air.instructions.items(.data)[@intFromEnum(inst)].atomic_load;
 
diff --git a/zig/src/print_zir.zig b/zig/src/print_zir.zig
index c5f1517edd..5467dcd27a 100644
--- a/zig/src/print_zir.zig
+++ b/zig/src/print_zir.zig
@@ -203,7 +203,7 @@ const Writer = struct {
             .alloc_comptime_mut,
             .elem_type,
             .indexable_ptr_elem_type,
-            .vector_elem_type,
+            .vec_arr_elem_type,
             .indexable_ptr_len,
             .anyframe_type,
             .bit_not,
@@ -566,7 +566,6 @@ const Writer = struct {
             .await_nosuspend,
             .c_undef,
             .c_include,
-            .fence,
             .set_float_mode,
             .set_align_stack,
             .wasm_memory_size,
diff --git a/zig/src/target.zig b/zig/src/target.zig
index 59c151bd6e..95c9798f65 100644
--- a/zig/src/target.zig
+++ b/zig/src/target.zig
@@ -31,7 +31,7 @@ pub fn libcNeedsLibUnwind(target: std.Target) bool {
         .wasi, // Wasm/WASI currently doesn't offer support for libunwind, so don't link it.
         => false,
 
-        .windows => target.abi != .msvc,
+        .windows => target.abi.isGnu(),
         else => true,
     };
 }
@@ -45,8 +45,7 @@ pub fn requiresPIC(target: std.Target, linking_libc: bool) bool {
     return target.isAndroid() or
         target.os.tag == .windows or target.os.tag == .uefi or
         osRequiresLibC(target) or
-        (linking_libc and target.isGnuLibC()) or
-        (target.abi == .ohos and target.cpu.arch == .aarch64);
+        (linking_libc and target.isGnuLibC());
 }
 
 pub fn picLevel(target: std.Target) u32 {
@@ -87,7 +86,7 @@ pub fn hasValgrindSupport(target: std.Target) bool {
         .aarch64_be,
         => {
             return target.os.tag == .linux or target.os.tag == .solaris or target.os.tag == .illumos or
-                (target.os.tag == .windows and target.abi != .msvc);
+                (target.os.tag == .windows and target.abi.isGnu());
         },
         else => return false,
     }
@@ -104,7 +103,6 @@ pub fn hasLlvmSupport(target: std.Target, ofmt: std.Target.ObjectFormat) bool {
         => return false,
 
         .coff,
-        .dxcontainer,
         .elf,
         .goff,
         .hex,
@@ -161,7 +159,6 @@ pub fn hasLlvmSupport(target: std.Target, ofmt: std.Target.ObjectFormat) bool {
         => true,
 
         // An LLVM backend exists but we don't currently support using it.
-        .dxil,
         .spirv,
         .spirv32,
         .spirv64,
@@ -170,6 +167,8 @@ pub fn hasLlvmSupport(target: std.Target, ofmt: std.Target.ObjectFormat) bool {
         // No LLVM backend exists.
         .kalimba,
         .spu_2,
+        .propeller1,
+        .propeller2,
         => false,
     };
 }
@@ -306,20 +305,17 @@ pub fn libcFullLinkFlags(target: std.Target) []const []const u8 {
             "-lc",
             "-lnetwork",
         },
-        else => switch (target.abi) {
-            .android => &[_][]const u8{
-                "-lm",
-                "-lc",
-                "-ldl",
-            },
-            else => &[_][]const u8{
-                "-lm",
-                "-lpthread",
-                "-lc",
-                "-ldl",
-                "-lrt",
-                "-lutil",
-            },
+        else => if (target.isAndroid() or target.abi.isOpenHarmony()) &[_][]const u8{
+            "-lm",
+            "-lc",
+            "-ldl",
+        } else &[_][]const u8{
+            "-lm",
+            "-lpthread",
+            "-lc",
+            "-ldl",
+            "-lrt",
+            "-lutil",
         },
     };
 }
@@ -588,14 +584,6 @@ pub inline fn backendSupportsFeature(backend: std.builtin.CompilerBackend, compt
             => true,
             else => false,
         },
-        .panic_unwrap_error => switch (backend) {
-            .stage2_c, .stage2_llvm => true,
-            else => false,
-        },
-        .safety_check_formatted => switch (backend) {
-            .stage2_c, .stage2_llvm => true,
-            else => false,
-        },
         .error_return_trace => switch (backend) {
             .stage2_llvm => true,
             else => false,
diff --git a/zig/src/wasi_libc.zig b/zig/src/wasi_libc.zig
index 57d93b6f56..ce94110b69 100644
--- a/zig/src/wasi_libc.zig
+++ b/zig/src/wasi_libc.zig
@@ -6,7 +6,7 @@ const Allocator = std.mem.Allocator;
 const Compilation = @import("Compilation.zig");
 const build_options = @import("build_options");
 
-pub const CRTFile = enum {
+pub const CrtFile = enum {
     crt1_reactor_o,
     crt1_command_o,
     libc_a,
@@ -16,7 +16,7 @@ pub const CRTFile = enum {
     libwasi_emulated_signal_a,
 };
 
-pub fn getEmulatedLibCRTFile(lib_name: []const u8) ?CRTFile {
+pub fn getEmulatedLibCrtFile(lib_name: []const u8) ?CrtFile {
     if (mem.eql(u8, lib_name, "wasi-emulated-process-clocks")) {
         return .libwasi_emulated_process_clocks_a;
     }
@@ -32,7 +32,7 @@ pub fn getEmulatedLibCRTFile(lib_name: []const u8) ?CRTFile {
     return null;
 }
 
-pub fn emulatedLibCRFileLibName(crt_file: CRTFile) []const u8 {
+pub fn emulatedLibCRFileLibName(crt_file: CrtFile) []const u8 {
     return switch (crt_file) {
         .libwasi_emulated_process_clocks_a => "libwasi-emulated-process-clocks.a",
         .libwasi_emulated_getpid_a => "libwasi-emulated-getpid.a",
@@ -42,10 +42,10 @@ pub fn emulatedLibCRFileLibName(crt_file: CRTFile) []const u8 {
     };
 }
 
-pub fn execModelCrtFile(wasi_exec_model: std.builtin.WasiExecModel) CRTFile {
+pub fn execModelCrtFile(wasi_exec_model: std.builtin.WasiExecModel) CrtFile {
     return switch (wasi_exec_model) {
-        .reactor => CRTFile.crt1_reactor_o,
-        .command => CRTFile.crt1_command_o,
+        .reactor => CrtFile.crt1_reactor_o,
+        .command => CrtFile.crt1_command_o,
     };
 }
 
@@ -57,7 +57,7 @@ pub fn execModelCrtFileFullName(wasi_exec_model: std.builtin.WasiExecModel) []co
     };
 }
 
-pub fn buildCRTFile(comp: *Compilation, crt_file: CRTFile, prog_node: std.Progress.Node) !void {
+pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progress.Node) !void {
     if (!build_options.have_llvm) {
         return error.ZigCompilerNotBuiltWithLLVMExtensions;
     }
diff --git a/zig/test/behavior/array.zig b/zig/test/behavior/array.zig
index a01e624a5d..17b8667238 100644
--- a/zig/test/behavior/array.zig
+++ b/zig/test/behavior/array.zig
@@ -1021,3 +1021,70 @@ test "runtime index of array of zero-bit values" {
     try std.testing.expect(result.index == 0);
     try std.testing.expect(result.value == {});
 }
+
+test "@splat array" {
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    const S = struct {
+        fn doTheTest(comptime T: type, x: T) !void {
+            const arr: [10]T = @splat(x);
+            for (arr) |elem| {
+                try expectEqual(x, elem);
+            }
+        }
+    };
+
+    try S.doTheTest(u32, 123);
+    try comptime S.doTheTest(u32, 123);
+
+    const Foo = struct { x: u8 };
+    try S.doTheTest(Foo, .{ .x = 10 });
+    try comptime S.doTheTest(Foo, .{ .x = 10 });
+}
+
+test "@splat array with sentinel" {
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    const S = struct {
+        fn doTheTest(comptime T: type, x: T, comptime s: T) !void {
+            const arr: [10:s]T = @splat(x);
+            for (arr) |elem| {
+                try expectEqual(x, elem);
+            }
+            const ptr: [*]const T = &arr;
+            try expectEqual(s, ptr[10]); // sentinel correct
+        }
+    };
+
+    try S.doTheTest(u32, 100, 42);
+    try comptime S.doTheTest(u32, 100, 42);
+
+    try S.doTheTest(?*anyopaque, @ptrFromInt(0x1000), null);
+    try comptime S.doTheTest(?*anyopaque, @ptrFromInt(0x1000), null);
+}
+
+test "@splat zero-length array" {
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    const S = struct {
+        fn doTheTest(comptime T: type, comptime s: T) !void {
+            var runtime_undef: T = undefined;
+            runtime_undef = undefined;
+            // The array should be comptime-known despite the `@splat` operand being runtime-known.
+            const arr: [0:s]T = @splat(runtime_undef);
+            const ptr: [*]const T = &arr;
+            comptime assert(ptr[0] == s);
+        }
+    };
+
+    try S.doTheTest(u32, 42);
+    try comptime S.doTheTest(u32, 42);
+
+    try S.doTheTest(?*anyopaque, null);
+    try comptime S.doTheTest(?*anyopaque, null);
+}
diff --git a/zig/test/behavior/atomics.zig b/zig/test/behavior/atomics.zig
index f2c2387729..7d68a41864 100644
--- a/zig/test/behavior/atomics.zig
+++ b/zig/test/behavior/atomics.zig
@@ -37,16 +37,6 @@ fn testCmpxchg() !void {
     try expect(x == 42);
 }
 
-test "fence" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
-    var x: i32 = 1234;
-    @fence(.seq_cst);
-    x = 5678;
-}
-
 test "atomicrmw and atomicload" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
diff --git a/zig/test/behavior/basic.zig b/zig/test/behavior/basic.zig
index 9acfd56d27..d6239889d8 100644
--- a/zig/test/behavior/basic.zig
+++ b/zig/test/behavior/basic.zig
@@ -1425,6 +1425,7 @@ test "allocation and looping over 3-byte integer" {
     if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .macos) {
         return error.SkipZigTest; // TODO
     }
+    if (builtin.cpu.arch == .s390x and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest; // TODO
 
     try expect(@sizeOf(u24) == 4);
     try expect(@sizeOf([1]u24) == 4);
diff --git a/zig/test/behavior/bitcast.zig b/zig/test/behavior/bitcast.zig
index 32ea5a62e6..2ef97c8310 100644
--- a/zig/test/behavior/bitcast.zig
+++ b/zig/test/behavior/bitcast.zig
@@ -429,9 +429,6 @@ test "bitcast nan float does not modify signaling bit" {
     if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
-    // TODO: https://github.com/ziglang/zig/issues/14366
-    if (builtin.zig_backend == .stage2_llvm and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
-
     const snan_u16: u16 = 0x7D00;
     const snan_u32: u32 = 0x7FA00000;
     const snan_u64: u64 = 0x7FF4000000000000;
diff --git a/zig/test/behavior/builtin_functions_returning_void_or_noreturn.zig b/zig/test/behavior/builtin_functions_returning_void_or_noreturn.zig
index 01b3062511..52a3094f3b 100644
--- a/zig/test/behavior/builtin_functions_returning_void_or_noreturn.zig
+++ b/zig/test/behavior/builtin_functions_returning_void_or_noreturn.zig
@@ -16,7 +16,6 @@ test {
     try testing.expectEqual({}, @atomicStore(u8, &val, 0, .unordered));
     try testing.expectEqual(void, @TypeOf(@breakpoint()));
     try testing.expectEqual({}, @export(&x, .{ .name = "x" }));
-    try testing.expectEqual({}, @fence(.acquire));
     try testing.expectEqual({}, @memcpy(@as([*]u8, @ptrFromInt(1))[0..0], @as([*]u8, @ptrFromInt(1))[0..0]));
     try testing.expectEqual({}, @memset(@as([*]u8, @ptrFromInt(1))[0..0], undefined));
     try testing.expectEqual(noreturn, @TypeOf(if (true) @panic("") else {}));
diff --git a/zig/test/behavior/export_keyword.zig b/zig/test/behavior/export_keyword.zig
index 70839959d2..bb86c287ca 100644
--- a/zig/test/behavior/export_keyword.zig
+++ b/zig/test/behavior/export_keyword.zig
@@ -39,3 +39,16 @@ export fn testPackedStuff(a: *const PackedStruct, b: *const PackedUnion) void {
         b;
     }
 }
+
+test "export function alias" {
+    _ = struct {
+        fn foo_internal() callconv(.C) u32 {
+            return 123;
+        }
+        export const foo_exported = foo_internal;
+    };
+    const Import = struct {
+        extern fn foo_exported() u32;
+    };
+    try expect(Import.foo_exported() == 123);
+}
diff --git a/zig/test/behavior/math.zig b/zig/test/behavior/math.zig
index bbf87fc834..1cd7583abc 100644
--- a/zig/test/behavior/math.zig
+++ b/zig/test/behavior/math.zig
@@ -167,7 +167,6 @@ fn testOneCtz(comptime T: type, x: T) u32 {
 }
 
 test "@ctz 128-bit integers" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
@@ -776,7 +775,6 @@ fn should_not_be_zero(x: f128) !void {
 }
 
 test "128-bit multiplication" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@@ -1204,7 +1202,6 @@ test "allow signed integer division/remainder when values are comptime-known and
 }
 
 test "quad hex float literal parsing accurate" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@@ -1363,7 +1360,6 @@ test "comptime float rem int" {
 }
 
 test "remainder division" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@@ -1403,7 +1399,6 @@ fn remdivOne(comptime T: type, a: T, b: T, c: T) !void {
 }
 
 test "float remainder division using @rem" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@@ -1447,7 +1442,6 @@ fn fremOne(comptime T: type, a: T, b: T, c: T, epsilon: T) !void {
 }
 
 test "float modulo division using @mod" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
diff --git a/zig/test/behavior/union.zig b/zig/test/behavior/union.zig
index b0209c124e..a87631c9e4 100644
--- a/zig/test/behavior/union.zig
+++ b/zig/test/behavior/union.zig
@@ -1893,6 +1893,7 @@ test "reinterpret packed union" {
     if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/21050
     if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/21050
     if (builtin.cpu.arch.isWasm()) return error.SkipZigTest; // TODO
+    if (builtin.cpu.arch == .s390x and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest; // TODO
     try S.doTheTest();
 }
 
diff --git a/zig/test/behavior/var_args.zig b/zig/test/behavior/var_args.zig
index 8445df14d0..350379bdfe 100644
--- a/zig/test/behavior/var_args.zig
+++ b/zig/test/behavior/var_args.zig
@@ -105,6 +105,7 @@ test "simple variadic function" {
         return error.SkipZigTest;
     }
     if (builtin.cpu.arch == .x86_64 and builtin.os.tag == .windows) return error.SkipZigTest; // TODO
+    if (builtin.cpu.arch == .s390x and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/21350
 
     const S = struct {
         fn simple(...) callconv(.C) c_int {
@@ -165,6 +166,7 @@ test "coerce reference to var arg" {
         return error.SkipZigTest;
     }
     if (builtin.cpu.arch == .x86_64 and builtin.os.tag == .windows) return error.SkipZigTest; // TODO
+    if (builtin.cpu.arch == .s390x and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/21350
 
     const S = struct {
         fn addPtr(count: c_int, ...) callconv(.C) c_int {
@@ -197,6 +199,7 @@ test "variadic functions" {
         return error.SkipZigTest;
     }
     if (builtin.cpu.arch == .x86_64 and builtin.os.tag == .windows) return error.SkipZigTest; // TODO
+    if (builtin.cpu.arch == .s390x and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/21350
 
     const S = struct {
         fn printf(list_ptr: *std.ArrayList(u8), format: [*:0]const u8, ...) callconv(.C) void {
@@ -241,6 +244,7 @@ test "copy VaList" {
         return error.SkipZigTest;
     }
     if (builtin.cpu.arch == .x86_64 and builtin.os.tag == .windows) return error.SkipZigTest; // TODO
+    if (builtin.cpu.arch == .s390x and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/21350
 
     const S = struct {
         fn add(count: c_int, ...) callconv(.C) c_int {
@@ -277,6 +281,7 @@ test "unused VaList arg" {
         // https://github.com/ziglang/zig/issues/16961
         return error.SkipZigTest; // TODO
     }
+    if (builtin.cpu.arch == .s390x and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/21350
 
     const S = struct {
         fn thirdArg(dummy: c_int, ...) callconv(.C) c_int {
diff --git a/zig/test/cases/compile_errors/array slice sentinel mismatch non-scalar.zig b/zig/test/cases/compile_errors/array slice sentinel mismatch non-scalar.zig
new file mode 100644
index 0000000000..085caffc99
--- /dev/null
+++ b/zig/test/cases/compile_errors/array slice sentinel mismatch non-scalar.zig	
@@ -0,0 +1,13 @@
+export fn foo() void {
+    const S = struct { a: u32 };
+    var arr = [_]S{ .{ .a = 1 }, .{ .a = 2 } };
+    const s = arr[0..1 :.{ .a = 1 }];
+    _ = s;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :4:26: error: non-scalar sentinel type 'tmp.foo.S'
+// :2:15: note: struct declared here
diff --git a/zig/test/cases/compile_errors/atomic_orderings_of_fence_Acquire_or_stricter.zig b/zig/test/cases/compile_errors/atomic_orderings_of_fence_Acquire_or_stricter.zig
deleted file mode 100644
index 63437e71ce..0000000000
--- a/zig/test/cases/compile_errors/atomic_orderings_of_fence_Acquire_or_stricter.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn entry() void {
-    @fence(.monotonic);
-}
-
-// error
-// backend=stage2
-// target=native
-//
-// :2:13: error: atomic ordering must be acquire or stricter
diff --git a/zig/test/cases/compile_errors/comptime_var_referenced_at_runtime.zig b/zig/test/cases/compile_errors/comptime_var_referenced_at_runtime.zig
index 30c3b2b850..2a5868f6b1 100644
--- a/zig/test/cases/compile_errors/comptime_var_referenced_at_runtime.zig
+++ b/zig/test/cases/compile_errors/comptime_var_referenced_at_runtime.zig
@@ -47,6 +47,22 @@ export fn qar() void {
     _ = y;
 }
 
+export fn bux() void {
+    comptime var x: [2]u32 = undefined;
+    x = .{ 1, 2 };
+
+    var rt: [2]u32 = undefined;
+    @memcpy(&rt, &x);
+}
+
+export fn far() void {
+    comptime var x: u32 = 123;
+
+    var rt: [2]*u32 = undefined;
+    const elem: *u32 = &x;
+    @memset(&rt, elem);
+}
+
 // error
 //
 // :5:19: error: runtime value contains reference to comptime var
@@ -63,3 +79,7 @@ export fn qar() void {
 // :41:12: note: comptime var pointers are not available at runtime
 // :46:39: error: runtime value contains reference to comptime var
 // :46:39: note: comptime var pointers are not available at runtime
+// :55:18: error: runtime value contains reference to comptime var
+// :55:18: note: comptime var pointers are not available at runtime
+// :63:18: error: runtime value contains reference to comptime var
+// :63:18: note: comptime var pointers are not available at runtime
diff --git a/zig/test/cases/compile_errors/comptime_var_referenced_by_decl.zig b/zig/test/cases/compile_errors/comptime_var_referenced_by_decl.zig
index a5dce623ed..e11af45df3 100644
--- a/zig/test/cases/compile_errors/comptime_var_referenced_by_decl.zig
+++ b/zig/test/cases/compile_errors/comptime_var_referenced_by_decl.zig
@@ -38,6 +38,12 @@ export const g: *const *const u32 = g: {
     break :g &aggregate[0];
 };
 
+// Mutable globals should have the same restrictions as const globals.
+export var h: *[1]u32 = h: {
+    var x: [1]u32 = .{123};
+    break :h &x;
+};
+
 // error
 //
 // :1:27: error: global variable contains reference to comptime var
@@ -47,3 +53,4 @@ export const g: *const *const u32 = g: {
 // :22:24: error: global variable contains reference to comptime var
 // :28:33: error: global variable contains reference to comptime var
 // :34:40: error: global variable contains reference to comptime var
+// :42:28: error: global variable contains reference to comptime var
diff --git a/zig/test/cases/compile_errors/destructure_error_union.zig b/zig/test/cases/compile_errors/destructure_error_union.zig
new file mode 100644
index 0000000000..fb5872707d
--- /dev/null
+++ b/zig/test/cases/compile_errors/destructure_error_union.zig
@@ -0,0 +1,15 @@
+pub export fn entry() void {
+    const Foo = struct { u8, u8 };
+    const foo: anyerror!Foo = error.Failure;
+    const bar, const baz = foo;
+    _ = bar;
+    _ = baz;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :4:28: error: type 'anyerror!tmp.entry.Foo' cannot be destructured
+// :4:26: note: result destructured here
+// :4:28: note: consider using 'try', 'catch', or 'if'
diff --git a/zig/test/cases/compile_errors/minmax_missing_args.zig b/zig/test/cases/compile_errors/minmax_missing_args.zig
new file mode 100644
index 0000000000..85a602fd40
--- /dev/null
+++ b/zig/test/cases/compile_errors/minmax_missing_args.zig
@@ -0,0 +1,9 @@
+comptime { _ = @min(1); }
+comptime { _ = @max(1); }
+
+// error
+// backend=stage2
+// target=native
+//
+// :1:16: error: expected at least 2 arguments, found 1
+// :2:16: error: expected at least 2 arguments, found 1
diff --git a/zig/test/cases/compile_errors/splat_bad_result_type.zig b/zig/test/cases/compile_errors/splat_bad_result_type.zig
new file mode 100644
index 0000000000..60d4b35d45
--- /dev/null
+++ b/zig/test/cases/compile_errors/splat_bad_result_type.zig
@@ -0,0 +1,7 @@
+export fn f() void {
+    _ = @as(u32, @splat(5));
+}
+
+// error
+//
+// :2:18: error: expected array or vector type, found 'u32'
diff --git a/zig/test/cases/compile_errors/splat_result_type_non_vector.zig b/zig/test/cases/compile_errors/splat_result_type_non_vector.zig
deleted file mode 100644
index dbff8dc041..0000000000
--- a/zig/test/cases/compile_errors/splat_result_type_non_vector.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn f() void {
-    _ = @as(u32, @splat(5));
-}
-
-// error
-// backend=stage2
-// target=native
-//
-// :2:18: error: expected vector type, found 'u32'
diff --git a/zig/test/cases/errdefer_discard.zig b/zig/test/cases/errdefer_discard.zig
new file mode 100644
index 0000000000..d9b4e7ae43
--- /dev/null
+++ b/zig/test/cases/errdefer_discard.zig
@@ -0,0 +1,7 @@
+pub fn main() !void {
+    errdefer |_| _ = @"_";
+}
+
+// error
+//
+// :2:15: error: discard of error capture; omit it instead
diff --git a/zig/test/cases/exit.zig b/zig/test/cases/exit.zig
index 23d17afe11..a1c256802c 100644
--- a/zig/test/cases/exit.zig
+++ b/zig/test/cases/exit.zig
@@ -1,5 +1,5 @@
 pub fn main() void {}
 
 // run
-// target=x86_64-linux,x86_64-macos,x86_64-windows,x86_64-plan9
+// target=x86_64-linux,x86_64-macos,x86_64-windows
 //
diff --git a/zig/test/cases/safety/array slice sentinel mismatch non-scalar.zig b/zig/test/cases/safety/array slice sentinel mismatch non-scalar.zig
deleted file mode 100644
index 5523970168..0000000000
--- a/zig/test/cases/safety/array slice sentinel mismatch non-scalar.zig	
+++ /dev/null
@@ -1,21 +0,0 @@
-const std = @import("std");
-
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
-    _ = stack_trace;
-    if (std.mem.eql(u8, message, "sentinel mismatch: expected tmp.main.S{ .a = 1 }, found tmp.main.S{ .a = 2 }")) {
-        std.process.exit(0);
-    }
-    std.process.exit(1);
-}
-
-pub fn main() !void {
-    const S = struct { a: u32 };
-    var arr = [_]S{ .{ .a = 1 }, .{ .a = 2 } };
-    const s = arr[0..1 :.{ .a = 1 }];
-    _ = s;
-    return error.TestFailed;
-}
-
-// run
-// backend=llvm
-// target=native
diff --git a/zig/test/incremental/add_decl b/zig/test/incremental/add_decl
index 376a725efc..6b3a0dad84 100644
--- a/zig/test/incremental/add_decl
+++ b/zig/test/incremental/add_decl
@@ -1,4 +1,6 @@
-#target=x86_64-linux
+#target=x86_64-linux-selfhosted
+#target=x86_64-linux-cbe
+#target=x86_64-windows-cbe
 #update=initial version
 #file=main.zig
 const std = @import("std");
diff --git a/zig/test/incremental/add_decl_namespaced b/zig/test/incremental/add_decl_namespaced
index 43123e0d0c..48ed5cfd2e 100644
--- a/zig/test/incremental/add_decl_namespaced
+++ b/zig/test/incremental/add_decl_namespaced
@@ -1,4 +1,6 @@
-#target=x86_64-linux
+#target=x86_64-linux-selfhosted
+#target=x86_64-linux-cbe
+#target=x86_64-windows-cbe
 #update=initial version
 #file=main.zig
 const std = @import("std");
diff --git a/zig/test/incremental/delete_comptime_decls b/zig/test/incremental/delete_comptime_decls
index d0da7110c3..03ddc68128 100644
--- a/zig/test/incremental/delete_comptime_decls
+++ b/zig/test/incremental/delete_comptime_decls
@@ -1,4 +1,6 @@
-#target=x86_64-linux
+#target=x86_64-linux-selfhosted
+#target=x86_64-linux-cbe
+#target=x86_64-windows-cbe
 #update=initial version
 #file=main.zig
 pub fn main() void {}
diff --git a/zig/test/incremental/hello b/zig/test/incremental/hello
index cad14d6e3d..3526b47f7c 100644
--- a/zig/test/incremental/hello
+++ b/zig/test/incremental/hello
@@ -1,4 +1,6 @@
-#target=x86_64-linux
+#target=x86_64-linux-selfhosted
+#target=x86_64-linux-cbe
+#target=x86_64-windows-cbe
 #update=initial version
 #file=main.zig
 const std = @import("std");
diff --git a/zig/test/incremental/modify_inline_fn b/zig/test/incremental/modify_inline_fn
index 633e7a0728..cd5361fb17 100644
--- a/zig/test/incremental/modify_inline_fn
+++ b/zig/test/incremental/modify_inline_fn
@@ -1,4 +1,6 @@
-#target=x86_64-linux
+#target=x86_64-linux-selfhosted
+#target=x86_64-linux-cbe
+#target=x86_64-windows-cbe
 #update=initial version
 #file=main.zig
 const std = @import("std");
diff --git a/zig/test/incremental/move_src b/zig/test/incremental/move_src
index 8313bdfac2..908135485c 100644
--- a/zig/test/incremental/move_src
+++ b/zig/test/incremental/move_src
@@ -1,4 +1,6 @@
-#target=x86_64-linux
+#target=x86_64-linux-selfhosted
+#target=x86_64-linux-cbe
+#target=x86_64-windows-cbe
 #update=initial version
 #file=main.zig
 const std = @import("std");
diff --git a/zig/test/incremental/remove_enum_field b/zig/test/incremental/remove_enum_field
index 64193bb25b..3a882ae0f1 100644
--- a/zig/test/incremental/remove_enum_field
+++ b/zig/test/incremental/remove_enum_field
@@ -1,4 +1,6 @@
-#target=x86_64-linux
+#target=x86_64-linux-selfhosted
+#target=x86_64-linux-cbe
+#target=x86_64-windows-cbe
 #update=initial version
 #file=main.zig
 const MyEnum = enum(u8) {
diff --git a/zig/test/incremental/type_becomes_comptime_only b/zig/test/incremental/type_becomes_comptime_only
index 2dfa556e87..2da31ec5f2 100644
--- a/zig/test/incremental/type_becomes_comptime_only
+++ b/zig/test/incremental/type_becomes_comptime_only
@@ -1,4 +1,6 @@
-#target=x86_64-linux
+#target=x86_64-linux-selfhosted
+#target=x86_64-linux-cbe
+#target=x86_64-windows-cbe
 #update=initial version
 #file=main.zig
 const SomeType = u32;
diff --git a/zig/test/incremental/unreferenced_error b/zig/test/incremental/unreferenced_error
index e3d67d6ad8..3dfe0ab758 100644
--- a/zig/test/incremental/unreferenced_error
+++ b/zig/test/incremental/unreferenced_error
@@ -1,4 +1,6 @@
-#target=x86_64-linux
+#target=x86_64-linux-selfhosted
+#target=x86_64-linux-cbe
+#target=x86_64-windows-cbe
 #update=initial version
 #file=main.zig
 const std = @import("std");
diff --git a/zig/test/link/elf.zig b/zig/test/link/elf.zig
index 9d169faf1d..f6891cf17e 100644
--- a/zig/test/link/elf.zig
+++ b/zig/test/link/elf.zig
@@ -952,25 +952,25 @@ fn testEmitStaticLib(b: *Build, opts: Options) *Step {
 
     const check = lib.checkObject();
     check.checkInArchiveSymtab();
-    check.checkExactPath("in object", obj1.getEmittedBin());
+    check.checkExact("in object obj1.o");
     check.checkExact("foo");
     check.checkInArchiveSymtab();
-    check.checkExactPath("in object", obj1.getEmittedBin());
+    check.checkExact("in object obj1.o");
     check.checkExact("bar");
     check.checkInArchiveSymtab();
-    check.checkExactPath("in object", obj1.getEmittedBin());
+    check.checkExact("in object obj1.o");
     check.checkExact("fooBar");
     check.checkInArchiveSymtab();
-    check.checkExactPath("in object", obj2.getEmittedBin());
+    check.checkExact("in object obj2.o");
     check.checkExact("tentative");
     check.checkInArchiveSymtab();
-    check.checkExactPath("in object", obj3.getEmittedBin());
+    check.checkExact("in object a_very_long_file_name_so_that_it_ends_up_in_strtab.o");
     check.checkExact("weakFoo");
     check.checkInArchiveSymtab();
-    check.checkExactPath("in object", obj3.getEmittedBin());
+    check.checkExact("in object a_very_long_file_name_so_that_it_ends_up_in_strtab.o");
     check.checkExact("strongBar");
     check.checkInArchiveSymtab();
-    check.checkExactPath("in object", obj3.getEmittedBin());
+    check.checkExact("in object a_very_long_file_name_so_that_it_ends_up_in_strtab.o");
     check.checkExact("strongBarAlias");
     test_step.dependOn(&check.step);
 
@@ -3916,7 +3916,7 @@ fn testUnknownFileTypeError(b: *Build, opts: Options) *Step {
     //     "note: while parsing /?/liba.dylib",
     // } });
     expectLinkErrors(exe, test_step, .{
-        .contains = "error: unexpected error: parsing input file failed with error InvalidLdScript",
+        .starts_with = "error: invalid token in LD script: '\\x00\\x00\\x00\\x0c\\x00\\x00\\x00/usr/lib/dyld\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x0d' (",
     });
 
     return test_step;
diff --git a/zig/test/link/link.zig b/zig/test/link/link.zig
index aee3bbe01b..4537846353 100644
--- a/zig/test/link/link.zig
+++ b/zig/test/link/link.zig
@@ -74,8 +74,8 @@ fn addCompileStep(
             .target = base.target,
             .optimize = base.optimize,
             .root_source_file = rsf: {
-                const name = b.fmt("{s}.zig", .{overlay.name});
                 const bytes = overlay.zig_source_bytes orelse break :rsf null;
+                const name = b.fmt("{s}.zig", .{overlay.name});
                 break :rsf b.addWriteFiles().add(name, bytes);
             },
             .pic = overlay.pic,
diff --git a/zig/test/link/macho.zig b/zig/test/link/macho.zig
index 31e6de1d04..1d790b20c6 100644
--- a/zig/test/link/macho.zig
+++ b/zig/test/link/macho.zig
@@ -63,6 +63,7 @@ pub fn testAll(b: *Build, build_opts: BuildOptions) *Step {
     macho_step.dependOn(testTlsZig(b, .{ .target = default_target }));
     macho_step.dependOn(testUndefinedFlag(b, .{ .target = default_target }));
     macho_step.dependOn(testUnresolvedError(b, .{ .target = default_target }));
+    macho_step.dependOn(testUnresolvedError2(b, .{ .target = default_target }));
     macho_step.dependOn(testUnwindInfo(b, .{ .target = default_target }));
     macho_step.dependOn(testUnwindInfoNoSubsectionsX64(b, .{ .target = x86_64_target }));
     macho_step.dependOn(testUnwindInfoNoSubsectionsArm64(b, .{ .target = aarch64_target }));
@@ -2610,6 +2611,31 @@ fn testUnresolvedError(b: *Build, opts: Options) *Step {
     return test_step;
 }
 
+fn testUnresolvedError2(b: *Build, opts: Options) *Step {
+    const test_step = addTestStep(b, "unresolved-error-2", opts);
+
+    const exe = addExecutable(b, opts, .{ .name = "main", .zig_source_bytes = 
+    \\pub fn main() !void {
+    \\    const msg_send_fn = @extern(
+    \\        *const fn () callconv(.C) usize,
+    \\        .{ .name = "objc_msgSend$initWithContentRect:styleMask:backing:defer:screen:" },
+    \\    );
+    \\    _ = @call(
+    \\        .auto,
+    \\        msg_send_fn,
+    \\        .{},
+    \\    );
+    \\}
+    });
+
+    expectLinkErrors(exe, test_step, .{ .exact = &.{
+        "error: undefined symbol: _objc_msgSend",
+        "note: referenced implicitly",
+    } });
+
+    return test_step;
+}
+
 fn testUnwindInfo(b: *Build, opts: Options) *Step {
     const test_step = addTestStep(b, "unwind-info", opts);
 
diff --git a/zig/test/llvm_targets.zig b/zig/test/llvm_targets.zig
index 76b9e668fa..687903d278 100644
--- a/zig/test/llvm_targets.zig
+++ b/zig/test/llvm_targets.zig
@@ -2,115 +2,335 @@ const std = @import("std");
 const Cases = @import("src/Cases.zig");
 
 const targets = [_]std.Target.Query{
+    .{ .cpu_arch = .aarch64, .os_tag = .bridgeos, .abi = .none },
+    .{ .cpu_arch = .aarch64, .os_tag = .driverkit, .abi = .none },
+    .{ .cpu_arch = .aarch64, .os_tag = .freebsd, .abi = .none },
     .{ .cpu_arch = .aarch64, .os_tag = .freestanding, .abi = .none },
-    .{ .cpu_arch = .aarch64, .os_tag = .freestanding, .abi = .ilp32 },
+    .{ .cpu_arch = .aarch64, .os_tag = .fuchsia, .abi = .none },
+    .{ .cpu_arch = .aarch64, .os_tag = .haiku, .abi = .none },
+    .{ .cpu_arch = .aarch64, .os_tag = .hermit, .abi = .none },
+    .{ .cpu_arch = .aarch64, .os_tag = .hurd, .abi = .gnu },
+    .{ .cpu_arch = .aarch64, .os_tag = .ios, .abi = .macabi },
     .{ .cpu_arch = .aarch64, .os_tag = .ios, .abi = .none },
     .{ .cpu_arch = .aarch64, .os_tag = .ios, .abi = .simulator },
-    .{ .cpu_arch = .aarch64, .os_tag = .linux, .abi = .none },
+    .{ .cpu_arch = .aarch64, .os_tag = .linux, .abi = .android },
+    .{ .cpu_arch = .aarch64, .os_tag = .linux, .abi = .gnu },
     .{ .cpu_arch = .aarch64, .os_tag = .linux, .abi = .gnuilp32 },
+    .{ .cpu_arch = .aarch64, .os_tag = .linux, .abi = .none },
+    .{ .cpu_arch = .aarch64, .os_tag = .linux, .abi = .ohos },
     .{ .cpu_arch = .aarch64, .os_tag = .macos, .abi = .none },
-    .{ .cpu_arch = .aarch64, .os_tag = .watchos, .abi = .none },
-    .{ .cpu_arch = .aarch64, .os_tag = .watchos, .abi = .simulator },
+    .{ .cpu_arch = .aarch64, .os_tag = .netbsd, .abi = .none },
+    .{ .cpu_arch = .aarch64, .os_tag = .openbsd, .abi = .none },
+    .{ .cpu_arch = .aarch64, .os_tag = .rtems, .abi = .ilp32 },
+    .{ .cpu_arch = .aarch64, .os_tag = .rtems, .abi = .none },
+    .{ .cpu_arch = .aarch64, .os_tag = .serenity, .abi = .none },
     .{ .cpu_arch = .aarch64, .os_tag = .tvos, .abi = .none },
     .{ .cpu_arch = .aarch64, .os_tag = .tvos, .abi = .simulator },
+    .{ .cpu_arch = .aarch64, .os_tag = .uefi, .abi = .none },
     .{ .cpu_arch = .aarch64, .os_tag = .visionos, .abi = .none },
     .{ .cpu_arch = .aarch64, .os_tag = .visionos, .abi = .simulator },
-    .{ .cpu_arch = .aarch64, .os_tag = .uefi, .abi = .none },
+    .{ .cpu_arch = .aarch64, .os_tag = .watchos, .abi = .ilp32 },
+    .{ .cpu_arch = .aarch64, .os_tag = .watchos, .abi = .none },
+    .{ .cpu_arch = .aarch64, .os_tag = .watchos, .abi = .simulator },
     .{ .cpu_arch = .aarch64, .os_tag = .windows, .abi = .gnu },
+    .{ .cpu_arch = .aarch64, .os_tag = .windows, .abi = .itanium },
     .{ .cpu_arch = .aarch64, .os_tag = .windows, .abi = .msvc },
+
     .{ .cpu_arch = .aarch64_be, .os_tag = .freestanding, .abi = .none },
+    .{ .cpu_arch = .aarch64_be, .os_tag = .linux, .abi = .gnu },
+    .{ .cpu_arch = .aarch64_be, .os_tag = .linux, .abi = .gnuilp32 },
     .{ .cpu_arch = .aarch64_be, .os_tag = .linux, .abi = .none },
+    .{ .cpu_arch = .aarch64_be, .os_tag = .netbsd, .abi = .none },
+
     .{ .cpu_arch = .amdgcn, .os_tag = .amdhsa, .abi = .none },
     .{ .cpu_arch = .amdgcn, .os_tag = .amdpal, .abi = .none },
-    .{ .cpu_arch = .amdgcn, .os_tag = .linux, .abi = .none },
-    //.{ .cpu_arch = .amdgcn, .os_tag = .mesa3d, .abi = .none },
+    .{ .cpu_arch = .amdgcn, .os_tag = .mesa3d, .abi = .none },
+
     .{ .cpu_arch = .arc, .os_tag = .freestanding, .abi = .none },
+    .{ .cpu_arch = .arc, .os_tag = .linux, .abi = .gnu },
     .{ .cpu_arch = .arc, .os_tag = .linux, .abi = .none },
-    .{ .cpu_arch = .arm, .os_tag = .freestanding, .abi = .none },
-    .{ .cpu_arch = .arm, .os_tag = .linux, .abi = .none },
-    .{ .cpu_arch = .arm, .os_tag = .uefi, .abi = .none },
-    .{ .cpu_arch = .armeb, .os_tag = .freestanding, .abi = .none },
-    .{ .cpu_arch = .armeb, .os_tag = .linux, .abi = .none },
-    .{ .cpu_arch = .avr, .os_tag = .freebsd, .abi = .none },
+
+    .{ .cpu_arch = .arm, .os_tag = .freebsd, .abi = .eabi },
+    .{ .cpu_arch = .arm, .os_tag = .freebsd, .abi = .eabihf },
+    .{ .cpu_arch = .arm, .os_tag = .freestanding, .abi = .eabi },
+    .{ .cpu_arch = .arm, .os_tag = .freestanding, .abi = .eabihf },
+    .{ .cpu_arch = .arm, .os_tag = .haiku, .abi = .eabi },
+    .{ .cpu_arch = .arm, .os_tag = .haiku, .abi = .eabihf },
+    .{ .cpu_arch = .arm, .os_tag = .linux, .abi = .androideabi },
+    .{ .cpu_arch = .arm, .os_tag = .linux, .abi = .eabi },
+    .{ .cpu_arch = .arm, .os_tag = .linux, .abi = .eabihf },
+    .{ .cpu_arch = .arm, .os_tag = .linux, .abi = .gnueabi },
+    .{ .cpu_arch = .arm, .os_tag = .linux, .abi = .gnueabihf },
+    .{ .cpu_arch = .arm, .os_tag = .linux, .abi = .musleabi },
+    .{ .cpu_arch = .arm, .os_tag = .linux, .abi = .musleabihf },
+    .{ .cpu_arch = .arm, .os_tag = .linux, .abi = .ohoseabi },
+    .{ .cpu_arch = .arm, .os_tag = .netbsd, .abi = .eabi },
+    .{ .cpu_arch = .arm, .os_tag = .netbsd, .abi = .eabihf },
+    .{ .cpu_arch = .arm, .os_tag = .openbsd, .abi = .eabi },
+    .{ .cpu_arch = .arm, .os_tag = .openbsd, .abi = .eabihf },
+    .{ .cpu_arch = .arm, .os_tag = .rtems, .abi = .eabi },
+    .{ .cpu_arch = .arm, .os_tag = .rtems, .abi = .eabihf },
+    .{ .cpu_arch = .arm, .os_tag = .uefi, .abi = .eabi },
+    .{ .cpu_arch = .arm, .os_tag = .uefi, .abi = .eabihf },
+
+    .{ .cpu_arch = .armeb, .os_tag = .freebsd, .abi = .eabi },
+    .{ .cpu_arch = .armeb, .os_tag = .freebsd, .abi = .eabihf },
+    .{ .cpu_arch = .armeb, .os_tag = .freestanding, .abi = .eabi },
+    .{ .cpu_arch = .armeb, .os_tag = .freestanding, .abi = .eabihf },
+    .{ .cpu_arch = .armeb, .os_tag = .linux, .abi = .eabi },
+    .{ .cpu_arch = .armeb, .os_tag = .linux, .abi = .eabihf },
+    .{ .cpu_arch = .armeb, .os_tag = .linux, .abi = .gnueabi },
+    .{ .cpu_arch = .armeb, .os_tag = .linux, .abi = .gnueabihf },
+    .{ .cpu_arch = .armeb, .os_tag = .linux, .abi = .musleabi },
+    .{ .cpu_arch = .armeb, .os_tag = .linux, .abi = .musleabihf },
+    .{ .cpu_arch = .armeb, .os_tag = .netbsd, .abi = .eabi },
+    .{ .cpu_arch = .armeb, .os_tag = .netbsd, .abi = .eabihf },
+    .{ .cpu_arch = .armeb, .os_tag = .rtems, .abi = .eabi },
+    .{ .cpu_arch = .armeb, .os_tag = .rtems, .abi = .eabihf },
+
     .{ .cpu_arch = .avr, .os_tag = .freestanding, .abi = .none },
-    .{ .cpu_arch = .avr, .os_tag = .linux, .abi = .none },
-    .{ .cpu_arch = .bpfel, .os_tag = .linux, .abi = .gnu },
-    .{ .cpu_arch = .bpfel, .os_tag = .linux, .abi = .none },
-    .{ .cpu_arch = .bpfeb, .os_tag = .linux, .abi = .gnu },
-    .{ .cpu_arch = .bpfeb, .os_tag = .linux, .abi = .none },
-    .{ .cpu_arch = .csky, .os_tag = .freestanding, .abi = .none },
-    .{ .cpu_arch = .csky, .os_tag = .linux, .abi = .none },
+    .{ .cpu_arch = .avr, .os_tag = .rtems, .abi = .none },
+
+    .{ .cpu_arch = .bpfeb, .os_tag = .freestanding, .abi = .none },
+
+    .{ .cpu_arch = .bpfel, .os_tag = .freestanding, .abi = .none },
+
+    .{ .cpu_arch = .csky, .os_tag = .freestanding, .abi = .eabi },
+    .{ .cpu_arch = .csky, .os_tag = .freestanding, .abi = .eabihf },
+    .{ .cpu_arch = .csky, .os_tag = .linux, .abi = .eabi },
+    .{ .cpu_arch = .csky, .os_tag = .linux, .abi = .eabihf },
+    .{ .cpu_arch = .csky, .os_tag = .linux, .abi = .gnueabi },
+    .{ .cpu_arch = .csky, .os_tag = .linux, .abi = .gnueabihf },
+
+    .{ .cpu_arch = .hexagon, .os_tag = .freestanding, .abi = .none },
     .{ .cpu_arch = .hexagon, .os_tag = .linux, .abi = .none },
+
+    .{ .cpu_arch = .lanai, .os_tag = .freestanding, .abi = .none },
+
+    .{ .cpu_arch = .loongarch32, .os_tag = .freestanding, .abi = .none },
+    .{ .cpu_arch = .loongarch32, .os_tag = .linux, .abi = .gnu },
+    .{ .cpu_arch = .loongarch32, .os_tag = .linux, .abi = .gnuf32 },
+    .{ .cpu_arch = .loongarch32, .os_tag = .linux, .abi = .gnusf },
+    .{ .cpu_arch = .loongarch32, .os_tag = .linux, .abi = .musl },
+    .{ .cpu_arch = .loongarch32, .os_tag = .linux, .abi = .none },
+    .{ .cpu_arch = .loongarch32, .os_tag = .uefi, .abi = .none },
+
+    .{ .cpu_arch = .loongarch64, .os_tag = .freestanding, .abi = .none },
+    .{ .cpu_arch = .loongarch64, .os_tag = .linux, .abi = .gnu },
+    .{ .cpu_arch = .loongarch64, .os_tag = .linux, .abi = .gnuf32 },
+    .{ .cpu_arch = .loongarch64, .os_tag = .linux, .abi = .gnusf },
+    .{ .cpu_arch = .loongarch64, .os_tag = .linux, .abi = .musl },
+    .{ .cpu_arch = .loongarch64, .os_tag = .linux, .abi = .none },
+    .{ .cpu_arch = .loongarch64, .os_tag = .uefi, .abi = .none },
+
     .{ .cpu_arch = .m68k, .os_tag = .freestanding, .abi = .none },
+    .{ .cpu_arch = .m68k, .os_tag = .haiku, .abi = .none },
+    .{ .cpu_arch = .m68k, .os_tag = .linux, .abi = .gnu },
     .{ .cpu_arch = .m68k, .os_tag = .linux, .abi = .none },
+    .{ .cpu_arch = .m68k, .os_tag = .netbsd, .abi = .none },
+    .{ .cpu_arch = .m68k, .os_tag = .rtems, .abi = .none },
+
+    .{ .cpu_arch = .mips, .os_tag = .freebsd, .abi = .eabi },
+    .{ .cpu_arch = .mips, .os_tag = .freebsd, .abi = .eabihf },
+    .{ .cpu_arch = .mips, .os_tag = .freestanding, .abi = .eabi },
+    .{ .cpu_arch = .mips, .os_tag = .freestanding, .abi = .eabihf },
+    .{ .cpu_arch = .mips, .os_tag = .linux, .abi = .eabi },
+    .{ .cpu_arch = .mips, .os_tag = .linux, .abi = .eabihf },
+    .{ .cpu_arch = .mips, .os_tag = .linux, .abi = .gnueabi },
     .{ .cpu_arch = .mips, .os_tag = .linux, .abi = .gnueabihf },
-    .{ .cpu_arch = .mips, .os_tag = .linux, .abi = .musl },
-    .{ .cpu_arch = .mips, .os_tag = .linux, .abi = .none },
+    .{ .cpu_arch = .mips, .os_tag = .linux, .abi = .musleabi },
+    .{ .cpu_arch = .mips, .os_tag = .linux, .abi = .musleabihf },
+    .{ .cpu_arch = .mips, .os_tag = .netbsd, .abi = .eabi },
+    .{ .cpu_arch = .mips, .os_tag = .netbsd, .abi = .eabihf },
+    .{ .cpu_arch = .mips, .os_tag = .rtems, .abi = .eabi },
+    .{ .cpu_arch = .mips, .os_tag = .rtems, .abi = .eabihf },
+
+    .{ .cpu_arch = .mipsel, .os_tag = .freebsd, .abi = .eabi },
+    .{ .cpu_arch = .mipsel, .os_tag = .freebsd, .abi = .eabihf },
+    .{ .cpu_arch = .mipsel, .os_tag = .freestanding, .abi = .eabi },
+    .{ .cpu_arch = .mipsel, .os_tag = .freestanding, .abi = .eabihf },
+    .{ .cpu_arch = .mipsel, .os_tag = .linux, .abi = .eabi },
+    .{ .cpu_arch = .mipsel, .os_tag = .linux, .abi = .eabihf },
+    .{ .cpu_arch = .mipsel, .os_tag = .linux, .abi = .gnueabi },
     .{ .cpu_arch = .mipsel, .os_tag = .linux, .abi = .gnueabihf },
-    .{ .cpu_arch = .mipsel, .os_tag = .linux, .abi = .musl },
-    .{ .cpu_arch = .mipsel, .os_tag = .linux, .abi = .none },
+    .{ .cpu_arch = .mipsel, .os_tag = .linux, .abi = .musleabi },
+    .{ .cpu_arch = .mipsel, .os_tag = .linux, .abi = .musleabihf },
+    .{ .cpu_arch = .mipsel, .os_tag = .netbsd, .abi = .eabi },
+    .{ .cpu_arch = .mipsel, .os_tag = .netbsd, .abi = .eabihf },
+    .{ .cpu_arch = .mipsel, .os_tag = .rtems, .abi = .eabi },
+    .{ .cpu_arch = .mipsel, .os_tag = .rtems, .abi = .eabihf },
+
+    .{ .cpu_arch = .mips64, .os_tag = .freebsd, .abi = .none },
+    .{ .cpu_arch = .mips64, .os_tag = .freestanding, .abi = .none },
+    .{ .cpu_arch = .mips64, .os_tag = .linux, .abi = .gnuabi64 },
+    .{ .cpu_arch = .mips64, .os_tag = .linux, .abi = .gnuabin32 },
+    .{ .cpu_arch = .mips64, .os_tag = .linux, .abi = .musl },
     .{ .cpu_arch = .mips64, .os_tag = .linux, .abi = .none },
+    .{ .cpu_arch = .mips64, .os_tag = .netbsd, .abi = .none },
+    .{ .cpu_arch = .mips64, .os_tag = .openbsd, .abi = .none },
+
+    .{ .cpu_arch = .mips64el, .os_tag = .freebsd, .abi = .none },
+    .{ .cpu_arch = .mips64el, .os_tag = .freestanding, .abi = .none },
+    .{ .cpu_arch = .mips64el, .os_tag = .linux, .abi = .gnuabi64 },
+    .{ .cpu_arch = .mips64el, .os_tag = .linux, .abi = .gnuabin32 },
+    .{ .cpu_arch = .mips64el, .os_tag = .linux, .abi = .musl },
     .{ .cpu_arch = .mips64el, .os_tag = .linux, .abi = .none },
-    .{ .cpu_arch = .msp430, .os_tag = .freebsd, .abi = .none },
+    .{ .cpu_arch = .mips64el, .os_tag = .netbsd, .abi = .none },
+    .{ .cpu_arch = .mips64el, .os_tag = .openbsd, .abi = .none },
+
     .{ .cpu_arch = .msp430, .os_tag = .freestanding, .abi = .none },
-    .{ .cpu_arch = .msp430, .os_tag = .linux, .abi = .none },
-    //.{ .cpu_arch = .nvptx, .os_tag = .cuda, .abi = .none },
-    //.{ .cpu_arch = .nvptx64, .os_tag = .cuda, .abi = .none },
-    .{ .cpu_arch = .powerpc, .os_tag = .freebsd, .abi = .none },
-    .{ .cpu_arch = .powerpc, .os_tag = .freestanding, .abi = .none },
+
+    .{ .cpu_arch = .nvptx, .os_tag = .cuda, .abi = .none },
+    .{ .cpu_arch = .nvptx, .os_tag = .nvcl, .abi = .none },
+    .{ .cpu_arch = .nvptx64, .os_tag = .cuda, .abi = .none },
+    .{ .cpu_arch = .nvptx64, .os_tag = .nvcl, .abi = .none },
+
+    .{ .cpu_arch = .powerpc, .os_tag = .aix, .abi = .eabihf },
+    .{ .cpu_arch = .powerpc, .os_tag = .freebsd, .abi = .eabi },
+    .{ .cpu_arch = .powerpc, .os_tag = .freebsd, .abi = .eabihf },
+    .{ .cpu_arch = .powerpc, .os_tag = .freestanding, .abi = .eabi },
+    .{ .cpu_arch = .powerpc, .os_tag = .freestanding, .abi = .eabihf },
+    .{ .cpu_arch = .powerpc, .os_tag = .haiku, .abi = .eabi },
+    .{ .cpu_arch = .powerpc, .os_tag = .haiku, .abi = .eabihf },
+    .{ .cpu_arch = .powerpc, .os_tag = .linux, .abi = .eabi },
+    .{ .cpu_arch = .powerpc, .os_tag = .linux, .abi = .eabihf },
+    .{ .cpu_arch = .powerpc, .os_tag = .linux, .abi = .gnueabi },
     .{ .cpu_arch = .powerpc, .os_tag = .linux, .abi = .gnueabihf },
-    .{ .cpu_arch = .powerpc, .os_tag = .linux, .abi = .musl },
-    .{ .cpu_arch = .powerpc, .os_tag = .linux, .abi = .none },
-    .{ .cpu_arch = .powerpcle, .os_tag = .freebsd, .abi = .none },
-    .{ .cpu_arch = .powerpcle, .os_tag = .freestanding, .abi = .none },
-    .{ .cpu_arch = .powerpcle, .os_tag = .linux, .abi = .gnu },
-    .{ .cpu_arch = .powerpcle, .os_tag = .linux, .abi = .musl },
-    .{ .cpu_arch = .powerpcle, .os_tag = .linux, .abi = .none },
+    .{ .cpu_arch = .powerpc, .os_tag = .linux, .abi = .musleabi },
+    .{ .cpu_arch = .powerpc, .os_tag = .linux, .abi = .musleabihf },
+    .{ .cpu_arch = .powerpc, .os_tag = .netbsd, .abi = .eabi },
+    .{ .cpu_arch = .powerpc, .os_tag = .netbsd, .abi = .eabihf },
+    .{ .cpu_arch = .powerpc, .os_tag = .openbsd, .abi = .eabi },
+    .{ .cpu_arch = .powerpc, .os_tag = .openbsd, .abi = .eabihf },
+    .{ .cpu_arch = .powerpc, .os_tag = .rtems, .abi = .eabi },
+    .{ .cpu_arch = .powerpc, .os_tag = .rtems, .abi = .eabihf },
+
+    .{ .cpu_arch = .powerpcle, .os_tag = .freestanding, .abi = .eabi },
+    .{ .cpu_arch = .powerpcle, .os_tag = .freestanding, .abi = .eabihf },
+
+    .{ .cpu_arch = .powerpc64, .os_tag = .aix, .abi = .none },
     .{ .cpu_arch = .powerpc64, .os_tag = .freebsd, .abi = .none },
     .{ .cpu_arch = .powerpc64, .os_tag = .freestanding, .abi = .none },
     .{ .cpu_arch = .powerpc64, .os_tag = .linux, .abi = .gnu },
     .{ .cpu_arch = .powerpc64, .os_tag = .linux, .abi = .musl },
     .{ .cpu_arch = .powerpc64, .os_tag = .linux, .abi = .none },
+    .{ .cpu_arch = .powerpc64, .os_tag = .openbsd, .abi = .none },
+    .{ .cpu_arch = .powerpc64, .os_tag = .rtems, .abi = .none },
+
     .{ .cpu_arch = .powerpc64le, .os_tag = .freebsd, .abi = .none },
     .{ .cpu_arch = .powerpc64le, .os_tag = .freestanding, .abi = .none },
     .{ .cpu_arch = .powerpc64le, .os_tag = .linux, .abi = .gnu },
     .{ .cpu_arch = .powerpc64le, .os_tag = .linux, .abi = .musl },
     .{ .cpu_arch = .powerpc64le, .os_tag = .linux, .abi = .none },
+
     .{ .cpu_arch = .riscv32, .os_tag = .freestanding, .abi = .none },
+    .{ .cpu_arch = .riscv32, .os_tag = .linux, .abi = .gnu },
+    .{ .cpu_arch = .riscv32, .os_tag = .linux, .abi = .musl },
     .{ .cpu_arch = .riscv32, .os_tag = .linux, .abi = .none },
+    .{ .cpu_arch = .riscv32, .os_tag = .linux, .abi = .ohos },
+    .{ .cpu_arch = .riscv32, .os_tag = .rtems, .abi = .none },
+    .{ .cpu_arch = .riscv32, .os_tag = .uefi, .abi = .none },
+
+    .{ .cpu_arch = .riscv64, .os_tag = .freebsd, .abi = .none },
     .{ .cpu_arch = .riscv64, .os_tag = .freestanding, .abi = .none },
+    .{ .cpu_arch = .riscv64, .os_tag = .fuchsia, .abi = .none },
+    .{ .cpu_arch = .riscv64, .os_tag = .haiku, .abi = .none },
+    .{ .cpu_arch = .riscv64, .os_tag = .hermit, .abi = .none },
+    .{ .cpu_arch = .riscv64, .os_tag = .linux, .abi = .android },
     .{ .cpu_arch = .riscv64, .os_tag = .linux, .abi = .gnu },
     .{ .cpu_arch = .riscv64, .os_tag = .linux, .abi = .musl },
     .{ .cpu_arch = .riscv64, .os_tag = .linux, .abi = .none },
+    .{ .cpu_arch = .riscv64, .os_tag = .linux, .abi = .ohos },
+    .{ .cpu_arch = .riscv64, .os_tag = .netbsd, .abi = .none },
+    .{ .cpu_arch = .riscv64, .os_tag = .openbsd, .abi = .none },
+    .{ .cpu_arch = .riscv64, .os_tag = .rtems, .abi = .none },
+    .{ .cpu_arch = .riscv64, .os_tag = .serenity, .abi = .none },
+    .{ .cpu_arch = .riscv64, .os_tag = .uefi, .abi = .none },
+
     .{ .cpu_arch = .s390x, .os_tag = .freestanding, .abi = .none },
     .{ .cpu_arch = .s390x, .os_tag = .linux, .abi = .gnu },
+    .{ .cpu_arch = .s390x, .os_tag = .linux, .abi = .none },
+    .{ .cpu_arch = .s390x, .os_tag = .zos, .abi = .none },
+
     .{ .cpu_arch = .sparc, .os_tag = .freestanding, .abi = .none },
     .{ .cpu_arch = .sparc, .os_tag = .linux, .abi = .gnu },
     .{ .cpu_arch = .sparc, .os_tag = .linux, .abi = .none },
+    .{ .cpu_arch = .sparc, .os_tag = .netbsd, .abi = .none },
+    .{ .cpu_arch = .sparc, .os_tag = .rtems, .abi = .none },
+
+    .{ .cpu_arch = .sparc64, .os_tag = .freebsd, .abi = .none },
     .{ .cpu_arch = .sparc64, .os_tag = .freestanding, .abi = .none },
+    .{ .cpu_arch = .sparc64, .os_tag = .haiku, .abi = .none },
+    .{ .cpu_arch = .sparc64, .os_tag = .illumos, .abi = .none },
     .{ .cpu_arch = .sparc64, .os_tag = .linux, .abi = .gnu },
-    //.{ .cpu_arch = .spirv32, .os_tag = .opencl, .abi = .none },
-    //.{ .cpu_arch = .spirv32, .os_tag = .opengl, .abi = .none },
-    //.{ .cpu_arch = .spirv32, .os_tag = .vulkan, .abi = .none },
-    //.{ .cpu_arch = .spirv64, .os_tag = .opencl, .abi = .none },
-    //.{ .cpu_arch = .spirv64, .os_tag = .opengl, .abi = .none },
-    //.{ .cpu_arch = .spirv64, .os_tag = .vulkan, .abi = .none },
-    .{ .cpu_arch = .thumb, .os_tag = .freestanding, .abi = .none },
-    .{ .cpu_arch = .thumbeb, .os_tag = .freestanding, .abi = .none },
+    .{ .cpu_arch = .sparc64, .os_tag = .linux, .abi = .none },
+    .{ .cpu_arch = .sparc64, .os_tag = .netbsd, .abi = .none },
+    .{ .cpu_arch = .sparc64, .os_tag = .openbsd, .abi = .none },
+    .{ .cpu_arch = .sparc64, .os_tag = .rtems, .abi = .none },
+    .{ .cpu_arch = .sparc64, .os_tag = .solaris, .abi = .none },
+
+    .{ .cpu_arch = .thumb, .os_tag = .freebsd, .abi = .eabi },
+    .{ .cpu_arch = .thumb, .os_tag = .freebsd, .abi = .eabihf },
+    .{ .cpu_arch = .thumb, .os_tag = .freestanding, .abi = .eabi },
+    .{ .cpu_arch = .thumb, .os_tag = .freestanding, .abi = .eabihf },
+    .{ .cpu_arch = .thumb, .os_tag = .linux, .abi = .eabi },
+    .{ .cpu_arch = .thumb, .os_tag = .linux, .abi = .eabihf },
+    .{ .cpu_arch = .thumb, .os_tag = .linux, .abi = .musleabi },
+    .{ .cpu_arch = .thumb, .os_tag = .linux, .abi = .musleabihf },
+    .{ .cpu_arch = .thumb, .os_tag = .netbsd, .abi = .eabi },
+    .{ .cpu_arch = .thumb, .os_tag = .netbsd, .abi = .eabihf },
+    .{ .cpu_arch = .thumb, .os_tag = .openbsd, .abi = .eabi },
+    .{ .cpu_arch = .thumb, .os_tag = .openbsd, .abi = .eabihf },
+    .{ .cpu_arch = .thumb, .os_tag = .rtems, .abi = .eabi },
+    .{ .cpu_arch = .thumb, .os_tag = .rtems, .abi = .eabihf },
+    .{ .cpu_arch = .thumb, .os_tag = .windows, .abi = .gnu },
+    .{ .cpu_arch = .thumb, .os_tag = .windows, .abi = .itanium },
+    .{ .cpu_arch = .thumb, .os_tag = .windows, .abi = .msvc },
+
+    .{ .cpu_arch = .thumbeb, .os_tag = .freebsd, .abi = .eabi },
+    .{ .cpu_arch = .thumbeb, .os_tag = .freebsd, .abi = .eabihf },
+    .{ .cpu_arch = .thumbeb, .os_tag = .freestanding, .abi = .eabi },
+    .{ .cpu_arch = .thumbeb, .os_tag = .freestanding, .abi = .eabihf },
+    .{ .cpu_arch = .thumbeb, .os_tag = .linux, .abi = .eabi },
+    .{ .cpu_arch = .thumbeb, .os_tag = .linux, .abi = .eabihf },
+    .{ .cpu_arch = .thumbeb, .os_tag = .linux, .abi = .musleabi },
+    .{ .cpu_arch = .thumbeb, .os_tag = .linux, .abi = .musleabihf },
+    .{ .cpu_arch = .thumbeb, .os_tag = .netbsd, .abi = .eabi },
+    .{ .cpu_arch = .thumbeb, .os_tag = .netbsd, .abi = .eabihf },
+    .{ .cpu_arch = .thumbeb, .os_tag = .rtems, .abi = .eabi },
+    .{ .cpu_arch = .thumbeb, .os_tag = .rtems, .abi = .eabihf },
+
+    .{ .cpu_arch = .ve, .os_tag = .freestanding, .abi = .none },
     .{ .cpu_arch = .ve, .os_tag = .linux, .abi = .none },
+
     .{ .cpu_arch = .wasm32, .os_tag = .emscripten, .abi = .none },
     .{ .cpu_arch = .wasm32, .os_tag = .freestanding, .abi = .none },
-    .{ .cpu_arch = .wasm32, .os_tag = .linux, .abi = .none },
+    .{ .cpu_arch = .wasm32, .os_tag = .wasi, .abi = .musl },
     .{ .cpu_arch = .wasm32, .os_tag = .wasi, .abi = .none },
+
     .{ .cpu_arch = .wasm64, .os_tag = .emscripten, .abi = .none },
     .{ .cpu_arch = .wasm64, .os_tag = .freestanding, .abi = .none },
-    .{ .cpu_arch = .wasm64, .os_tag = .linux, .abi = .none },
+    .{ .cpu_arch = .wasm64, .os_tag = .wasi, .abi = .musl },
     .{ .cpu_arch = .wasm64, .os_tag = .wasi, .abi = .none },
+
+    .{ .cpu_arch = .x86, .os_tag = .elfiamcu, .abi = .none },
+    .{ .cpu_arch = .x86, .os_tag = .freebsd, .abi = .none },
     .{ .cpu_arch = .x86, .os_tag = .freestanding, .abi = .none },
+    .{ .cpu_arch = .x86, .os_tag = .haiku, .abi = .none },
+    .{ .cpu_arch = .x86, .os_tag = .hurd, .abi = .gnu },
+    .{ .cpu_arch = .x86, .os_tag = .linux, .abi = .android },
+    .{ .cpu_arch = .x86, .os_tag = .linux, .abi = .gnu },
+    .{ .cpu_arch = .x86, .os_tag = .linux, .abi = .musl },
     .{ .cpu_arch = .x86, .os_tag = .linux, .abi = .none },
+    .{ .cpu_arch = .x86, .os_tag = .linux, .abi = .ohos },
+    .{ .cpu_arch = .x86, .os_tag = .netbsd, .abi = .none },
+    .{ .cpu_arch = .x86, .os_tag = .openbsd, .abi = .none },
+    .{ .cpu_arch = .x86, .os_tag = .rtems, .abi = .none },
     .{ .cpu_arch = .x86, .os_tag = .uefi, .abi = .none },
     .{ .cpu_arch = .x86, .os_tag = .windows, .abi = .gnu },
+    .{ .cpu_arch = .x86, .os_tag = .windows, .abi = .itanium },
     .{ .cpu_arch = .x86, .os_tag = .windows, .abi = .msvc },
+
     .{ .cpu_arch = .x86_64, .os_tag = .freebsd, .abi = .none },
     .{ .cpu_arch = .x86_64, .os_tag = .freestanding, .abi = .none },
     .{
@@ -120,15 +340,38 @@ const targets = [_]std.Target.Query{
         .cpu_features_add = std.Target.x86.featureSet(&.{.soft_float}),
         .cpu_features_sub = std.Target.x86.featureSet(&.{ .mmx, .sse, .sse2, .avx, .avx2 }),
     },
+    .{ .cpu_arch = .x86_64, .os_tag = .fuchsia, .abi = .none },
+    .{ .cpu_arch = .x86_64, .os_tag = .dragonfly, .abi = .none },
+    .{ .cpu_arch = .x86_64, .os_tag = .driverkit, .abi = .none },
+    .{ .cpu_arch = .x86_64, .os_tag = .haiku, .abi = .none },
+    .{ .cpu_arch = .x86_64, .os_tag = .hermit, .abi = .none },
+    .{ .cpu_arch = .x86_64, .os_tag = .hurd, .abi = .gnu },
+    .{ .cpu_arch = .x86_64, .os_tag = .illumos, .abi = .none },
+    .{ .cpu_arch = .x86_64, .os_tag = .ios, .abi = .macabi },
     .{ .cpu_arch = .x86_64, .os_tag = .ios, .abi = .simulator },
-    .{ .cpu_arch = .x86_64, .os_tag = .watchos, .abi = .simulator },
-    .{ .cpu_arch = .x86_64, .os_tag = .tvos, .abi = .simulator },
-    .{ .cpu_arch = .x86_64, .os_tag = .visionos, .abi = .simulator },
+    .{ .cpu_arch = .x86_64, .os_tag = .linux, .abi = .android },
+    .{ .cpu_arch = .x86_64, .os_tag = .linux, .abi = .gnu },
+    .{ .cpu_arch = .x86_64, .os_tag = .linux, .abi = .gnux32 },
+    .{ .cpu_arch = .x86_64, .os_tag = .linux, .abi = .musl },
+    .{ .cpu_arch = .x86_64, .os_tag = .linux, .abi = .muslx32 },
     .{ .cpu_arch = .x86_64, .os_tag = .linux, .abi = .none },
+    .{ .cpu_arch = .x86_64, .os_tag = .linux, .abi = .ohos },
     .{ .cpu_arch = .x86_64, .os_tag = .macos, .abi = .none },
+    .{ .cpu_arch = .x86_64, .os_tag = .netbsd, .abi = .none },
+    .{ .cpu_arch = .x86_64, .os_tag = .openbsd, .abi = .none },
+    .{ .cpu_arch = .x86_64, .os_tag = .rtems, .abi = .none },
+    .{ .cpu_arch = .x86_64, .os_tag = .serenity, .abi = .none },
+    .{ .cpu_arch = .x86_64, .os_tag = .solaris, .abi = .none },
+    .{ .cpu_arch = .x86_64, .os_tag = .tvos, .abi = .simulator },
     .{ .cpu_arch = .x86_64, .os_tag = .uefi, .abi = .none },
+    .{ .cpu_arch = .x86_64, .os_tag = .visionos, .abi = .simulator },
+    .{ .cpu_arch = .x86_64, .os_tag = .watchos, .abi = .simulator },
     .{ .cpu_arch = .x86_64, .os_tag = .windows, .abi = .gnu },
+    .{ .cpu_arch = .x86_64, .os_tag = .windows, .abi = .itanium },
     .{ .cpu_arch = .x86_64, .os_tag = .windows, .abi = .msvc },
+
+    .{ .cpu_arch = .xcore, .os_tag = .freestanding, .abi = .none },
+
     .{ .cpu_arch = .xtensa, .os_tag = .freestanding, .abi = .none },
     .{ .cpu_arch = .xtensa, .os_tag = .linux, .abi = .none },
 };
diff --git a/zig/test/src/Debugger.zig b/zig/test/src/Debugger.zig
index 6a930bf9dd..913c9b632c 100644
--- a/zig/test/src/Debugger.zig
+++ b/zig/test/src/Debugger.zig
@@ -113,70 +113,70 @@ pub fn addTestsForTarget(db: *Debugger, target: Target) void {
         &.{
             \\(lldb) frame variable --show-types -- basic
             \\(root.basic.Basic) basic = {
-            \\  (void) void = {}
-            \\  (bool) bool_false = false
-            \\  (bool) bool_true = true
-            \\  (u0) u0_0 = 0
-            \\  (u1) u1_0 = 0
-            \\  (u1) u1_1 = 1
-            \\  (u2) u2_0 = 0
-            \\  (u2) u2_3 = 3
-            \\  (u3) u3_0 = 0
-            \\  (u3) u3_7 = 7
-            \\  (u4) u4_0 = 0
-            \\  (u4) u4_15 = 15
-            \\  (u5) u5_0 = 0
-            \\  (u5) u5_31 = 31
-            \\  (u6) u6_0 = 0
-            \\  (u6) u6_63 = 63
-            \\  (u7) u7_0 = 0
-            \\  (u7) u7_127 = 127
-            \\  (u8) u8_0 = 0
-            \\  (u8) u8_255 = 255
-            \\  (u16) u16_0 = 0
-            \\  (u16) u16_65535 = 65535
-            \\  (u24) u24_0 = 0
-            \\  (u24) u24_16777215 = 16777215
-            \\  (u32) u32_0 = 0
-            \\  (u32) u32_4294967295 = 4294967295
-            \\  (i0) i0_0 = 0
-            \\  (i1) i1_-1 = -1
-            \\  (i1) i1_0 = 0
-            \\  (i2) i2_-2 = -2
-            \\  (i2) i2_0 = 0
-            \\  (i2) i2_1 = 1
-            \\  (i3) i3_-4 = -4
-            \\  (i3) i3_0 = 0
-            \\  (i3) i3_3 = 3
-            \\  (i4) i4_-8 = -8
-            \\  (i4) i4_0 = 0
-            \\  (i4) i4_7 = 7
-            \\  (i5) i5_-16 = -16
-            \\  (i5) i5_0 = 0
-            \\  (i5) i5_15 = 15
-            \\  (i6) i6_-32 = -32
-            \\  (i6) i6_0 = 0
-            \\  (i6) i6_31 = 31
-            \\  (i7) i7_-64 = -64
-            \\  (i7) i7_0 = 0
-            \\  (i7) i7_63 = 63
-            \\  (i8) i8_-128 = -128
-            \\  (i8) i8_0 = 0
-            \\  (i8) i8_127 = 127
-            \\  (i16) i16_-32768 = -32768
-            \\  (i16) i16_0 = 0
-            \\  (i16) i16_32767 = 32767
-            \\  (i24) i24_-8388608 = -8388608
-            \\  (i24) i24_0 = 0
-            \\  (i24) i24_8388607 = 8388607
-            \\  (i32) i32_-2147483648 = -2147483648
-            \\  (i32) i32_0 = 0
-            \\  (i32) i32_2147483647 = 2147483647
-            \\  (f16) f16_42.625 = 42.625
-            \\  (f32) f32_-2730.65625 = -2730.65625
-            \\  (f64) f64_357913941.33203125 = 357913941.33203125
-            \\  (f80) f80_-91625968981.3330078125 = -91625968981.3330078125
-            \\  (f128) f128_384307168202282325.333332061767578125 = 384307168202282325.333332061767578125
+            \\  (void) .void = {}
+            \\  (bool) .bool_false = false
+            \\  (bool) .bool_true = true
+            \\  (u0) .u0_0 = 0
+            \\  (u1) .u1_0 = 0
+            \\  (u1) .u1_1 = 1
+            \\  (u2) .u2_0 = 0
+            \\  (u2) .u2_3 = 3
+            \\  (u3) .u3_0 = 0
+            \\  (u3) .u3_7 = 7
+            \\  (u4) .u4_0 = 0
+            \\  (u4) .u4_15 = 15
+            \\  (u5) .u5_0 = 0
+            \\  (u5) .u5_31 = 31
+            \\  (u6) .u6_0 = 0
+            \\  (u6) .u6_63 = 63
+            \\  (u7) .u7_0 = 0
+            \\  (u7) .u7_127 = 127
+            \\  (u8) .u8_0 = 0
+            \\  (u8) .u8_255 = 255
+            \\  (u16) .u16_0 = 0
+            \\  (u16) .u16_65535 = 65535
+            \\  (u24) .u24_0 = 0
+            \\  (u24) .u24_16777215 = 16777215
+            \\  (u32) .u32_0 = 0
+            \\  (u32) .u32_4294967295 = 4294967295
+            \\  (i0) .i0_0 = 0
+            \\  (i1) .@"i1_-1" = -1
+            \\  (i1) .i1_0 = 0
+            \\  (i2) .@"i2_-2" = -2
+            \\  (i2) .i2_0 = 0
+            \\  (i2) .i2_1 = 1
+            \\  (i3) .@"i3_-4" = -4
+            \\  (i3) .i3_0 = 0
+            \\  (i3) .i3_3 = 3
+            \\  (i4) .@"i4_-8" = -8
+            \\  (i4) .i4_0 = 0
+            \\  (i4) .i4_7 = 7
+            \\  (i5) .@"i5_-16" = -16
+            \\  (i5) .i5_0 = 0
+            \\  (i5) .i5_15 = 15
+            \\  (i6) .@"i6_-32" = -32
+            \\  (i6) .i6_0 = 0
+            \\  (i6) .i6_31 = 31
+            \\  (i7) .@"i7_-64" = -64
+            \\  (i7) .i7_0 = 0
+            \\  (i7) .i7_63 = 63
+            \\  (i8) .@"i8_-128" = -128
+            \\  (i8) .i8_0 = 0
+            \\  (i8) .i8_127 = 127
+            \\  (i16) .@"i16_-32768" = -32768
+            \\  (i16) .i16_0 = 0
+            \\  (i16) .i16_32767 = 32767
+            \\  (i24) .@"i24_-8388608" = -8388608
+            \\  (i24) .i24_0 = 0
+            \\  (i24) .i24_8388607 = 8388607
+            \\  (i32) .@"i32_-2147483648" = -2147483648
+            \\  (i32) .i32_0 = 0
+            \\  (i32) .i32_2147483647 = 2147483647
+            \\  (f16) .@"f16_42.625" = 42.625
+            \\  (f32) .@"f32_-2730.65625" = -2730.65625
+            \\  (f64) .@"f64_357913941.33203125" = 357913941.33203125
+            \\  (f80) .@"f80_-91625968981.3330078125" = -91625968981.3330078125
+            \\  (f128) .@"f128_384307168202282325.333332061767578125" = 384307168202282325.333332061767578125
             \\}
             \\(lldb) breakpoint delete --force 1
             \\1 breakpoints deleted; 0 breakpoint locations disabled.
@@ -249,57 +249,57 @@ pub fn addTestsForTarget(db: *Debugger, target: Target) void {
         &.{
             \\(lldb) frame variable --show-types -- pointers
             \\(root.pointers.Pointers) pointers = {
-            \\  (*u32) single = 0x0000000000001010
-            \\  (*const u32) single_const = 0x0000000000001014
-            \\  (*volatile u32) single_volatile = 0x0000000000001018
-            \\  (*const volatile u32) single_const_volatile = 0x000000000000101c
-            \\  (*allowzero u32) single_allowzero = 0x0000000000001020
-            \\  (*allowzero const u32) single_allowzero_const = 0x0000000000001024
-            \\  (*allowzero volatile u32) single_allowzero_volatile = 0x0000000000001028
-            \\  (*allowzero const volatile u32) single_allowzero_const_volatile = 0x000000000000102c
-            \\  ([*]u32) many = 0x0000000000002010
-            \\  ([*]const u32) many_const = 0x0000000000002014
-            \\  ([*]volatile u32) many_volatile = 0x0000000000002018
-            \\  ([*]const volatile u32) many_const_volatile = 0x000000000000201c
-            \\  ([*]allowzero u32) many_allowzero = 0x0000000000002020
-            \\  ([*]allowzero const u32) many_allowzero_const = 0x0000000000002024
-            \\  ([*]allowzero volatile u32) many_allowzero_volatile = 0x0000000000002028
-            \\  ([*]allowzero const volatile u32) many_allowzero_const_volatile = 0x000000000000202c
-            \\  ([]u32) slice = len=1 {
+            \\  (*u32) .single = 0x0000000000001010
+            \\  (*const u32) .single_const = 0x0000000000001014
+            \\  (*volatile u32) .single_volatile = 0x0000000000001018
+            \\  (*const volatile u32) .single_const_volatile = 0x000000000000101c
+            \\  (*allowzero u32) .single_allowzero = 0x0000000000001020
+            \\  (*allowzero const u32) .single_allowzero_const = 0x0000000000001024
+            \\  (*allowzero volatile u32) .single_allowzero_volatile = 0x0000000000001028
+            \\  (*allowzero const volatile u32) .single_allowzero_const_volatile = 0x000000000000102c
+            \\  ([*]u32) .many = 0x0000000000002010
+            \\  ([*]const u32) .many_const = 0x0000000000002014
+            \\  ([*]volatile u32) .many_volatile = 0x0000000000002018
+            \\  ([*]const volatile u32) .many_const_volatile = 0x000000000000201c
+            \\  ([*]allowzero u32) .many_allowzero = 0x0000000000002020
+            \\  ([*]allowzero const u32) .many_allowzero_const = 0x0000000000002024
+            \\  ([*]allowzero volatile u32) .many_allowzero_volatile = 0x0000000000002028
+            \\  ([*]allowzero const volatile u32) .many_allowzero_const_volatile = 0x000000000000202c
+            \\  ([]u32) .slice = len=1 {
             \\    (u32) [0] = 3010
             \\  }
-            \\  ([]const u32) slice_const = len=2 {
+            \\  ([]const u32) .slice_const = len=2 {
             \\    (u32) [0] = 3010
             \\    (u32) [1] = 3014
             \\  }
-            \\  ([]volatile u32) slice_volatile = len=3 {
+            \\  ([]volatile u32) .slice_volatile = len=3 {
             \\    (u32) [0] = 3010
             \\    (u32) [1] = 3014
             \\    (u32) [2] = 3018
             \\  }
-            \\  ([]const volatile u32) slice_const_volatile = len=4 {
+            \\  ([]const volatile u32) .slice_const_volatile = len=4 {
             \\    (u32) [0] = 3010
             \\    (u32) [1] = 3014
             \\    (u32) [2] = 3018
             \\    (u32) [3] = 3022
             \\  }
-            \\  ([]allowzero u32) slice_allowzero = len=0 {}
-            \\  ([]allowzero const u32) slice_allowzero_const = len=1 {
+            \\  ([]allowzero u32) .slice_allowzero = len=0 {}
+            \\  ([]allowzero const u32) .slice_allowzero_const = len=1 {
             \\    (u32) [0] = 3026
             \\  }
-            \\  ([]allowzero volatile u32) slice_allowzero_volatile = len=2 {
+            \\  ([]allowzero volatile u32) .slice_allowzero_volatile = len=2 {
             \\    (u32) [0] = 3026
             \\    (u32) [1] = 3030
             \\  }
-            \\  ([]allowzero const volatile u32) slice_allowzero_const_volatile = len=3 {
+            \\  ([]allowzero const volatile u32) .slice_allowzero_const_volatile = len=3 {
             \\    (u32) [0] = 3026
             \\    (u32) [1] = 3030
             \\    (u32) [2] = 3034
             \\  }
-            \\  ([*c]u32) c = 0x0000000000004010
-            \\  ([*c]const u32) c_const = 0x0000000000004014
-            \\  ([*c]volatile u32) c_volatile = 0x0000000000004018
-            \\  ([*c]const volatile u32) c_const_volatile = 0x000000000000401c
+            \\  ([*c]u32) .c = 0x0000000000004010
+            \\  ([*c]const u32) .c_const = 0x0000000000004014
+            \\  ([*c]volatile u32) .c_volatile = 0x0000000000004018
+            \\  ([*c]const volatile u32) .c_const_volatile = 0x000000000000401c
             \\}
             \\(lldb) breakpoint delete --force 1
             \\1 breakpoints deleted; 0 breakpoint locations disabled.
@@ -362,10 +362,10 @@ pub fn addTestsForTarget(db: *Debugger, target: Target) void {
             \\}
             \\(lldb) frame variable --show-types --format c-string -- strings
             \\(root.strings.Strings) strings = {
-            \\  ([*c]const u8) c_ptr = "c_ptr\x07\x08\t"
-            \\  ([*:0]const u8) many_ptr = "many_ptr\n\x0b\x0c"
-            \\  (*const [12:0]u8) ptr_array = "ptr_array\x00\r\x1b"
-            \\  ([:0]const u8) slice = "slice\"\'\\\x00" len=9 {
+            \\  ([*c]const u8) .c_ptr = "c_ptr\x07\x08\t"
+            \\  ([*:0]const u8) .many_ptr = "many_ptr\n\x0b\x0c"
+            \\  (*const [12:0]u8) .ptr_array = "ptr_array\x00\r\x1b"
+            \\  ([:0]const u8) .slice = "slice\"\'\\\x00" len=9 {
             \\    (u8) [0] = "s"
             \\    (u8) [1] = "l"
             \\    (u8) [2] = "i"
@@ -434,10 +434,10 @@ pub fn addTestsForTarget(db: *Debugger, target: Target) void {
             \\}
             \\(lldb) frame variable --show-types -- enums
             \\(root.enums.Enums) enums = {
-            \\  (root.enums.Enums.Zero) zero = @enumFromInt(13)
-            \\  (root.enums.Enums.One) one = .first
-            \\  (root.enums.Enums.Two) two = @enumFromInt(-1234)
-            \\  (root.enums.Enums.Three) three = .second
+            \\  (root.enums.Enums.Zero) .zero = @enumFromInt(13)
+            \\  (root.enums.Enums.One) .one = .first
+            \\  (root.enums.Enums.Two) .two = @enumFromInt(-1234)
+            \\  (root.enums.Enums.Three) .three = .second
             \\}
             \\(lldb) breakpoint delete --force 1
             \\1 breakpoints deleted; 0 breakpoint locations disabled.
@@ -498,15 +498,15 @@ pub fn addTestsForTarget(db: *Debugger, target: Target) void {
             \\}
             \\(lldb) frame variable --show-types -- errors
             \\(root.errors.Errors) errors = {
-            \\  (error{One}) one = error.One
-            \\  (error{One,Two}) two = error.Two
-            \\  (error{One,Two,Three}) three = error.Three
-            \\  (anyerror) any = error.Any
-            \\  (anyerror!void) any_void = {
-            \\    (anyerror) error = error.NotVoid
+            \\  (error{One}) .one = error.One
+            \\  (error{One,Two}) .two = error.Two
+            \\  (error{One,Two,Three}) .three = error.Three
+            \\  (anyerror) .any = error.Any
+            \\  (anyerror!void) .any_void = {
+            \\    (anyerror) .error = error.NotVoid
             \\  }
-            \\  (error{One}!u32) any_u32 = {
-            \\    (u32) value = 42
+            \\  (error{One}!u32) .any_u32 = {
+            \\    (u32) .value = 42
             \\  }
             \\}
             \\(lldb) breakpoint delete --force 1
@@ -630,17 +630,17 @@ pub fn addTestsForTarget(db: *Debugger, target: Target) void {
             \\}
             \\(lldb) frame variable --show-types -- unions
             \\(root.unions.Unions) unions = {
-            \\  (root.unions.Unions.Untagged) untagged = {
-            \\    (u32) u32 = 3217031168
-            \\    (i32) i32 = -1077936128
-            \\    (f32) f32 = -1.5
+            \\  (root.unions.Unions.Untagged) .untagged = {
+            \\    (u32) .u32 = 3217031168
+            \\    (i32) .i32 = -1077936128
+            \\    (f32) .f32 = -1.5
             \\  }
-            \\  (root.unions.Unions.SafetyTagged) safety_tagged = {
-            \\    (root.unions.Unions.Enum) en = .second
+            \\  (root.unions.Unions.SafetyTagged) .safety_tagged = {
+            \\    (root.unions.Unions.Enum) .en = .second
             \\  }
-            \\  (root.unions.Unions.Tagged) tagged = {
-            \\    (error{Error}!root.unions.Unions.Enum) eu = {
-            \\      (error{Error}) error = error.Error
+            \\  (root.unions.Unions.Tagged) .tagged = {
+            \\    (error{Error}!root.unions.Unions.Enum) .eu = {
+            \\      (error{Error}) .error = error.Error
             \\    }
             \\  }
             \\}
@@ -721,6 +721,93 @@ pub fn addTestsForTarget(db: *Debugger, target: Target) void {
             \\1 breakpoints deleted; 0 breakpoint locations disabled.
         },
     );
+    db.addLldbTest(
+        "if_blocks",
+        target,
+        &.{
+            .{
+                .path = "if_blocks.zig",
+                .source =
+                \\pub fn main() void {
+                \\    for (0..2) |i| {
+                \\        if (i == 0) {
+                \\            var x: u32 = 123;
+                \\            _ = &x;
+                \\        } else {
+                \\            var x: f32 = 4.5;
+                \\            _ = &x;
+                \\        }
+                \\    }
+                \\}
+                \\
+                ,
+            },
+        },
+        \\breakpoint set --file if_blocks.zig --source-pattern-regexp '_ = &x;'
+        \\process launch
+        \\frame variable
+        \\process continue
+        \\frame variable
+        \\breakpoint delete --force 1
+    ,
+        &.{
+            \\(lldb) frame variable
+            \\(usize) i = 0
+            \\(u32) x = 123
+            \\(lldb) process continue
+            ,
+            \\(lldb) frame variable
+            \\(usize) i = 1
+            \\(f32) x = 4.5
+            \\(lldb) breakpoint delete --force 1
+            \\1 breakpoints deleted; 0 breakpoint locations disabled.
+        },
+    );
+    db.addLldbTest(
+        "switch_blocks",
+        target,
+        &.{
+            .{
+                .path = "switch_blocks.zig",
+                .source =
+                \\pub fn main() void {
+                \\    for (0..2) |i| {
+                \\        switch (i) {
+                \\            0 => {
+                \\                var x: u32 = 123;
+                \\                _ = &x;
+                \\            },
+                \\            else => {
+                \\                var x: f32 = 4.5;
+                \\                _ = &x;
+                \\            },
+                \\        }
+                \\    }
+                \\}
+                \\
+                ,
+            },
+        },
+        \\breakpoint set --file switch_blocks.zig --source-pattern-regexp '_ = &x;'
+        \\process launch
+        \\frame variable
+        \\process continue
+        \\frame variable
+        \\breakpoint delete --force 1
+    ,
+        &.{
+            \\(lldb) frame variable
+            \\(usize) i = 0
+            \\(u32) x = 123
+            \\(lldb) process continue
+            ,
+            \\(lldb) frame variable
+            \\(usize) i = 1
+            \\(f32) x = 4.5
+            \\(lldb) breakpoint delete --force 1
+            \\1 breakpoints deleted; 0 breakpoint locations disabled.
+        },
+    );
     db.addLldbTest(
         "inline_call",
         target,
@@ -1370,24 +1457,24 @@ pub fn addTestsForTarget(db: *Debugger, target: Target) void {
             \\(lldb) frame variable --show-types -- map.unmanaged
             \\(std.hash_map.HashMapUnmanaged(u32,u32,main.Context,63)) map.unmanaged = len=5 capacity=16 {
             \\  (std.hash_map.HashMapUnmanaged(u32,u32,main.Context,63).KV) [0] = {
-            \\    (u32) key = 0
-            \\    (u32) value = 1
+            \\    (u32) .key = 0
+            \\    (u32) .value = 1
             \\  }
             \\  (std.hash_map.HashMapUnmanaged(u32,u32,main.Context,63).KV) [1] = {
-            \\    (u32) key = 2
-            \\    (u32) value = 3
+            \\    (u32) .key = 2
+            \\    (u32) .value = 3
             \\  }
             \\  (std.hash_map.HashMapUnmanaged(u32,u32,main.Context,63).KV) [2] = {
-            \\    (u32) key = 4
-            \\    (u32) value = 5
+            \\    (u32) .key = 4
+            \\    (u32) .value = 5
             \\  }
             \\  (std.hash_map.HashMapUnmanaged(u32,u32,main.Context,63).KV) [3] = {
-            \\    (u32) key = 6
-            \\    (u32) value = 7
+            \\    (u32) .key = 6
+            \\    (u32) .value = 7
             \\  }
             \\  (std.hash_map.HashMapUnmanaged(u32,u32,main.Context,63).KV) [4] = {
-            \\    (u32) key = 8
-            \\    (u32) value = 9
+            \\    (u32) .key = 8
+            \\    (u32) .value = 9
             \\  }
             \\}
             \\(lldb) breakpoint delete --force 1
@@ -1447,37 +1534,37 @@ pub fn addTestsForTarget(db: *Debugger, target: Target) void {
             \\(lldb) frame variable --show-types -- list0 list0.len list0.capacity list0[0] list0[1] list0[2] list0.0 list0.1 list0.2
             \\(std.multi_array_list.MultiArrayList(main.Elem0)) list0 = len=3 capacity=8 {
             \\  (root.main.Elem0) [0] = {
-            \\    (u32) 0 = 1
-            \\    (u8) 1 = 2
-            \\    (u16) 2 = 3
+            \\    (u32) .@"0" = 1
+            \\    (u8) .@"1" = 2
+            \\    (u16) .@"2" = 3
             \\  }
             \\  (root.main.Elem0) [1] = {
-            \\    (u32) 0 = 4
-            \\    (u8) 1 = 5
-            \\    (u16) 2 = 6
+            \\    (u32) .@"0" = 4
+            \\    (u8) .@"1" = 5
+            \\    (u16) .@"2" = 6
             \\  }
             \\  (root.main.Elem0) [2] = {
-            \\    (u32) 0 = 7
-            \\    (u8) 1 = 8
-            \\    (u16) 2 = 9
+            \\    (u32) .@"0" = 7
+            \\    (u8) .@"1" = 8
+            \\    (u16) .@"2" = 9
             \\  }
             \\}
             \\(usize) list0.len = 3
             \\(usize) list0.capacity = 8
             \\(root.main.Elem0) list0[0] = {
-            \\  (u32) 0 = 1
-            \\  (u8) 1 = 2
-            \\  (u16) 2 = 3
+            \\  (u32) .@"0" = 1
+            \\  (u8) .@"1" = 2
+            \\  (u16) .@"2" = 3
             \\}
             \\(root.main.Elem0) list0[1] = {
-            \\  (u32) 0 = 4
-            \\  (u8) 1 = 5
-            \\  (u16) 2 = 6
+            \\  (u32) .@"0" = 4
+            \\  (u8) .@"1" = 5
+            \\  (u16) .@"2" = 6
             \\}
             \\(root.main.Elem0) list0[2] = {
-            \\  (u32) 0 = 7
-            \\  (u8) 1 = 8
-            \\  (u16) 2 = 9
+            \\  (u32) .@"0" = 7
+            \\  (u8) .@"1" = 8
+            \\  (u16) .@"2" = 9
             \\}
             \\([3]u32) list0.0 = {
             \\  (u32) [0] = 1
@@ -1497,37 +1584,37 @@ pub fn addTestsForTarget(db: *Debugger, target: Target) void {
             \\(lldb) frame variable --show-types -- slice0 slice0.len slice0.capacity slice0[0] slice0[1] slice0[2] slice0.0 slice0.1 slice0.2
             \\(std.multi_array_list.MultiArrayList(main.Elem0).Slice) slice0 = len=3 capacity=8 {
             \\  (root.main.Elem0) [0] = {
-            \\    (u32) 0 = 1
-            \\    (u8) 1 = 2
-            \\    (u16) 2 = 3
+            \\    (u32) .@"0" = 1
+            \\    (u8) .@"1" = 2
+            \\    (u16) .@"2" = 3
             \\  }
             \\  (root.main.Elem0) [1] = {
-            \\    (u32) 0 = 4
-            \\    (u8) 1 = 5
-            \\    (u16) 2 = 6
+            \\    (u32) .@"0" = 4
+            \\    (u8) .@"1" = 5
+            \\    (u16) .@"2" = 6
             \\  }
             \\  (root.main.Elem0) [2] = {
-            \\    (u32) 0 = 7
-            \\    (u8) 1 = 8
-            \\    (u16) 2 = 9
+            \\    (u32) .@"0" = 7
+            \\    (u8) .@"1" = 8
+            \\    (u16) .@"2" = 9
             \\  }
             \\}
             \\(usize) slice0.len = 3
             \\(usize) slice0.capacity = 8
             \\(root.main.Elem0) slice0[0] = {
-            \\  (u32) 0 = 1
-            \\  (u8) 1 = 2
-            \\  (u16) 2 = 3
+            \\  (u32) .@"0" = 1
+            \\  (u8) .@"1" = 2
+            \\  (u16) .@"2" = 3
             \\}
             \\(root.main.Elem0) slice0[1] = {
-            \\  (u32) 0 = 4
-            \\  (u8) 1 = 5
-            \\  (u16) 2 = 6
+            \\  (u32) .@"0" = 4
+            \\  (u8) .@"1" = 5
+            \\  (u16) .@"2" = 6
             \\}
             \\(root.main.Elem0) slice0[2] = {
-            \\  (u32) 0 = 7
-            \\  (u8) 1 = 8
-            \\  (u16) 2 = 9
+            \\  (u32) .@"0" = 7
+            \\  (u8) .@"1" = 8
+            \\  (u16) .@"2" = 9
             \\}
             \\([3]u32) slice0.0 = {
             \\  (u32) [0] = 1
@@ -1547,37 +1634,37 @@ pub fn addTestsForTarget(db: *Debugger, target: Target) void {
             \\(lldb) frame variable --show-types -- list1 list1.len list1.capacity list1[0] list1[1] list1[2] list1.a list1.b list1.c
             \\(std.multi_array_list.MultiArrayList(main.Elem1)) list1 = len=3 capacity=12 {
             \\  (root.main.Elem1) [0] = {
-            \\    (u32) a = 1
-            \\    (u8) b = 2
-            \\    (u16) c = 3
+            \\    (u32) .a = 1
+            \\    (u8) .b = 2
+            \\    (u16) .c = 3
             \\  }
             \\  (root.main.Elem1) [1] = {
-            \\    (u32) a = 4
-            \\    (u8) b = 5
-            \\    (u16) c = 6
+            \\    (u32) .a = 4
+            \\    (u8) .b = 5
+            \\    (u16) .c = 6
             \\  }
             \\  (root.main.Elem1) [2] = {
-            \\    (u32) a = 7
-            \\    (u8) b = 8
-            \\    (u16) c = 9
+            \\    (u32) .a = 7
+            \\    (u8) .b = 8
+            \\    (u16) .c = 9
             \\  }
             \\}
             \\(usize) list1.len = 3
             \\(usize) list1.capacity = 12
             \\(root.main.Elem1) list1[0] = {
-            \\  (u32) a = 1
-            \\  (u8) b = 2
-            \\  (u16) c = 3
+            \\  (u32) .a = 1
+            \\  (u8) .b = 2
+            \\  (u16) .c = 3
             \\}
             \\(root.main.Elem1) list1[1] = {
-            \\  (u32) a = 4
-            \\  (u8) b = 5
-            \\  (u16) c = 6
+            \\  (u32) .a = 4
+            \\  (u8) .b = 5
+            \\  (u16) .c = 6
             \\}
             \\(root.main.Elem1) list1[2] = {
-            \\  (u32) a = 7
-            \\  (u8) b = 8
-            \\  (u16) c = 9
+            \\  (u32) .a = 7
+            \\  (u8) .b = 8
+            \\  (u16) .c = 9
             \\}
             \\([3]u32) list1.a = {
             \\  (u32) [0] = 1
@@ -1597,37 +1684,37 @@ pub fn addTestsForTarget(db: *Debugger, target: Target) void {
             \\(lldb) frame variable --show-types -- slice1 slice1.len slice1.capacity slice1[0] slice1[1] slice1[2] slice1.a slice1.b slice1.c
             \\(std.multi_array_list.MultiArrayList(main.Elem1).Slice) slice1 = len=3 capacity=12 {
             \\  (root.main.Elem1) [0] = {
-            \\    (u32) a = 1
-            \\    (u8) b = 2
-            \\    (u16) c = 3
+            \\    (u32) .a = 1
+            \\    (u8) .b = 2
+            \\    (u16) .c = 3
             \\  }
             \\  (root.main.Elem1) [1] = {
-            \\    (u32) a = 4
-            \\    (u8) b = 5
-            \\    (u16) c = 6
+            \\    (u32) .a = 4
+            \\    (u8) .b = 5
+            \\    (u16) .c = 6
             \\  }
             \\  (root.main.Elem1) [2] = {
-            \\    (u32) a = 7
-            \\    (u8) b = 8
-            \\    (u16) c = 9
+            \\    (u32) .a = 7
+            \\    (u8) .b = 8
+            \\    (u16) .c = 9
             \\  }
             \\}
             \\(usize) slice1.len = 3
             \\(usize) slice1.capacity = 12
             \\(root.main.Elem1) slice1[0] = {
-            \\  (u32) a = 1
-            \\  (u8) b = 2
-            \\  (u16) c = 3
+            \\  (u32) .a = 1
+            \\  (u8) .b = 2
+            \\  (u16) .c = 3
             \\}
             \\(root.main.Elem1) slice1[1] = {
-            \\  (u32) a = 4
-            \\  (u8) b = 5
-            \\  (u16) c = 6
+            \\  (u32) .a = 4
+            \\  (u8) .b = 5
+            \\  (u16) .c = 6
             \\}
             \\(root.main.Elem1) slice1[2] = {
-            \\  (u32) a = 7
-            \\  (u8) b = 8
-            \\  (u16) c = 9
+            \\  (u32) .a = 7
+            \\  (u8) .b = 8
+            \\  (u16) .c = 9
             \\}
             \\([3]u32) slice1.a = {
             \\  (u32) [0] = 1
diff --git a/zig/test/standalone/empty_env/build.zig b/zig/test/standalone/empty_env/build.zig
index ed733995bf..dcbb0ad052 100644
--- a/zig/test/standalone/empty_env/build.zig
+++ b/zig/test/standalone/empty_env/build.zig
@@ -7,6 +7,13 @@ pub fn build(b: *std.Build) void {
 
     const optimize: std.builtin.OptimizeMode = .Debug;
 
+    if (builtin.os.tag == .windows and std.process.hasEnvVarConstant("ConEmuHWND")) {
+        // ConEmu injects environment variables into processes before they are executed
+        // depending on user settings. This obviously invalidates the test, so skipping
+        // it is the best option.
+        return;
+    }
+
     if (builtin.os.tag == .windows and builtin.cpu.arch == .aarch64) {
         // https://github.com/ziglang/zig/issues/13685
         return;
diff --git a/zig/test/tests.zig b/zig/test/tests.zig
index 2fdfb654f4..017f9478a9 100644
--- a/zig/test/tests.zig
+++ b/zig/test/tests.zig
@@ -579,6 +579,30 @@ const test_targets = blk: {
             .link_libc = true,
         },
 
+        .{
+            .target = .{
+                .cpu_arch = .riscv32,
+                .os_tag = .linux,
+                .abi = .none,
+            },
+        },
+        .{
+            .target = .{
+                .cpu_arch = .riscv32,
+                .os_tag = .linux,
+                .abi = .musl,
+            },
+            .link_libc = true,
+        },
+        .{
+            .target = .{
+                .cpu_arch = .riscv32,
+                .os_tag = .linux,
+                .abi = .gnu,
+            },
+            .link_libc = true,
+        },
+
         .{
             .target = .{
                 .cpu_arch = .riscv64,
@@ -612,6 +636,30 @@ const test_targets = blk: {
             .use_lld = false,
         },
 
+        .{
+            .target = .{
+                .cpu_arch = .s390x,
+                .os_tag = .linux,
+                .abi = .none,
+            },
+        },
+        .{
+            .target = .{
+                .cpu_arch = .s390x,
+                .os_tag = .linux,
+                .abi = .musl,
+            },
+            .link_libc = true,
+        },
+        .{
+            .target = .{
+                .cpu_arch = .s390x,
+                .os_tag = .linux,
+                .abi = .gnu,
+            },
+            .link_libc = true,
+        },
+
         .{
             .target = .{
                 .cpu_arch = .x86_64,
@@ -1461,3 +1509,31 @@ pub fn addDebuggerTests(b: *std.Build, options: DebuggerContext.Options) ?*Step
     });
     return step;
 }
+
+pub fn addIncrementalTests(b: *std.Build, test_step: *Step) !void {
+    const incr_check = b.addExecutable(.{
+        .name = "incr-check",
+        .root_source_file = b.path("tools/incr-check.zig"),
+        .target = b.graph.host,
+        .optimize = .Debug,
+    });
+
+    var dir = try b.build_root.handle.openDir("test/incremental", .{ .iterate = true });
+    defer dir.close();
+
+    var it = try dir.walk(b.graph.arena);
+    while (try it.next()) |entry| {
+        if (entry.kind != .file) continue;
+
+        const run = b.addRunArtifact(incr_check);
+        run.setName(b.fmt("incr-check '{s}'", .{entry.basename}));
+
+        run.addArg(b.graph.zig_exe);
+        run.addFileArg(b.path("test/incremental/").path(b, entry.path));
+        run.addArgs(&.{ "--zig-lib-dir", b.fmt("{}", .{b.graph.zig_lib_directory}) });
+
+        run.addCheck(.{ .expect_term = .{ .Exited = 0 } });
+
+        test_step.dependOn(&run.step);
+    }
+}
diff --git a/zig/tools/generate_linux_syscalls.zig b/zig/tools/generate_linux_syscalls.zig
index f11633491e..df1b5127df 100644
--- a/zig/tools/generate_linux_syscalls.zig
+++ b/zig/tools/generate_linux_syscalls.zig
@@ -22,6 +22,8 @@ const stdlib_renames = std.StaticStringMap([]const u8).initComptime(.{
     // ARM EABI/Thumb.
     .{ "arm_sync_file_range", "sync_file_range" },
     .{ "arm_fadvise64_64", "fadvise64_64" },
+    // ARC and Hexagon.
+    .{ "mmap_pgoff", "mmap2" },
 });
 
 // Only for newer architectures where we use the C preprocessor.
diff --git a/zig/tools/incr-check.zig b/zig/tools/incr-check.zig
index eafe6e8c04..b5329f134e 100644
--- a/zig/tools/incr-check.zig
+++ b/zig/tools/incr-check.zig
@@ -1,17 +1,12 @@
 const std = @import("std");
-const fatal = std.process.fatal;
 const Allocator = std.mem.Allocator;
 const Cache = std.Build.Cache;
 
-const usage = "usage: incr-check <zig binary path> <input file> [--zig-lib-dir lib] [--debug-zcu] [--emit none|bin|c] [--zig-cc-binary /path/to/zig]";
-
-const EmitMode = enum {
-    none,
-    bin,
-    c,
-};
+const usage = "usage: incr-check <zig binary path> <input file> [--zig-lib-dir lib] [--debug-zcu] [--debug-link] [--preserve-tmp] [--zig-cc-binary /path/to/zig]";
 
 pub fn main() !void {
+    const fatal = std.process.fatal;
+
     var arena_instance = std.heap.ArenaAllocator.init(std.heap.page_allocator);
     defer arena_instance.deinit();
     const arena = arena_instance.allocator();
@@ -20,21 +15,22 @@ pub fn main() !void {
     var opt_input_file_name: ?[]const u8 = null;
     var opt_lib_dir: ?[]const u8 = null;
     var opt_cc_zig: ?[]const u8 = null;
-    var emit: EmitMode = .bin;
     var debug_zcu = false;
+    var debug_link = false;
+    var preserve_tmp = false;
 
     var arg_it = try std.process.argsWithAllocator(arena);
     _ = arg_it.skip();
     while (arg_it.next()) |arg| {
         if (arg.len > 0 and arg[0] == '-') {
-            if (std.mem.eql(u8, arg, "--emit")) {
-                const emit_str = arg_it.next() orelse fatal("expected arg after '--emit'\n{s}", .{usage});
-                emit = std.meta.stringToEnum(EmitMode, emit_str) orelse
-                    fatal("invalid emit mode '{s}'\n{s}", .{ emit_str, usage });
-            } else if (std.mem.eql(u8, arg, "--zig-lib-dir")) {
+            if (std.mem.eql(u8, arg, "--zig-lib-dir")) {
                 opt_lib_dir = arg_it.next() orelse fatal("expected arg after '--zig-lib-dir'\n{s}", .{usage});
             } else if (std.mem.eql(u8, arg, "--debug-zcu")) {
                 debug_zcu = true;
+            } else if (std.mem.eql(u8, arg, "--debug-link")) {
+                debug_link = true;
+            } else if (std.mem.eql(u8, arg, "--preserve-tmp")) {
+                preserve_tmp = true;
             } else if (std.mem.eql(u8, arg, "--zig-cc-binary")) {
                 opt_cc_zig = arg_it.next() orelse fatal("expect arg after '--zig-cc-binary'\n{s}", .{usage});
             } else {
@@ -56,15 +52,29 @@ pub fn main() !void {
     const input_file_bytes = try std.fs.cwd().readFileAlloc(arena, input_file_name, std.math.maxInt(u32));
     const case = try Case.parse(arena, input_file_bytes);
 
+    // Check now: if there are any targets using the `cbe` backend, we need the lib dir.
+    if (opt_lib_dir == null) {
+        for (case.targets) |target| {
+            if (target.backend == .cbe) {
+                fatal("'--zig-lib-dir' requried when using backend 'cbe'", .{});
+            }
+        }
+    }
+
     const prog_node = std.Progress.start(.{});
     defer prog_node.end();
 
     const rand_int = std.crypto.random.int(u64);
     const tmp_dir_path = "tmp_" ++ std.fmt.hex(rand_int);
-    const tmp_dir = try std.fs.cwd().makeOpenPath(tmp_dir_path, .{});
-
-    const child_prog_node = prog_node.start("zig build-exe", 0);
-    defer child_prog_node.end();
+    var tmp_dir = try std.fs.cwd().makeOpenPath(tmp_dir_path, .{});
+    defer {
+        tmp_dir.close();
+        if (!preserve_tmp) {
+            std.fs.cwd().deleteTree(tmp_dir_path) catch |err| {
+                std.log.warn("failed to delete tree '{s}': {s}", .{ tmp_dir_path, @errorName(err) });
+            };
+        }
+    }
 
     // Convert paths to be relative to the cwd of the subprocess.
     const resolved_zig_exe = try std.fs.path.relative(arena, tmp_dir_path, zig_exe);
@@ -73,104 +83,132 @@ pub fn main() !void {
     else
         null;
 
-    var child_args: std.ArrayListUnmanaged([]const u8) = .empty;
-    try child_args.appendSlice(arena, &.{
-        resolved_zig_exe,
-        "build-exe",
-        case.root_source_file,
-        "-fincremental",
-        "-target",
-        case.target_query,
-        "--cache-dir",
-        ".local-cache",
-        "--global-cache-dir",
-        ".global_cache",
-        "--listen=-",
-    });
-    if (opt_resolved_lib_dir) |resolved_lib_dir| {
-        try child_args.appendSlice(arena, &.{ "--zig-lib-dir", resolved_lib_dir });
-    }
-    switch (emit) {
-        .bin => try child_args.appendSlice(arena, &.{ "-fno-llvm", "-fno-lld" }),
-        .none => try child_args.append(arena, "-fno-emit-bin"),
-        .c => try child_args.appendSlice(arena, &.{ "-ofmt=c", "-lc" }),
-    }
-    if (debug_zcu) {
-        try child_args.appendSlice(arena, &.{ "--debug-log", "zcu" });
-    }
+    const host = try std.zig.system.resolveTargetQuery(.{});
+
+    const debug_log_verbose = debug_zcu or debug_link;
+
+    for (case.targets) |target| {
+        const target_prog_node = node: {
+            var name_buf: [std.Progress.Node.max_name_len]u8 = undefined;
+            const name = std.fmt.bufPrint(&name_buf, "{s}-{s}", .{ target.query, @tagName(target.backend) }) catch &name_buf;
+            break :node prog_node.start(name, case.updates.len);
+        };
+        defer target_prog_node.end();
 
-    var child = std.process.Child.init(child_args.items, arena);
-    child.stdin_behavior = .Pipe;
-    child.stdout_behavior = .Pipe;
-    child.stderr_behavior = .Pipe;
-    child.progress_node = child_prog_node;
-    child.cwd_dir = tmp_dir;
-    child.cwd = tmp_dir_path;
-
-    var cc_child_args: std.ArrayListUnmanaged([]const u8) = .empty;
-    if (emit == .c) {
-        const resolved_cc_zig_exe = if (opt_cc_zig) |cc_zig_exe|
-            try std.fs.path.relative(arena, tmp_dir_path, cc_zig_exe)
-        else
-            resolved_zig_exe;
-
-        try cc_child_args.appendSlice(arena, &.{
-            resolved_cc_zig_exe,
-            "cc",
+        if (debug_log_verbose) {
+            std.log.scoped(.status).info("target: '{s}-{s}'", .{ target.query, @tagName(target.backend) });
+        }
+
+        var child_args: std.ArrayListUnmanaged([]const u8) = .empty;
+        try child_args.appendSlice(arena, &.{
+            resolved_zig_exe,
+            "build-exe",
+            case.root_source_file,
+            "-fincremental",
             "-target",
-            case.target_query,
-            "-I",
-            opt_resolved_lib_dir orelse fatal("'--zig-lib-dir' required when using '--emit c'", .{}),
-            "-o",
+            target.query,
+            "--cache-dir",
+            ".local-cache",
+            "--global-cache-dir",
+            ".global-cache",
+            "--listen=-",
         });
-    }
+        if (opt_resolved_lib_dir) |resolved_lib_dir| {
+            try child_args.appendSlice(arena, &.{ "--zig-lib-dir", resolved_lib_dir });
+        }
+        switch (target.backend) {
+            .sema => try child_args.append(arena, "-fno-emit-bin"),
+            .selfhosted => try child_args.appendSlice(arena, &.{ "-fno-llvm", "-fno-lld" }),
+            .llvm => try child_args.appendSlice(arena, &.{ "-fllvm", "-flld" }),
+            .cbe => try child_args.appendSlice(arena, &.{ "-ofmt=c", "-lc" }),
+        }
+        if (debug_zcu) {
+            try child_args.appendSlice(arena, &.{ "--debug-log", "zcu" });
+        }
+        if (debug_link) {
+            try child_args.appendSlice(arena, &.{ "--debug-log", "link", "--debug-log", "link_state", "--debug-log", "link_relocs" });
+        }
 
-    var eval: Eval = .{
-        .arena = arena,
-        .case = case,
-        .tmp_dir = tmp_dir,
-        .tmp_dir_path = tmp_dir_path,
-        .child = &child,
-        .allow_stderr = debug_zcu,
-        .emit = emit,
-        .cc_child_args = &cc_child_args,
-    };
+        const zig_prog_node = target_prog_node.start("zig build-exe", 0);
+        defer zig_prog_node.end();
+
+        var child = std.process.Child.init(child_args.items, arena);
+        child.stdin_behavior = .Pipe;
+        child.stdout_behavior = .Pipe;
+        child.stderr_behavior = .Pipe;
+        child.progress_node = zig_prog_node;
+        child.cwd_dir = tmp_dir;
+        child.cwd = tmp_dir_path;
+
+        var cc_child_args: std.ArrayListUnmanaged([]const u8) = .empty;
+        if (target.backend == .cbe) {
+            const resolved_cc_zig_exe = if (opt_cc_zig) |cc_zig_exe|
+                try std.fs.path.relative(arena, tmp_dir_path, cc_zig_exe)
+            else
+                resolved_zig_exe;
+
+            try cc_child_args.appendSlice(arena, &.{
+                resolved_cc_zig_exe,
+                "cc",
+                "-target",
+                target.query,
+                "-I",
+                opt_resolved_lib_dir.?, // verified earlier
+                "-o",
+            });
+        }
 
-    try child.spawn();
+        var eval: Eval = .{
+            .arena = arena,
+            .case = case,
+            .host = host,
+            .target = target,
+            .tmp_dir = tmp_dir,
+            .tmp_dir_path = tmp_dir_path,
+            .child = &child,
+            .allow_stderr = debug_log_verbose,
+            .preserve_tmp_on_fatal = preserve_tmp,
+            .cc_child_args = &cc_child_args,
+        };
 
-    var poller = std.io.poll(arena, Eval.StreamEnum, .{
-        .stdout = child.stdout.?,
-        .stderr = child.stderr.?,
-    });
-    defer poller.deinit();
+        try child.spawn();
 
-    for (case.updates) |update| {
-        var update_node = prog_node.start(update.name, 0);
-        defer update_node.end();
+        var poller = std.io.poll(arena, Eval.StreamEnum, .{
+            .stdout = child.stdout.?,
+            .stderr = child.stderr.?,
+        });
+        defer poller.deinit();
 
-        if (debug_zcu) {
-            std.log.info("=== START UPDATE '{s}' ===", .{update.name});
-        }
+        for (case.updates) |update| {
+            var update_node = target_prog_node.start(update.name, 0);
+            defer update_node.end();
 
-        eval.write(update);
-        try eval.requestUpdate();
-        try eval.check(&poller, update, update_node);
-    }
+            if (debug_log_verbose) {
+                std.log.scoped(.status).info("update: '{s}'", .{update.name});
+            }
 
-    try eval.end(&poller);
+            eval.write(update);
+            try eval.requestUpdate();
+            try eval.check(&poller, update, update_node);
+        }
+
+        try eval.end(&poller);
 
-    waitChild(&child);
+        waitChild(&child, &eval);
+    }
 }
 
 const Eval = struct {
     arena: Allocator,
+    host: std.Target,
     case: Case,
+    target: Case.Target,
     tmp_dir: std.fs.Dir,
     tmp_dir_path: []const u8,
     child: *std.process.Child,
     allow_stderr: bool,
-    emit: EmitMode,
-    /// When `emit == .c`, this contains the first few arguments to `zig cc` to build the generated binary.
+    preserve_tmp_on_fatal: bool,
+    /// When `target.backend == .cbe`, this contains the first few arguments to `zig cc` to build the generated binary.
     /// The arguments `out.c in.c` must be appended before spawning the subprocess.
     cc_child_args: *std.ArrayListUnmanaged([]const u8),
 
@@ -184,12 +222,12 @@ const Eval = struct {
                 .sub_path = full_contents.name,
                 .data = full_contents.bytes,
             }) catch |err| {
-                fatal("failed to update '{s}': {s}", .{ full_contents.name, @errorName(err) });
+                eval.fatal("failed to update '{s}': {s}", .{ full_contents.name, @errorName(err) });
             };
         }
         for (update.deletes) |doomed_name| {
             eval.tmp_dir.deleteFile(doomed_name) catch |err| {
-                fatal("failed to delete '{s}': {s}", .{ doomed_name, @errorName(err) });
+                eval.fatal("failed to delete '{s}': {s}", .{ doomed_name, @errorName(err) });
             };
         }
     }
@@ -231,7 +269,7 @@ const Eval = struct {
                         if (eval.allow_stderr) {
                             std.log.info("error_bundle included stderr:\n{s}", .{stderr_data});
                         } else {
-                            fatal("error_bundle included unexpected stderr:\n{s}", .{stderr_data});
+                            eval.fatal("error_bundle included unexpected stderr:\n{s}", .{stderr_data});
                         }
                     }
                     if (result_error_bundle.errorMessageCount() != 0) {
@@ -250,15 +288,14 @@ const Eval = struct {
                         if (eval.allow_stderr) {
                             std.log.info("emit_digest included stderr:\n{s}", .{stderr_data});
                         } else {
-                            fatal("emit_digest included unexpected stderr:\n{s}", .{stderr_data});
+                            eval.fatal("emit_digest included unexpected stderr:\n{s}", .{stderr_data});
                         }
                     }
 
-                    if (eval.emit == .none) {
+                    if (eval.target.backend == .sema) {
                         try eval.checkSuccessOutcome(update, null, prog_node);
                         // This message indicates the end of the update.
                         stdout.discard(body.len);
-                        return;
                     }
 
                     const digest = body[@sizeOf(EbpHdr)..][0..Cache.bin_digest_len];
@@ -267,14 +304,7 @@ const Eval = struct {
                     const name = std.fs.path.stem(std.fs.path.basename(eval.case.root_source_file));
                     const bin_name = try std.zig.binNameAlloc(arena, .{
                         .root_name = name,
-                        .target = try std.zig.system.resolveTargetQuery(try std.Build.parseTargetQuery(.{
-                            .arch_os_abi = eval.case.target_query,
-                            .object_format = switch (eval.emit) {
-                                .none => unreachable,
-                                .bin => null,
-                                .c => "c",
-                            },
-                        })),
+                        .target = eval.target.resolved,
                         .output_mode = .Exe,
                     });
                     const bin_path = try std.fs.path.join(arena, &.{ result_dir, bin_name });
@@ -282,7 +312,6 @@ const Eval = struct {
                     try eval.checkSuccessOutcome(update, bin_path, prog_node);
                     // This message indicates the end of the update.
                     stdout.discard(body.len);
-                    return;
                 },
                 else => {
                     // Ignore other messages.
@@ -296,16 +325,15 @@ const Eval = struct {
             if (eval.allow_stderr) {
                 std.log.info("update '{s}' included stderr:\n{s}", .{ update.name, stderr_data });
             } else {
-                fatal("update '{s}' failed:\n{s}", .{ update.name, stderr_data });
+                eval.fatal("update '{s}' failed:\n{s}", .{ update.name, stderr_data });
             }
         }
 
-        waitChild(eval.child);
-        fatal("update '{s}': compiler failed to send error_bundle or emit_bin_path", .{update.name});
+        waitChild(eval.child, eval);
+        eval.fatal("update '{s}': compiler failed to send error_bundle or emit_bin_path", .{update.name});
     }
 
     fn checkErrorOutcome(eval: *Eval, update: Case.Update, error_bundle: std.zig.ErrorBundle) !void {
-        _ = eval;
         switch (update.outcome) {
             .unknown => return,
             .compile_errors => |expected_errors| {
@@ -317,7 +345,7 @@ const Eval = struct {
             .stdout, .exit_code => {
                 const color: std.zig.Color = .auto;
                 error_bundle.renderToStdErr(color.renderOptions());
-                fatal("update '{s}': unexpected compile errors", .{update.name});
+                eval.fatal("update '{s}': unexpected compile errors", .{update.name});
             },
         }
     }
@@ -325,18 +353,18 @@ const Eval = struct {
     fn checkSuccessOutcome(eval: *Eval, update: Case.Update, opt_emitted_path: ?[]const u8, prog_node: std.Progress.Node) !void {
         switch (update.outcome) {
             .unknown => return,
-            .compile_errors => fatal("expected compile errors but compilation incorrectly succeeded", .{}),
+            .compile_errors => eval.fatal("expected compile errors but compilation incorrectly succeeded", .{}),
             .stdout, .exit_code => {},
         }
         const emitted_path = opt_emitted_path orelse {
-            std.debug.assert(eval.emit == .none);
+            std.debug.assert(eval.target.backend == .sema);
             return;
         };
 
-        const binary_path = switch (eval.emit) {
-            .none => unreachable,
-            .bin => emitted_path,
-            .c => bin: {
+        const binary_path = switch (eval.target.backend) {
+            .sema => unreachable,
+            .selfhosted, .llvm => emitted_path,
+            .cbe => bin: {
                 const rand_int = std.crypto.random.int(u64);
                 const out_bin_name = "./out_" ++ std.fmt.hex(rand_int);
                 try eval.buildCOutput(update, emitted_path, out_bin_name, prog_node);
@@ -344,27 +372,73 @@ const Eval = struct {
             },
         };
 
+        var argv_buf: [2][]const u8 = undefined;
+        const argv: []const []const u8, const is_foreign: bool = switch (std.zig.system.getExternalExecutor(
+            eval.host,
+            &eval.target.resolved,
+            .{ .link_libc = eval.target.backend == .cbe },
+        )) {
+            .bad_dl, .bad_os_or_cpu => {
+                // This binary cannot be executed on this host.
+                if (eval.allow_stderr) {
+                    std.log.warn("skipping execution because host '{s}' cannot execute binaries for foreign target '{s}'", .{
+                        try eval.host.zigTriple(eval.arena),
+                        try eval.target.resolved.zigTriple(eval.arena),
+                    });
+                }
+                return;
+            },
+            .native, .rosetta => argv: {
+                argv_buf[0] = binary_path;
+                break :argv .{ argv_buf[0..1], false };
+            },
+            .qemu, .wine, .wasmtime, .darling => |executor_cmd| argv: {
+                argv_buf[0] = executor_cmd;
+                argv_buf[1] = binary_path;
+                break :argv .{ argv_buf[0..2], true };
+            },
+        };
+
+        const run_prog_node = prog_node.start("run generated executable", 0);
+        defer run_prog_node.end();
+
         const result = std.process.Child.run(.{
             .allocator = eval.arena,
-            .argv = &.{binary_path},
+            .argv = argv,
             .cwd_dir = eval.tmp_dir,
             .cwd = eval.tmp_dir_path,
         }) catch |err| {
-            fatal("update '{s}': failed to run the generated executable '{s}': {s}", .{
+            if (is_foreign) {
+                // Chances are the foreign executor isn't available. Skip this evaluation.
+                if (eval.allow_stderr) {
+                    std.log.warn("update '{s}': skipping execution of '{s}' via executor for foreign target '{s}': {s}", .{
+                        update.name,
+                        binary_path,
+                        try eval.target.resolved.zigTriple(eval.arena),
+                        @errorName(err),
+                    });
+                }
+                return;
+            }
+            eval.fatal("update '{s}': failed to run the generated executable '{s}': {s}", .{
                 update.name, binary_path, @errorName(err),
             });
         };
-        if (result.stderr.len != 0) {
+
+        // Some executors (looking at you, Wine) like throwing some stderr in, just for fun.
+        // Therefore, we'll ignore stderr when using a foreign executor.
+        if (!is_foreign and result.stderr.len != 0) {
             std.log.err("update '{s}': generated executable '{s}' had unexpected stderr:\n{s}", .{
                 update.name, binary_path, result.stderr,
             });
         }
+
         switch (result.term) {
             .Exited => |code| switch (update.outcome) {
                 .unknown, .compile_errors => unreachable,
                 .stdout => |expected_stdout| {
                     if (code != 0) {
-                        fatal("update '{s}': generated executable '{s}' failed with code {d}", .{
+                        eval.fatal("update '{s}': generated executable '{s}' failed with code {d}", .{
                             update.name, binary_path, code,
                         });
                     }
@@ -373,12 +447,13 @@ const Eval = struct {
                 .exit_code => |expected_code| try std.testing.expectEqual(expected_code, result.term.Exited),
             },
             .Signal, .Stopped, .Unknown => {
-                fatal("update '{s}': generated executable '{s}' terminated unexpectedly", .{
+                eval.fatal("update '{s}': generated executable '{s}' terminated unexpectedly", .{
                     update.name, binary_path,
                 });
             },
         }
-        if (result.stderr.len != 0) std.process.exit(1);
+
+        if (!is_foreign and result.stderr.len != 0) std.process.exit(1);
     }
 
     fn requestUpdate(eval: *Eval) !void {
@@ -390,7 +465,7 @@ const Eval = struct {
     }
 
     fn end(eval: *Eval, poller: *Poller) !void {
-        requestExit(eval.child);
+        requestExit(eval.child, eval);
 
         const Header = std.zig.Server.Message.Header;
         const stdout = poller.fifo(.stdout);
@@ -410,7 +485,7 @@ const Eval = struct {
 
         if (stderr.readableLength() > 0) {
             const stderr_data = try stderr.toOwnedSlice();
-            fatal("unexpected stderr:\n{s}", .{stderr_data});
+            eval.fatal("unexpected stderr:\n{s}", .{stderr_data});
         }
     }
 
@@ -430,7 +505,7 @@ const Eval = struct {
             .cwd = eval.tmp_dir_path,
             .progress_node = child_prog_node,
         }) catch |err| {
-            fatal("update '{s}': failed to spawn zig cc for '{s}': {s}", .{
+            eval.fatal("update '{s}': failed to spawn zig cc for '{s}': {s}", .{
                 update.name, c_path, @errorName(err),
             });
         };
@@ -441,7 +516,7 @@ const Eval = struct {
                         update.name, result.stderr,
                     });
                 }
-                fatal("update '{s}': zig cc for '{s}' failed with code {d}", .{
+                eval.fatal("update '{s}': zig cc for '{s}' failed with code {d}", .{
                     update.name, c_path, code,
                 });
             },
@@ -451,18 +526,48 @@ const Eval = struct {
                         update.name, result.stderr,
                     });
                 }
-                fatal("update '{s}': zig cc for '{s}' terminated unexpectedly", .{
+                eval.fatal("update '{s}': zig cc for '{s}' terminated unexpectedly", .{
                     update.name, c_path,
                 });
             },
         }
     }
+
+    fn fatal(eval: *Eval, comptime fmt: []const u8, args: anytype) noreturn {
+        eval.tmp_dir.close();
+        if (!eval.preserve_tmp_on_fatal) {
+            std.fs.cwd().deleteTree(eval.tmp_dir_path) catch |err| {
+                std.log.warn("failed to delete tree '{s}': {s}", .{ eval.tmp_dir_path, @errorName(err) });
+            };
+        }
+        std.process.fatal(fmt, args);
+    }
 };
 
 const Case = struct {
     updates: []Update,
     root_source_file: []const u8,
-    target_query: []const u8,
+    targets: []const Target,
+
+    const Target = struct {
+        query: []const u8,
+        resolved: std.Target,
+        backend: Backend,
+        const Backend = enum {
+            /// Run semantic analysis only. Runtime output will not be tested, but we still verify
+            /// that compilation succeeds. Corresponds to `-fno-emit-bin`.
+            sema,
+            /// Use the self-hosted code generation backend for this target.
+            /// Corresponds to `-fno-llvm -fno-lld`.
+            selfhosted,
+            /// Use the LLVM backend.
+            /// Corresponds to `-fllvm -flld`.
+            llvm,
+            /// Use the C backend. The output is compiled with `zig cc`.
+            /// Corresponds to `-ofmt=c`.
+            cbe,
+        };
+    };
 
     const Update = struct {
         name: []const u8,
@@ -492,9 +597,11 @@ const Case = struct {
     };
 
     fn parse(arena: Allocator, bytes: []const u8) !Case {
+        const fatal = std.process.fatal;
+
+        var targets: std.ArrayListUnmanaged(Target) = .empty;
         var updates: std.ArrayListUnmanaged(Update) = .empty;
         var changes: std.ArrayListUnmanaged(FullContents) = .empty;
-        var target_query: ?[]const u8 = null;
         var it = std.mem.splitScalar(u8, bytes, '\n');
         var line_n: usize = 1;
         var root_source_file: ?[]const u8 = null;
@@ -502,12 +609,34 @@ const Case = struct {
             if (std.mem.startsWith(u8, line, "#")) {
                 var line_it = std.mem.splitScalar(u8, line, '=');
                 const key = line_it.first()[1..];
-                const val = line_it.rest();
+                const val = std.mem.trimRight(u8, line_it.rest(), "\r"); // windows moment
                 if (val.len == 0) {
                     fatal("line {d}: missing value", .{line_n});
                 } else if (std.mem.eql(u8, key, "target")) {
-                    if (target_query != null) fatal("line {d}: duplicate target", .{line_n});
-                    target_query = val;
+                    const split_idx = std.mem.lastIndexOfScalar(u8, val, '-') orelse
+                        fatal("line {d}: target does not include backend", .{line_n});
+
+                    const query = val[0..split_idx];
+
+                    const backend_str = val[split_idx + 1 ..];
+                    const backend: Target.Backend = std.meta.stringToEnum(Target.Backend, backend_str) orelse
+                        fatal("line {d}: invalid backend '{s}'", .{ line_n, backend_str });
+
+                    const parsed_query = std.Build.parseTargetQuery(.{
+                        .arch_os_abi = query,
+                        .object_format = switch (backend) {
+                            .sema, .selfhosted, .llvm => null,
+                            .cbe => "c",
+                        },
+                    }) catch fatal("line {d}: invalid target query '{s}'", .{ line_n, query });
+
+                    const resolved = try std.zig.system.resolveTargetQuery(parsed_query);
+
+                    try targets.append(arena, .{
+                        .query = query,
+                        .resolved = resolved,
+                        .backend = backend,
+                    });
                 } else if (std.mem.eql(u8, key, "update")) {
                     if (updates.items.len > 0) {
                         const last_update = &updates.items[updates.items.len - 1];
@@ -559,20 +688,24 @@ const Case = struct {
             }
         }
 
+        if (targets.items.len == 0) {
+            fatal("missing target", .{});
+        }
+
         if (changes.items.len > 0) {
             const last_update = &updates.items[updates.items.len - 1];
-            last_update.changes = try changes.toOwnedSlice(arena);
+            last_update.changes = changes.items; // arena so no need for toOwnedSlice
         }
 
         return .{
             .updates = updates.items,
             .root_source_file = root_source_file orelse fatal("missing root source file", .{}),
-            .target_query = target_query orelse fatal("missing target", .{}),
+            .targets = targets.items, // arena so no need for toOwnedSlice
         };
     }
 };
 
-fn requestExit(child: *std.process.Child) void {
+fn requestExit(child: *std.process.Child, eval: *Eval) void {
     if (child.stdin == null) return;
 
     const header: std.zig.Client.Message.Header = .{
@@ -581,7 +714,7 @@ fn requestExit(child: *std.process.Child) void {
     };
     child.stdin.?.writeAll(std.mem.asBytes(&header)) catch |err| switch (err) {
         error.BrokenPipe => {},
-        else => fatal("failed to send exit: {s}", .{@errorName(err)}),
+        else => eval.fatal("failed to send exit: {s}", .{@errorName(err)}),
     };
 
     // Send EOF to stdin.
@@ -589,11 +722,11 @@ fn requestExit(child: *std.process.Child) void {
     child.stdin = null;
 }
 
-fn waitChild(child: *std.process.Child) void {
-    requestExit(child);
-    const term = child.wait() catch |err| fatal("child process failed: {s}", .{@errorName(err)});
+fn waitChild(child: *std.process.Child, eval: *Eval) void {
+    requestExit(child, eval);
+    const term = child.wait() catch |err| eval.fatal("child process failed: {s}", .{@errorName(err)});
     switch (term) {
-        .Exited => |code| if (code != 0) fatal("compiler failed with code {d}", .{code}),
-        .Signal, .Stopped, .Unknown => fatal("compiler terminated unexpectedly", .{}),
+        .Exited => |code| if (code != 0) eval.fatal("compiler failed with code {d}", .{code}),
+        .Signal, .Stopped, .Unknown => eval.fatal("compiler terminated unexpectedly", .{}),
     }
 }
diff --git a/zig/tools/lldb_pretty_printers.py b/zig/tools/lldb_pretty_printers.py
index 7bb6aa78c2..dd4fe77add 100644
--- a/zig/tools/lldb_pretty_printers.py
+++ b/zig/tools/lldb_pretty_printers.py
@@ -1,7 +1,7 @@
 # pretty printing for the zig language, zig standard library, and zig stage 2 compiler.
 # put commands in ~/.lldbinit to run them automatically when starting lldb
 # `command script import /path/to/zig/tools/lldb_pretty_printers.py` to import this file
-# `type category enable zig` to enable pretty printing for the zig language
+# `type category enable zig.lang` to enable pretty printing for the zig language
 # `type category enable zig.std` to enable pretty printing for the zig standard library
 # `type category enable zig.stage2` to enable pretty printing for the zig stage 2 compiler
 import lldb
@@ -688,11 +688,14 @@ def add(debugger, *, category, regex=False, type, identifier=None, synth=False,
 def MultiArrayList_Entry(type): return '^multi_array_list\\.MultiArrayList\\(%s\\)\\.Entry__struct_[1-9][0-9]*$' % type
 
 def __lldb_init_module(debugger, _=None):
+    # Initialize Zig Categories
+    debugger.HandleCommand('type category define --language c99 zig.lang zig.std')
+
     # Initialize Zig Language
-    add(debugger, category='zig', regex=True, type='^\\[\\]', identifier='zig_Slice', synth=True, expand=True, summary='len=${svar%#}')
-    add(debugger, category='zig', type='[]u8', identifier='zig_String', summary=True)
-    add(debugger, category='zig', regex=True, type='^\\?', identifier='zig_Optional', synth=True, summary=True)
-    add(debugger, category='zig', regex=True, type='^(error{.*}|anyerror)!', identifier='zig_ErrorUnion', synth=True, inline_children=True, summary=True)
+    add(debugger, category='zig.lang', regex=True, type='^\\[\\]', identifier='zig_Slice', synth=True, expand=True, summary='len=${svar%#}')
+    add(debugger, category='zig.lang', type='[]u8', identifier='zig_String', summary=True)
+    add(debugger, category='zig.lang', regex=True, type='^\\?', identifier='zig_Optional', synth=True, summary=True)
+    add(debugger, category='zig.lang', regex=True, type='^(error{.*}|anyerror)!', identifier='zig_ErrorUnion', synth=True, inline_children=True, summary=True)
 
     # Initialize Zig Standard Library
     add(debugger, category='zig.std', type='mem.Allocator', summary='${var.ptr}')
diff --git a/zig/tools/process_headers.zig b/zig/tools/process_headers.zig
index c83903bc28..970c383886 100644
--- a/zig/tools/process_headers.zig
+++ b/zig/tools/process_headers.zig
@@ -209,6 +209,11 @@ const glibc_targets = [_]LibCTarget{
         .arch = MultiArch{ .specific = .loongarch64 },
         .abi = MultiAbi{ .specific = Abi.gnu },
     },
+    LibCTarget{
+        .name = "loongarch64-linux-gnu-lp64s",
+        .arch = MultiArch{ .specific = .loongarch64 },
+        .abi = MultiAbi{ .specific = Abi.gnusf },
+    },
 };
 
 const musl_targets = [_]LibCTarget{
diff --git a/zig/tools/update_cpu_features.zig b/zig/tools/update_cpu_features.zig
index 63637d8f78..fdc7b02a9e 100644
--- a/zig/tools/update_cpu_features.zig
+++ b/zig/tools/update_cpu_features.zig
@@ -61,10 +61,6 @@ const llvm_targets = [_]LlvmTarget{
                 .zig_name = "contextidr_el2",
                 .desc = "Enable RW operand Context ID Register (EL2)",
             },
-            .{
-                .llvm_name = "v8a",
-                .extra_deps = &.{"neon"},
-            },
             .{
                 .llvm_name = "neoversee1",
                 .flatten = true,
@@ -487,7 +483,6 @@ const llvm_targets = [_]LlvmTarget{
             .{
                 .llvm_name = "cortex-m85",
                 .omit_deps = &.{ "mve_fp", "pacbti", "fp_armv8d16" },
-                .extra_deps = &.{"trustzone"},
             },
             .{
                 .llvm_name = "cortex-x1c",
@@ -1436,6 +1431,24 @@ fn processOneTarget(job: Job) anyerror!void {
                         try deps.append(other_zig_name);
                     }
                 }
+                // This is used by AArch64.
+                if (kv.value_ptr.object.get("DefaultExts")) |exts_val| {
+                    for (exts_val.array.items) |ext| {
+                        const other_key = ext.object.get("def").?.string;
+                        const other_obj = &root_map.getPtr(other_key).?.object;
+                        const other_llvm_name = other_obj.get("Name").?.string;
+                        const other_zig_name = (try llvmFeatureNameToZigNameOmit(
+                            arena,
+                            llvm_target,
+                            other_llvm_name,
+                        )) orelse continue;
+                        for (omit_deps) |omit_dep| {
+                            if (mem.eql(u8, other_zig_name, omit_dep)) break;
+                        } else {
+                            try deps.append(other_zig_name);
+                        }
+                    }
+                }
                 for (extra_deps) |extra_dep| {
                     try deps.append(extra_dep);
                 }
@@ -1563,12 +1576,6 @@ fn processOneTarget(job: Job) anyerror!void {
 
     const zig_code_basename = try std.fmt.allocPrint(arena, "{s}.zig", .{llvm_target.zig_name});
 
-    if (all_features.items.len == 0) {
-        // We represent this with an empty file.
-        try target_dir.deleteTree(zig_code_basename);
-        return;
-    }
-
     var zig_code_file = try target_dir.createFile(zig_code_basename, .{});
     defer zig_code_file.close();
 
@@ -1583,11 +1590,12 @@ fn processOneTarget(job: Job) anyerror!void {
         \\const CpuModel = std.Target.Cpu.Model;
         \\
         \\pub const Feature = enum {
-        \\
     );
 
-    for (all_features.items) |feature| {
-        try w.print("    {p},\n", .{std.zig.fmtId(feature.zig_name)});
+    for (all_features.items, 0..) |feature, i| {
+        try w.print("\n    {p},", .{std.zig.fmtId(feature.zig_name)});
+
+        if (i == all_features.items.len - 1) try w.writeAll("\n");
     }
 
     try w.writeAll(

From bc7b15c1a0797a5a033b572fbd560f406be12bea Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Fri, 11 Oct 2024 15:43:23 +0200
Subject: [PATCH 2/2] Update the list of working target triples

Closes #42.
Closes #52.
Closes #98.
Closes #99.
Closes #103.
Closes #105.
Closes #116.
Closes #175.
Closes #176.
Closes #179.
Closes #180.
Closes #183.
---
 README.md | 27 ++++++++++++++-------------
 1 file changed, 14 insertions(+), 13 deletions(-)

diff --git a/README.md b/README.md
index f1e0009a79..ca99d59bb8 100644
--- a/README.md
+++ b/README.md
@@ -102,16 +102,17 @@ is more portable across Linux distributions.
 | `aarch64_be-linux-musl`    | OK             |
 | `arm-linux-gnueabi`        | [#101](https://github.com/ziglang/zig-bootstrap/issues/101) |
 | `arm-linux-gnueabihf`      | [#102](https://github.com/ziglang/zig-bootstrap/issues/102) |
-| `arm-linux-musleabi`       | [#103](https://github.com/ziglang/zig-bootstrap/issues/103) |
-| `arm-linux-musleabihf`     | [#183](https://github.com/ziglang/zig-bootstrap/issues/183) |
+| `arm-linux-musleabi`       | OK             |
+| `arm-linux-musleabihf`     | OK             |
 | `armeb-linux-gnueabi`      | [#96](https://github.com/ziglang/zig-bootstrap/issues/96) |
 | `armeb-linux-gnueabihf`    | [#97](https://github.com/ziglang/zig-bootstrap/issues/97) |
-| `armeb-linux-musleabi`     | [#98](https://github.com/ziglang/zig-bootstrap/issues/98) |
-| `armeb-linux-musleabihf`   | [#99](https://github.com/ziglang/zig-bootstrap/issues/99) |
+| `armeb-linux-musleabi`     | OK             |
+| `armeb-linux-musleabihf`   | OK             |
 | `loongarch64-linux-gnu`    | OK             |
+| `loongarch64-linux-gnusf`  | OK             |
 | `loongarch64-linux-musl`   | OK             |
-| `mips-linux-gnueabi`       | OK             |
-| `mips-linux-gnueabihf`     | OK             |
+| `mips-linux-gnueabi`       | [#195](https://github.com/ziglang/zig-bootstrap/issues/195) |
+| `mips-linux-gnueabihf`     | [#196](https://github.com/ziglang/zig-bootstrap/issues/196) |
 | `mips-linux-musleabi`      | OK             |
 | `mips-linux-musleabihf`    | OK             |
 | `mips64-linux-gnuabi64`    | OK             |
@@ -136,15 +137,15 @@ is more portable across Linux distributions.
 | `riscv32-linux-musl`       | OK             |
 | `riscv64-linux-gnu`        | OK             |
 | `riscv64-linux-musl`       | OK             |
-| `s390x-linux-gnu`          | [#116](https://github.com/ziglang/zig-bootstrap/issues/116) |
-| `s390x-linux-musl`         | [#52](https://github.com/ziglang/bootstrap/issues/52) |
+| `s390x-linux-gnu`          | OK             |
+| `s390x-linux-musl`         | OK             |
 | `sparc-linux-gnu`          | [#117](https://github.com/ziglang/zig-bootstrap/issues/117) |
 | `sparc64-linux-gnu`        | [#172](https://github.com/ziglang/zig-bootstrap/issues/172) |
-| `thumb-linux-musleabi`     | [#176](https://github.com/ziglang/zig-bootstrap/issues/176) |
-| `thumb-linux-musleabihf`   | [#175](https://github.com/ziglang/zig-bootstrap/issues/175) |
-| `thumb-windows-gnu`        | [#105](https://github.com/ziglang/zig-bootstrap/issues/105) |
-| `thumbeb-linux-musleabi`   | [#180](https://github.com/ziglang/zig-bootstrap/issues/180) |
-| `thumbeb-linux-musleabihf` | [#179](https://github.com/ziglang/zig-bootstrap/issues/179) |
+| `thumb-linux-musleabi`     | OK             |
+| `thumb-linux-musleabihf`   | OK             |
+| `thumb-windows-gnu`        | OK             |
+| `thumbeb-linux-musleabi`   | OK             |
+| `thumbeb-linux-musleabihf` | OK             |
 | `x86-linux-gnu`            | OK             |
 | `x86-linux-musl`           | OK             |
 | `x86-windows-gnu`          | OK             |