Merge branch 'llvm13'

18 files changed, 804 insertions, 732 deletions

diff --git a/src/Compilation.zig b/src/Compilation.zig
index 76a84701ce..95337de1e1 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -2725,7 +2725,7 @@ fn reportRetryableCObjectError(
 
     const c_obj_err_msg = try comp.gpa.create(CObject.ErrorMsg);
     errdefer comp.gpa.destroy(c_obj_err_msg);
-    const msg = try std.fmt.allocPrint(comp.gpa, "unable to build C object: {s}", .{@errorName(err)});
+    const msg = try std.fmt.allocPrint(comp.gpa, "{s}", .{@errorName(err)});
     errdefer comp.gpa.free(msg);
     c_obj_err_msg.* = .{
         .msg = msg,
@@ -2797,6 +2797,8 @@ fn updateCObject(comp: *Compilation, c_object: *CObject, c_obj_prog_node: *std.P
     const tracy = trace(@src());
     defer tracy.end();
 
+    log.debug("updating C object: {s}", .{c_object.src.src_path});
+
     if (c_object.clearStatus(comp.gpa)) {
         // There was previous failure.
         const lock = comp.mutex.acquire();
diff --git a/src/clang.zig b/src/clang.zig
index 1254a505f4..430c9093f2 100644
--- a/src/clang.zig
+++ b/src/clang.zig
@@ -1168,13 +1168,16 @@ const StmtClass = enum(c_int) {
     IndirectGotoStmtClass,
     MSDependentExistsStmtClass,
     NullStmtClass,
+    OMPCanonicalLoopClass,
     OMPAtomicDirectiveClass,
     OMPBarrierDirectiveClass,
     OMPCancelDirectiveClass,
     OMPCancellationPointDirectiveClass,
     OMPCriticalDirectiveClass,
     OMPDepobjDirectiveClass,
+    OMPDispatchDirectiveClass,
     OMPFlushDirectiveClass,
+    OMPInteropDirectiveClass,
     OMPDistributeDirectiveClass,
     OMPDistributeParallelForDirectiveClass,
     OMPDistributeParallelForSimdDirectiveClass,
@@ -1200,6 +1203,9 @@ const StmtClass = enum(c_int) {
     OMPTeamsDistributeParallelForDirectiveClass,
     OMPTeamsDistributeParallelForSimdDirectiveClass,
     OMPTeamsDistributeSimdDirectiveClass,
+    OMPTileDirectiveClass,
+    OMPUnrollDirectiveClass,
+    OMPMaskedDirectiveClass,
     OMPMasterDirectiveClass,
     OMPOrderedDirectiveClass,
     OMPParallelDirectiveClass,
@@ -1348,6 +1354,7 @@ const StmtClass = enum(c_int) {
     PseudoObjectExprClass,
     RecoveryExprClass,
     RequiresExprClass,
+    SYCLUniqueStableNameExprClass,
     ShuffleVectorExprClass,
     SizeOfPackExprClass,
     SourceLocExprClass,
@@ -1390,6 +1397,7 @@ pub const CK = enum(c_int) {
     PointerToIntegral,
     PointerToBoolean,
     ToVoid,
+    MatrixCast,
     VectorSplat,
     IntegralCast,
     IntegralToBoolean,
@@ -1445,6 +1453,8 @@ pub const DeclKind = enum(c_int) {
     Import,
     LifetimeExtendedTemporary,
     LinkageSpec,
+    Using,
+    UsingEnum,
     Label,
     Namespace,
     NamespaceAlias,
@@ -1473,7 +1483,7 @@ pub const DeclKind = enum(c_int) {
     TypeAlias,
     Typedef,
     UnresolvedUsingTypename,
-    Using,
+    UnresolvedUsingIfExists,
     UsingDirective,
     UsingPack,
     UsingShadow,
@@ -1615,6 +1625,72 @@ pub const BuiltinTypeKind = enum(c_int) {
     SveBool,
     VectorQuad,
     VectorPair,
+    RvvInt8mf8,
+    RvvInt8mf4,
+    RvvInt8mf2,
+    RvvInt8m1,
+    RvvInt8m2,
+    RvvInt8m4,
+    RvvInt8m8,
+    RvvUint8mf8,
+    RvvUint8mf4,
+    RvvUint8mf2,
+    RvvUint8m1,
+    RvvUint8m2,
+    RvvUint8m4,
+    RvvUint8m8,
+    RvvInt16mf4,
+    RvvInt16mf2,
+    RvvInt16m1,
+    RvvInt16m2,
+    RvvInt16m4,
+    RvvInt16m8,
+    RvvUint16mf4,
+    RvvUint16mf2,
+    RvvUint16m1,
+    RvvUint16m2,
+    RvvUint16m4,
+    RvvUint16m8,
+    RvvInt32mf2,
+    RvvInt32m1,
+    RvvInt32m2,
+    RvvInt32m4,
+    RvvInt32m8,
+    RvvUint32mf2,
+    RvvUint32m1,
+    RvvUint32m2,
+    RvvUint32m4,
+    RvvUint32m8,
+    RvvInt64m1,
+    RvvInt64m2,
+    RvvInt64m4,
+    RvvInt64m8,
+    RvvUint64m1,
+    RvvUint64m2,
+    RvvUint64m4,
+    RvvUint64m8,
+    RvvFloat16mf4,
+    RvvFloat16mf2,
+    RvvFloat16m1,
+    RvvFloat16m2,
+    RvvFloat16m4,
+    RvvFloat16m8,
+    RvvFloat32mf2,
+    RvvFloat32m1,
+    RvvFloat32m2,
+    RvvFloat32m4,
+    RvvFloat32m8,
+    RvvFloat64m1,
+    RvvFloat64m2,
+    RvvFloat64m4,
+    RvvFloat64m8,
+    RvvBool1,
+    RvvBool2,
+    RvvBool4,
+    RvvBool8,
+    RvvBool16,
+    RvvBool32,
+    RvvBool64,
     Void,
     Bool,
     Char_U,
@@ -1705,6 +1781,7 @@ pub const CallingConv = enum(c_int) {
     SpirFunction,
     OpenCLKernel,
     Swift,
+    SwiftAsync,
     PreserveMost,
     PreserveAll,
     AArch64VectorCall,
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index a1e9f47df4..d223569d0f 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -7,6 +7,7 @@ const link = @import("../link.zig");
 const log = std.log.scoped(.codegen);
 const math = std.math;
 
+const build_options = @import("build_options");
 const Module = @import("../Module.zig");
 const TypedValue = @import("../TypedValue.zig");
 const Zir = @import("../Zir.zig");
@@ -31,6 +32,7 @@ pub fn targetTriple(allocator: *Allocator, target: std.Target) ![:0]u8 {
         .bpfeb => "bpfeb",
         .csky => "csky",
         .hexagon => "hexagon",
+        .m68k => "m68k",
         .mips => "mips",
         .mipsel => "mipsel",
         .mips64 => "mips64",
@@ -140,6 +142,7 @@ pub fn targetTriple(allocator: *Allocator, target: std.Target) ![:0]u8 {
         .musl => "musl",
         .musleabi => "musleabi",
         .musleabihf => "musleabihf",
+        .muslx32 => "muslx32",
         .msvc => "msvc",
         .itanium => "itanium",
         .cygnus => "cygnus",
@@ -1902,6 +1905,7 @@ pub const FuncGen = struct {
             llvm.Bool.fromBool(is_volatile),
             .False,
             .ATT,
+            .False,
         );
         return self.builder.buildCall(
             asm_fn,
@@ -2552,15 +2556,15 @@ pub const FuncGen = struct {
                 new_value = self.builder.buildZExt(new_value, abi_ty, "");
             }
         }
-        const result = self.builder.buildCmpXchg(
+        const result = self.builder.buildAtomicCmpXchg(
             ptr,
             expected_value,
             new_value,
             toLlvmAtomicOrdering(extra.successOrder()),
             toLlvmAtomicOrdering(extra.failureOrder()),
-            is_weak,
-            self.single_threaded,
+            llvm.Bool.fromBool(self.single_threaded),
         );
+        result.setWeak(llvm.Bool.fromBool(is_weak));
 
         const optional_ty = self.air.typeOfIndex(inst);
 
@@ -2873,7 +2877,7 @@ fn initializeLLVMTarget(arch: std.Target.Cpu.Arch) void {
             llvm.LLVMInitializeAMDGPUAsmPrinter();
             llvm.LLVMInitializeAMDGPUAsmParser();
         },
-        .arm, .armeb => {
+        .thumb, .thumbeb, .arm, .armeb => {
             llvm.LLVMInitializeARMTarget();
             llvm.LLVMInitializeARMTargetInfo();
             llvm.LLVMInitializeARMTargetMC();
@@ -2976,25 +2980,66 @@ fn initializeLLVMTarget(arch: std.Target.Cpu.Arch) void {
             llvm.LLVMInitializeXCoreTargetInfo();
             llvm.LLVMInitializeXCoreTargetMC();
             llvm.LLVMInitializeXCoreAsmPrinter();
-            // There is no LLVMInitializeXCoreAsmParser function available.
+            // There is no LLVMInitializeXCoreAsmParser function.
+        },
+        .m68k => {
+            if (build_options.llvm_has_m68k) {
+                llvm.LLVMInitializeM68kTarget();
+                llvm.LLVMInitializeM68kTargetInfo();
+                llvm.LLVMInitializeM68kTargetMC();
+                llvm.LLVMInitializeM68kAsmPrinter();
+                llvm.LLVMInitializeM68kAsmParser();
+            }
+        },
+        .csky => {
+            if (build_options.llvm_has_csky) {
+                llvm.LLVMInitializeCSKYTarget();
+                llvm.LLVMInitializeCSKYTargetInfo();
+                llvm.LLVMInitializeCSKYTargetMC();
+                // There is no LLVMInitializeCSKYAsmPrinter function.
+                llvm.LLVMInitializeCSKYAsmParser();
+            }
         },
-        .arc => {},
-        .csky => {},
-        .r600 => {},
-        .tce, .tcele => {},
-        .thumb, .thumbeb => {},
-        .le32, .le64 => {},
-        .amdil, .amdil64 => {},
-        .hsail, .hsail64 => {},
-        .spir, .spir64 => {},
-        .kalimba => {},
-        .shave => {},
-        .renderscript32 => {},
-        .renderscript64 => {},
-        .ve => {},
-        .spu_2 => {},
-        .spirv32 => {},
-        .spirv64 => {},
+        .ve => {
+            if (build_options.llvm_has_ve) {
+                llvm.LLVMInitializeVETarget();
+                llvm.LLVMInitializeVETargetInfo();
+                llvm.LLVMInitializeVETargetMC();
+                llvm.LLVMInitializeVEAsmPrinter();
+                llvm.LLVMInitializeVEAsmParser();
+            }
+        },
+        .arc => {
+            if (build_options.llvm_has_arc) {
+                llvm.LLVMInitializeARCTarget();
+                llvm.LLVMInitializeARCTargetInfo();
+                llvm.LLVMInitializeARCTargetMC();
+                llvm.LLVMInitializeARCAsmPrinter();
+                // There is no LLVMInitializeARCAsmParser function.
+            }
+        },
+
+        // LLVM backends that have no initialization functions.
+        .tce,
+        .tcele,
+        .r600,
+        .le32,
+        .le64,
+        .amdil,
+        .amdil64,
+        .hsail,
+        .hsail64,
+        .shave,
+        .spir,
+        .spir64,
+        .kalimba,
+        .renderscript32,
+        .renderscript64,
+        => {},
+
+        .spu_2 => unreachable, // LLVM does not support this backend
+        .spirv32 => unreachable, // LLVM does not support this backend
+        .spirv64 => unreachable, // LLVM does not support this backend
     }
 }
 
diff --git a/src/codegen/llvm/bindings.zig b/src/codegen/llvm/bindings.zig
index 69845c0899..496579008e 100644
--- a/src/codegen/llvm/bindings.zig
+++ b/src/codegen/llvm/bindings.zig
@@ -137,6 +137,9 @@ pub const Value = opaque {
     pub const constIntToPtr = LLVMConstIntToPtr;
     extern fn LLVMConstIntToPtr(ConstantVal: *const Value, ToType: *const Type) *const Value;
 
+    pub const setWeak = LLVMSetWeak;
+    extern fn LLVMSetWeak(CmpXchgInst: *const Value, IsWeak: Bool) void;
+
     pub const setOrdering = LLVMSetOrdering;
     extern fn LLVMSetOrdering(MemoryAccessInst: *const Value, Ordering: AtomicOrdering) void;
 
@@ -308,6 +311,7 @@ extern fn LLVMGetInlineAsm(
     HasSideEffects: Bool,
     IsAlignStack: Bool,
     Dialect: InlineAsmDialect,
+    CanThrow: Bool,
 ) *const Value;
 
 pub const functionType = LLVMFunctionType;
@@ -589,16 +593,15 @@ pub const Builder = opaque {
         Name: [*:0]const u8,
     ) *const Value;
 
-    pub const buildCmpXchg = ZigLLVMBuildCmpXchg;
-    extern fn ZigLLVMBuildCmpXchg(
+    pub const buildAtomicCmpXchg = LLVMBuildAtomicCmpXchg;
+    extern fn LLVMBuildAtomicCmpXchg(
         builder: *const Builder,
         ptr: *const Value,
         cmp: *const Value,
         new_val: *const Value,
         success_ordering: AtomicOrdering,
         failure_ordering: AtomicOrdering,
-        is_weak: bool,
-        is_single_threaded: bool,
+        is_single_threaded: Bool,
     ) *const Value;
 
     pub const buildSelect = LLVMBuildSelect;
@@ -842,6 +845,10 @@ pub extern fn LLVMInitializeSystemZTargetInfo() void;
 pub extern fn LLVMInitializeWebAssemblyTargetInfo() void;
 pub extern fn LLVMInitializeX86TargetInfo() void;
 pub extern fn LLVMInitializeXCoreTargetInfo() void;
+pub extern fn LLVMInitializeM68kTargetInfo() void;
+pub extern fn LLVMInitializeCSKYTargetInfo() void;
+pub extern fn LLVMInitializeVETargetInfo() void;
+pub extern fn LLVMInitializeARCTargetInfo() void;
 
 pub extern fn LLVMInitializeAArch64Target() void;
 pub extern fn LLVMInitializeAMDGPUTarget() void;
@@ -860,6 +867,10 @@ pub extern fn LLVMInitializeSystemZTarget() void;
 pub extern fn LLVMInitializeWebAssemblyTarget() void;
 pub extern fn LLVMInitializeX86Target() void;
 pub extern fn LLVMInitializeXCoreTarget() void;
+pub extern fn LLVMInitializeM68kTarget() void;
+pub extern fn LLVMInitializeVETarget() void;
+pub extern fn LLVMInitializeCSKYTarget() void;
+pub extern fn LLVMInitializeARCTarget() void;
 
 pub extern fn LLVMInitializeAArch64TargetMC() void;
 pub extern fn LLVMInitializeAMDGPUTargetMC() void;
@@ -878,6 +889,10 @@ pub extern fn LLVMInitializeSystemZTargetMC() void;
 pub extern fn LLVMInitializeWebAssemblyTargetMC() void;
 pub extern fn LLVMInitializeX86TargetMC() void;
 pub extern fn LLVMInitializeXCoreTargetMC() void;
+pub extern fn LLVMInitializeM68kTargetMC() void;
+pub extern fn LLVMInitializeCSKYTargetMC() void;
+pub extern fn LLVMInitializeVETargetMC() void;
+pub extern fn LLVMInitializeARCTargetMC() void;
 
 pub extern fn LLVMInitializeAArch64AsmPrinter() void;
 pub extern fn LLVMInitializeAMDGPUAsmPrinter() void;
@@ -896,6 +911,9 @@ pub extern fn LLVMInitializeSystemZAsmPrinter() void;
 pub extern fn LLVMInitializeWebAssemblyAsmPrinter() void;
 pub extern fn LLVMInitializeX86AsmPrinter() void;
 pub extern fn LLVMInitializeXCoreAsmPrinter() void;
+pub extern fn LLVMInitializeM68kAsmPrinter() void;
+pub extern fn LLVMInitializeVEAsmPrinter() void;
+pub extern fn LLVMInitializeARCAsmPrinter() void;
 
 pub extern fn LLVMInitializeAArch64AsmParser() void;
 pub extern fn LLVMInitializeAMDGPUAsmParser() void;
@@ -912,6 +930,9 @@ pub extern fn LLVMInitializeSparcAsmParser() void;
 pub extern fn LLVMInitializeSystemZAsmParser() void;
 pub extern fn LLVMInitializeWebAssemblyAsmParser() void;
 pub extern fn LLVMInitializeX86AsmParser() void;
+pub extern fn LLVMInitializeM68kAsmParser() void;
+pub extern fn LLVMInitializeCSKYAsmParser() void;
+pub extern fn LLVMInitializeVEAsmParser() void;
 
 extern fn ZigLLDLinkCOFF(argc: c_int, argv: [*:null]const ?[*:0]const u8, can_exit_early: bool) c_int;
 extern fn ZigLLDLinkELF(argc: c_int, argv: [*:null]const ?[*:0]const u8, can_exit_early: bool) c_int;
@@ -991,6 +1012,7 @@ pub const ArchType = enum(c_int) {
     bpfeb,
     csky,
     hexagon,
+    m68k,
     mips,
     mipsel,
     mips64,
diff --git a/src/config.zig.in b/src/config.zig.in
index 1bd1b35505..62e8785ccb 100644
--- a/src/config.zig.in
+++ b/src/config.zig.in
@@ -1,4 +1,8 @@
 pub const have_llvm = true;
+pub const llvm_has_m68k = false;
+pub const llvm_has_csky = false;
+pub const llvm_has_ve = false;
+pub const llvm_has_arc = false;
 pub const version: [:0]const u8 = "@ZIG_VERSION@";
 pub const semver = @import("std").SemanticVersion.parse(version) catch unreachable;
 pub const enable_logging: bool = @ZIG_ENABLE_LOGGING_BOOL@;
diff --git a/src/libcxx.zig b/src/libcxx.zig
index 5ba6e47ece..2cff5d738a 100644
--- a/src/libcxx.zig
+++ b/src/libcxx.zig
@@ -45,6 +45,7 @@ const libcxx_files = [_][]const u8{
     "src/filesystem/directory_iterator.cpp",
     "src/filesystem/int128_builtins.cpp",
     "src/filesystem/operations.cpp",
+    "src/format.cpp",
     "src/functional.cpp",
     "src/future.cpp",
     "src/hash.cpp",
@@ -64,6 +65,7 @@ const libcxx_files = [_][]const u8{
     "src/stdexcept.cpp",
     "src/string.cpp",
     "src/strstream.cpp",
+    "src/support/ibm/xlocale_zos.cpp",
     "src/support/solaris/xlocale.cpp",
     "src/support/win32/locale_win32.cpp",
     "src/support/win32/support.cpp",
@@ -119,10 +121,12 @@ pub fn buildLibCXX(comp: *Compilation) !void {
                 continue;
         }
 
-        if (target.os.tag != .windows) {
-            if (std.mem.startsWith(u8, cxx_src, "src/support/win32/"))
-                continue;
-        }
+        if (std.mem.startsWith(u8, cxx_src, "src/support/win32/") and target.os.tag != .windows)
+            continue;
+        if (std.mem.startsWith(u8, cxx_src, "src/support/solaris/") and target.os.tag != .solaris)
+            continue;
+        if (std.mem.startsWith(u8, cxx_src, "src/support/ibm/") and target.os.tag != .zos)
+            continue;
 
         try cflags.append("-DNDEBUG");
         try cflags.append("-D_LIBCPP_BUILDING_LIBRARY");
@@ -144,6 +148,12 @@ pub fn buildLibCXX(comp: *Compilation) !void {
             try cflags.append("-fno-exceptions");
         }
 
+        if (target.os.tag == .zos) {
+            try cflags.append("-fno-aligned-allocation");
+        } else {
+            try cflags.append("-faligned-allocation");
+        }
+
         try cflags.append("-I");
         try cflags.append(cxx_include_path);
 
@@ -154,7 +164,7 @@ pub fn buildLibCXX(comp: *Compilation) !void {
             try cflags.append("-fPIC");
         }
         try cflags.append("-nostdinc++");
-        try cflags.append("-std=c++14");
+        try cflags.append("-std=c++20");
         try cflags.append("-Wno-user-defined-literals");
 
         c_source_files.appendAssumeCapacity(.{
diff --git a/src/libtsan.zig b/src/libtsan.zig
index 2f288df9c2..57f1f8c78e 100644
--- a/src/libtsan.zig
+++ b/src/libtsan.zig
@@ -260,7 +260,6 @@ const tsan_sources = [_][]const u8{
     "tsan_malloc_mac.cpp",
     "tsan_md5.cpp",
     "tsan_mman.cpp",
-    "tsan_mutex.cpp",
     "tsan_mutexset.cpp",
     "tsan_preinit.cpp",
     "tsan_report.cpp",
@@ -270,7 +269,6 @@ const tsan_sources = [_][]const u8{
     "tsan_rtl_report.cpp",
     "tsan_rtl_thread.cpp",
     "tsan_stack_trace.cpp",
-    "tsan_stat.cpp",
     "tsan_suppressions.cpp",
     "tsan_symbolize.cpp",
     "tsan_sync.cpp",
@@ -295,14 +293,15 @@ const sanitizer_common_sources = [_][]const u8{
     "sanitizer_deadlock_detector2.cpp",
     "sanitizer_errno.cpp",
     "sanitizer_file.cpp",
-    "sanitizer_flags.cpp",
     "sanitizer_flag_parser.cpp",
+    "sanitizer_flags.cpp",
     "sanitizer_fuchsia.cpp",
     "sanitizer_libc.cpp",
     "sanitizer_libignore.cpp",
     "sanitizer_linux.cpp",
     "sanitizer_linux_s390.cpp",
     "sanitizer_mac.cpp",
+    "sanitizer_mutex.cpp",
     "sanitizer_netbsd.cpp",
     "sanitizer_openbsd.cpp",
     "sanitizer_persistent_allocator.cpp",
@@ -314,20 +313,19 @@ const sanitizer_common_sources = [_][]const u8{
     "sanitizer_platform_limits_solaris.cpp",
     "sanitizer_posix.cpp",
     "sanitizer_printf.cpp",
-    "sanitizer_procmaps_common.cpp",
     "sanitizer_procmaps_bsd.cpp",
+    "sanitizer_procmaps_common.cpp",
     "sanitizer_procmaps_fuchsia.cpp",
     "sanitizer_procmaps_linux.cpp",
     "sanitizer_procmaps_mac.cpp",
     "sanitizer_procmaps_solaris.cpp",
-    "sanitizer_rtems.cpp",
     "sanitizer_solaris.cpp",
     "sanitizer_stoptheworld_fuchsia.cpp",
     "sanitizer_stoptheworld_mac.cpp",
     "sanitizer_suppressions.cpp",
     "sanitizer_termination.cpp",
-    "sanitizer_tls_get_addr.cpp",
     "sanitizer_thread_registry.cpp",
+    "sanitizer_tls_get_addr.cpp",
     "sanitizer_type_traits.cpp",
     "sanitizer_win.cpp",
 };
diff --git a/src/stage1/codegen.cpp b/src/stage1/codegen.cpp
index a0f130b79e..a3f87c9f5a 100644
--- a/src/stage1/codegen.cpp
+++ b/src/stage1/codegen.cpp
@@ -3869,14 +3869,10 @@ static LLVMValueRef ir_render_load_ptr(CodeGen *g, Stage1Air *executable,
     LLVMValueRef shift_amt_val = LLVMConstInt(LLVMTypeOf(containing_int), shift_amt, false);
     LLVMValueRef shifted_value = LLVMBuildLShr(g->builder, containing_int, shift_amt_val, "");
 
-    LLVMTypeRef same_size_int = LLVMIntType(size_in_bits);
-    LLVMValueRef mask = LLVMConstAllOnes(LLVMIntType(size_in_bits));
-    mask = LLVMConstZExt(mask, LLVMTypeOf(containing_int));
-    LLVMValueRef masked_value = LLVMBuildAnd(g->builder, shifted_value, mask, "");
-
     if (handle_is_ptr(g, child_type)) {
         LLVMValueRef result_loc = ir_llvm_value(g, instruction->result_loc);
-        LLVMValueRef truncated_int = LLVMBuildTrunc(g->builder, masked_value, same_size_int, "");
+        LLVMTypeRef same_size_int = LLVMIntType(size_in_bits);
+        LLVMValueRef truncated_int = LLVMBuildTrunc(g->builder, shifted_value, same_size_int, "");
         LLVMValueRef bitcasted_ptr = LLVMBuildBitCast(g->builder, result_loc,
                                                       LLVMPointerType(same_size_int, 0), "");
         LLVMBuildStore(g->builder, truncated_int, bitcasted_ptr);
@@ -3884,11 +3880,12 @@ static LLVMValueRef ir_render_load_ptr(CodeGen *g, Stage1Air *executable,
     }
 
     if (child_type->id == ZigTypeIdFloat) {
-        LLVMValueRef truncated_int = LLVMBuildTrunc(g->builder, masked_value, same_size_int, "");
+        LLVMTypeRef same_size_int = LLVMIntType(size_in_bits);
+        LLVMValueRef truncated_int = LLVMBuildTrunc(g->builder, shifted_value, same_size_int, "");
         return LLVMBuildBitCast(g->builder, truncated_int, get_llvm_type(g, child_type), "");
     }
 
-    return LLVMBuildTrunc(g->builder, masked_value, get_llvm_type(g, child_type), "");
+    return LLVMBuildTrunc(g->builder, shifted_value, get_llvm_type(g, child_type), "");
 }
 
 static bool value_is_all_undef_array(CodeGen *g, ZigValue *const_val, size_t len) {
@@ -3994,7 +3991,7 @@ static LLVMValueRef gen_valgrind_client_request(CodeGen *g, LLVMValueRef default
                     input_and_output_count, false);
             LLVMValueRef asm_fn = LLVMGetInlineAsm(function_type, buf_ptr(asm_template), buf_len(asm_template),
                     buf_ptr(asm_constraints), buf_len(asm_constraints), asm_has_side_effects, asm_is_alignstack,
-                    LLVMInlineAsmDialectATT);
+                    LLVMInlineAsmDialectATT, false);
             return LLVMBuildCall(g->builder, asm_fn, param_values, input_and_output_count, "");
         }
     }
@@ -5105,7 +5102,7 @@ static LLVMValueRef ir_render_asm_gen(CodeGen *g, Stage1Air *executable, Stage1A
 
     bool is_volatile = instruction->has_side_effects || (asm_expr->output_list.length == 0);
     LLVMValueRef asm_fn = LLVMGetInlineAsm(function_type, buf_ptr(&llvm_template), buf_len(&llvm_template),
-            buf_ptr(&constraint_buf), buf_len(&constraint_buf), is_volatile, false, LLVMInlineAsmDialectATT);
+            buf_ptr(&constraint_buf), buf_len(&constraint_buf), is_volatile, false, LLVMInlineAsmDialectATT, false);
 
     LLVMValueRef built_call = LLVMBuildCall(g->builder, asm_fn, param_values, (unsigned)input_and_output_count, "");
     heap::c_allocator.deallocate(param_values, input_and_output_count);
@@ -5647,21 +5644,21 @@ static LLVMAtomicOrdering to_LLVMAtomicOrdering(AtomicOrder atomic_order) {
     zig_unreachable();
 }
 
-static enum ZigLLVM_AtomicRMWBinOp to_ZigLLVMAtomicRMWBinOp(AtomicRmwOp op, bool is_signed, bool is_float) {
+static LLVMAtomicRMWBinOp to_LLVMAtomicRMWBinOp(AtomicRmwOp op, bool is_signed, bool is_float) {
     switch (op) {
-        case AtomicRmwOp_xchg: return ZigLLVMAtomicRMWBinOpXchg;
+        case AtomicRmwOp_xchg: return LLVMAtomicRMWBinOpXchg;
         case AtomicRmwOp_add:
-            return is_float ? ZigLLVMAtomicRMWBinOpFAdd : ZigLLVMAtomicRMWBinOpAdd;
+            return is_float ? LLVMAtomicRMWBinOpFAdd : LLVMAtomicRMWBinOpAdd;
         case AtomicRmwOp_sub:
-            return is_float ? ZigLLVMAtomicRMWBinOpFSub : ZigLLVMAtomicRMWBinOpSub;
-        case AtomicRmwOp_and: return ZigLLVMAtomicRMWBinOpAnd;
-        case AtomicRmwOp_nand: return ZigLLVMAtomicRMWBinOpNand;
-        case AtomicRmwOp_or: return ZigLLVMAtomicRMWBinOpOr;
-        case AtomicRmwOp_xor: return ZigLLVMAtomicRMWBinOpXor;
+            return is_float ? LLVMAtomicRMWBinOpFSub : LLVMAtomicRMWBinOpSub;
+        case AtomicRmwOp_and: return LLVMAtomicRMWBinOpAnd;
+        case AtomicRmwOp_nand: return LLVMAtomicRMWBinOpNand;
+        case AtomicRmwOp_or: return LLVMAtomicRMWBinOpOr;
+        case AtomicRmwOp_xor: return LLVMAtomicRMWBinOpXor;
         case AtomicRmwOp_max:
-            return is_signed ? ZigLLVMAtomicRMWBinOpMax : ZigLLVMAtomicRMWBinOpUMax;
+            return is_signed ? LLVMAtomicRMWBinOpMax : LLVMAtomicRMWBinOpUMax;
         case AtomicRmwOp_min:
-            return is_signed ? ZigLLVMAtomicRMWBinOpMin : ZigLLVMAtomicRMWBinOpUMin;
+            return is_signed ? LLVMAtomicRMWBinOpMin : LLVMAtomicRMWBinOpUMin;
     }
     zig_unreachable();
 }
@@ -5720,8 +5717,9 @@ static LLVMValueRef ir_render_cmpxchg(CodeGen *g, Stage1Air *executable, Stage1A
     LLVMAtomicOrdering success_order = to_LLVMAtomicOrdering(instruction->success_order);
     LLVMAtomicOrdering failure_order = to_LLVMAtomicOrdering(instruction->failure_order);
 
-    LLVMValueRef result_val = ZigLLVMBuildCmpXchg(g->builder, ptr_val, cmp_val, new_val,
-            success_order, failure_order, instruction->is_weak, g->is_single_threaded);
+    LLVMValueRef result_val = LLVMBuildAtomicCmpXchg(g->builder, ptr_val, cmp_val, new_val,
+            success_order, failure_order, g->is_single_threaded);
+    LLVMSetWeak(result_val, instruction->is_weak);
 
     ZigType *optional_type = instruction->base.value->type;
     assert(optional_type->id == ZigTypeIdOptional);
@@ -6487,13 +6485,13 @@ static LLVMValueRef ir_render_atomic_rmw(CodeGen *g, Stage1Air *executable,
     } else {
         is_signed = false;
     }
-    enum ZigLLVM_AtomicRMWBinOp op = to_ZigLLVMAtomicRMWBinOp(instruction->op, is_signed, is_float);
+    LLVMAtomicRMWBinOp op = to_LLVMAtomicRMWBinOp(instruction->op, is_signed, is_float);
     LLVMAtomicOrdering ordering = to_LLVMAtomicOrdering(instruction->ordering);
     LLVMValueRef ptr = ir_llvm_value(g, instruction->ptr);
     LLVMValueRef operand = ir_llvm_value(g, instruction->operand);
 
     LLVMTypeRef actual_abi_type = get_atomic_abi_type(g, instruction->ptr,
-            op == ZigLLVMAtomicRMWBinOpXchg);
+            op == LLVMAtomicRMWBinOpXchg);
     if (actual_abi_type != nullptr) {
         // operand needs widening and truncating or bitcasting.
         LLVMValueRef casted_ptr = LLVMBuildBitCast(g->builder, ptr,
@@ -6506,7 +6504,7 @@ static LLVMValueRef ir_render_atomic_rmw(CodeGen *g, Stage1Air *executable,
         } else {
             casted_operand = LLVMBuildZExt(g->builder, operand, actual_abi_type, "");
         }
-        LLVMValueRef uncasted_result = ZigLLVMBuildAtomicRMW(g->builder, op, casted_ptr, casted_operand, ordering,
+        LLVMValueRef uncasted_result = LLVMBuildAtomicRMW(g->builder, op, casted_ptr, casted_operand, ordering,
                 g->is_single_threaded);
         if (is_float) {
             return LLVMBuildBitCast(g->builder, uncasted_result, get_llvm_type(g, operand_type), "");
@@ -6516,14 +6514,14 @@ static LLVMValueRef ir_render_atomic_rmw(CodeGen *g, Stage1Air *executable,
     }
 
     if (get_codegen_ptr_type_bail(g, operand_type) == nullptr) {
-        return ZigLLVMBuildAtomicRMW(g->builder, op, ptr, operand, ordering, g->is_single_threaded);
+        return LLVMBuildAtomicRMW(g->builder, op, ptr, operand, ordering, g->is_single_threaded);
     }
 
     // it's a pointer but we need to treat it as an int
     LLVMValueRef casted_ptr = LLVMBuildBitCast(g->builder, ptr,
         LLVMPointerType(g->builtin_types.entry_usize->llvm_type, 0), "");
     LLVMValueRef casted_operand = LLVMBuildPtrToInt(g->builder, operand, g->builtin_types.entry_usize->llvm_type, "");
-    LLVMValueRef uncasted_result = ZigLLVMBuildAtomicRMW(g->builder, op, casted_ptr, casted_operand, ordering,
+    LLVMValueRef uncasted_result = LLVMBuildAtomicRMW(g->builder, op, casted_ptr, casted_operand, ordering,
             g->is_single_threaded);
     return LLVMBuildIntToPtr(g->builder, uncasted_result, get_llvm_type(g, operand_type), "");
 }
diff --git a/src/stage1/target.cpp b/src/stage1/target.cpp
index 4da19e4c36..eca468e5c0 100644
--- a/src/stage1/target.cpp
+++ b/src/stage1/target.cpp
@@ -25,6 +25,7 @@ static const ZigLLVM_ArchType arch_list[] = {
     ZigLLVM_bpfeb,          // eBPF or extended BPF or 64-bit BPF (big endian)
     ZigLLVM_csky,           // CSKY: csky
     ZigLLVM_hexagon,        // Hexagon: hexagon
+    ZigLLVM_m68k,           // M68k: Motorola 680x0 family
     ZigLLVM_mips,           // MIPS: mips, mipsallegrex, mipsr6
     ZigLLVM_mipsel,         // MIPSEL: mipsel, mipsallegrexe, mipsr6el
     ZigLLVM_mips64,         // MIPS64: mips64, mips64r6, mipsn32, mipsn32r6
@@ -147,6 +148,7 @@ static const ZigLLVM_EnvironmentType abi_list[] = {
     ZigLLVM_Musl,
     ZigLLVM_MuslEABI,
     ZigLLVM_MuslEABIHF,
+    ZigLLVM_MuslX32,
 
     ZigLLVM_MSVC,
     ZigLLVM_Itanium,
@@ -500,6 +502,7 @@ uint32_t target_arch_pointer_bit_width(ZigLLVM_ArchType arch) {
         case ZigLLVM_arm:
         case ZigLLVM_armeb:
         case ZigLLVM_hexagon:
+        case ZigLLVM_m68k:
         case ZigLLVM_le32:
         case ZigLLVM_mips:
         case ZigLLVM_mipsel:
@@ -567,6 +570,7 @@ uint32_t target_arch_largest_atomic_bits(ZigLLVM_ArchType arch) {
         case ZigLLVM_arm:
         case ZigLLVM_armeb:
         case ZigLLVM_hexagon:
+        case ZigLLVM_m68k:
         case ZigLLVM_le32:
         case ZigLLVM_mips:
         case ZigLLVM_mipsel:
@@ -801,6 +805,8 @@ const char *arch_stack_pointer_register_name(ZigLLVM_ArchType arch) {
         case ZigLLVM_aarch64_32:
         case ZigLLVM_riscv32:
         case ZigLLVM_riscv64:
+        case ZigLLVM_m68k:
+        case ZigLLVM_mips:
         case ZigLLVM_mipsel:
         case ZigLLVM_ppc:
         case ZigLLVM_ppcle:
@@ -827,7 +833,6 @@ const char *arch_stack_pointer_register_name(ZigLLVM_ArchType arch) {
         case ZigLLVM_kalimba:
         case ZigLLVM_le32:
         case ZigLLVM_le64:
-        case ZigLLVM_mips:
         case ZigLLVM_mips64:
         case ZigLLVM_mips64el:
         case ZigLLVM_msp430:
@@ -876,6 +881,7 @@ bool target_is_arm(const ZigTarget *target) {
         case ZigLLVM_bpfel:
         case ZigLLVM_csky:
         case ZigLLVM_hexagon:
+        case ZigLLVM_m68k:
         case ZigLLVM_lanai:
         case ZigLLVM_hsail:
         case ZigLLVM_hsail64:
diff --git a/src/target.zig b/src/target.zig
index 621335209c..6b6ed2fbc5 100644
--- a/src/target.zig
+++ b/src/target.zig
@@ -34,6 +34,8 @@ pub const available_libcs = [_]ArchOsAbi{
     .{ .arch = .i386, .os = .linux, .abi = .gnu },
     .{ .arch = .i386, .os = .linux, .abi = .musl },
     .{ .arch = .i386, .os = .windows, .abi = .gnu },
+    .{ .arch = .m68k, .os = .linux, .abi = .gnu },
+    .{ .arch = .m68k, .os = .linux, .abi = .musl },
     .{ .arch = .mips64el, .os = .linux, .abi = .gnuabi64 },
     .{ .arch = .mips64el, .os = .linux, .abi = .gnuabin32 },
     .{ .arch = .mips64el, .os = .linux, .abi = .musl },
@@ -83,6 +85,7 @@ pub fn libCGenericName(target: std.Target) [:0]const u8 {
         .musl,
         .musleabi,
         .musleabihf,
+        .muslx32,
         .none,
         => return "musl",
         .code16,
@@ -186,6 +189,7 @@ pub fn hasLlvmSupport(target: std.Target) bool {
         .bpfeb,
         .csky,
         .hexagon,
+        .m68k,
         .mips,
         .mipsel,
         .mips64,
@@ -295,6 +299,7 @@ pub fn archToLLVM(arch_tag: std.Target.Cpu.Arch) llvm.ArchType {
         .bpfeb => .bpfeb,
         .csky => .csky,
         .hexagon => .hexagon,
+        .m68k => .m68k,
         .mips => .mips,
         .mipsel => .mipsel,
         .mips64 => .mips64,
@@ -496,6 +501,7 @@ pub fn largestAtomicBits(target: std.Target) u32 {
         .arm,
         .armeb,
         .hexagon,
+        .m68k,
         .le32,
         .mips,
         .mipsel,
diff --git a/src/zig_clang.cpp b/src/zig_clang.cpp
index 685ee8bcce..f5b04ddd9d 100644
--- a/src/zig_clang.cpp
+++ b/src/zig_clang.cpp
@@ -164,6 +164,10 @@ void ZigClang_detect_enum_CK(clang::CastKind x) {
         case clang::CK_DerivedToBase:
         case clang::CK_DerivedToBaseMemberPointer:
         case clang::CK_Dynamic:
+        case clang::CK_FixedPointCast:
+        case clang::CK_FixedPointToBoolean:
+        case clang::CK_FixedPointToFloating:
+        case clang::CK_FixedPointToIntegral:
         case clang::CK_FloatingCast:
         case clang::CK_FloatingComplexCast:
         case clang::CK_FloatingComplexToBoolean:
@@ -171,6 +175,7 @@ void ZigClang_detect_enum_CK(clang::CastKind x) {
         case clang::CK_FloatingComplexToReal:
         case clang::CK_FloatingRealToComplex:
         case clang::CK_FloatingToBoolean:
+        case clang::CK_FloatingToFixedPoint:
         case clang::CK_FloatingToIntegral:
         case clang::CK_FunctionToPointerDecay:
         case clang::CK_IntToOCLSampler:
@@ -181,13 +186,13 @@ void ZigClang_detect_enum_CK(clang::CastKind x) {
         case clang::CK_IntegralComplexToReal:
         case clang::CK_IntegralRealToComplex:
         case clang::CK_IntegralToBoolean:
+        case clang::CK_IntegralToFixedPoint:
         case clang::CK_IntegralToFloating:
         case clang::CK_IntegralToPointer:
-        case clang::CK_FloatingToFixedPoint:
-        case clang::CK_FixedPointToFloating:
         case clang::CK_LValueBitCast:
-        case clang::CK_LValueToRValueBitCast:
         case clang::CK_LValueToRValue:
+        case clang::CK_LValueToRValueBitCast:
+        case clang::CK_MatrixCast:
         case clang::CK_MemberPointerToBoolean:
         case clang::CK_NoOp:
         case clang::CK_NonAtomicToAtomic:
@@ -203,10 +208,6 @@ void ZigClang_detect_enum_CK(clang::CastKind x) {
         case clang::CK_UserDefinedConversion:
         case clang::CK_VectorSplat:
         case clang::CK_ZeroToOCLOpaqueType:
-        case clang::CK_FixedPointCast:
-        case clang::CK_FixedPointToIntegral:
-        case clang::CK_IntegralToFixedPoint:
-        case clang::CK_FixedPointToBoolean:
             break;
     }
 };
@@ -236,6 +237,7 @@ static_assert((clang::CastKind)ZigClangCK_IntegralToPointer == clang::CK_Integra
 static_assert((clang::CastKind)ZigClangCK_PointerToIntegral == clang::CK_PointerToIntegral, "");
 static_assert((clang::CastKind)ZigClangCK_PointerToBoolean == clang::CK_PointerToBoolean, "");
 static_assert((clang::CastKind)ZigClangCK_ToVoid == clang::CK_ToVoid, "");
+static_assert((clang::CastKind)ZigClangCK_MatrixCast == clang::CK_MatrixCast, "");
 static_assert((clang::CastKind)ZigClangCK_VectorSplat == clang::CK_VectorSplat, "");
 static_assert((clang::CastKind)ZigClangCK_IntegralCast == clang::CK_IntegralCast, "");
 static_assert((clang::CastKind)ZigClangCK_IntegralToBoolean == clang::CK_IntegralToBoolean, "");
@@ -390,221 +392,228 @@ static_assert((clang::Type::TypeClass)ZigClangType_ExtVector == clang::Type::Ext
 
 // Detect additions to the enum
 void ZigClang_detect_enum_StmtClass(clang::Stmt::StmtClass x) {
-    switch (static_cast<ZigClangStmtClass>(x)) {
-        case ZigClangStmt_NoStmtClass:
-        case ZigClangStmt_GCCAsmStmtClass:
-        case ZigClangStmt_MSAsmStmtClass:
-        case ZigClangStmt_BreakStmtClass:
-        case ZigClangStmt_CXXCatchStmtClass:
-        case ZigClangStmt_CXXForRangeStmtClass:
-        case ZigClangStmt_CXXTryStmtClass:
-        case ZigClangStmt_CapturedStmtClass:
-        case ZigClangStmt_CompoundStmtClass:
-        case ZigClangStmt_ContinueStmtClass:
-        case ZigClangStmt_CoreturnStmtClass:
-        case ZigClangStmt_CoroutineBodyStmtClass:
-        case ZigClangStmt_DeclStmtClass:
-        case ZigClangStmt_DoStmtClass:
-        case ZigClangStmt_ForStmtClass:
-        case ZigClangStmt_GotoStmtClass:
-        case ZigClangStmt_IfStmtClass:
-        case ZigClangStmt_IndirectGotoStmtClass:
-        case ZigClangStmt_MSDependentExistsStmtClass:
-        case ZigClangStmt_NullStmtClass:
-        case ZigClangStmt_OMPAtomicDirectiveClass:
-        case ZigClangStmt_OMPBarrierDirectiveClass:
-        case ZigClangStmt_OMPCancelDirectiveClass:
-        case ZigClangStmt_OMPCancellationPointDirectiveClass:
-        case ZigClangStmt_OMPCriticalDirectiveClass:
-        case ZigClangStmt_OMPDepobjDirectiveClass:
-        case ZigClangStmt_OMPFlushDirectiveClass:
-        case ZigClangStmt_OMPDistributeDirectiveClass:
-        case ZigClangStmt_OMPDistributeParallelForDirectiveClass:
-        case ZigClangStmt_OMPDistributeParallelForSimdDirectiveClass:
-        case ZigClangStmt_OMPDistributeSimdDirectiveClass:
-        case ZigClangStmt_OMPForDirectiveClass:
-        case ZigClangStmt_OMPForSimdDirectiveClass:
-        case ZigClangStmt_OMPMasterTaskLoopDirectiveClass:
-        case ZigClangStmt_OMPMasterTaskLoopSimdDirectiveClass:
-        case ZigClangStmt_OMPParallelForDirectiveClass:
-        case ZigClangStmt_OMPParallelForSimdDirectiveClass:
-        case ZigClangStmt_OMPParallelMasterTaskLoopDirectiveClass:
-        case ZigClangStmt_OMPParallelMasterTaskLoopSimdDirectiveClass:
-        case ZigClangStmt_OMPSimdDirectiveClass:
-        case ZigClangStmt_OMPTargetParallelForSimdDirectiveClass:
-        case ZigClangStmt_OMPTargetSimdDirectiveClass:
-        case ZigClangStmt_OMPTargetTeamsDistributeDirectiveClass:
-        case ZigClangStmt_OMPTargetTeamsDistributeParallelForDirectiveClass:
-        case ZigClangStmt_OMPTargetTeamsDistributeParallelForSimdDirectiveClass:
-        case ZigClangStmt_OMPTargetTeamsDistributeSimdDirectiveClass:
-        case ZigClangStmt_OMPTaskLoopDirectiveClass:
-        case ZigClangStmt_OMPTaskLoopSimdDirectiveClass:
-        case ZigClangStmt_OMPTeamsDistributeDirectiveClass:
-        case ZigClangStmt_OMPTeamsDistributeParallelForDirectiveClass:
-        case ZigClangStmt_OMPTeamsDistributeParallelForSimdDirectiveClass:
-        case ZigClangStmt_OMPTeamsDistributeSimdDirectiveClass:
-        case ZigClangStmt_OMPMasterDirectiveClass:
-        case ZigClangStmt_OMPOrderedDirectiveClass:
-        case ZigClangStmt_OMPParallelDirectiveClass:
-        case ZigClangStmt_OMPParallelMasterDirectiveClass:
-        case ZigClangStmt_OMPParallelSectionsDirectiveClass:
-        case ZigClangStmt_OMPScanDirectiveClass:
-        case ZigClangStmt_OMPSectionDirectiveClass:
-        case ZigClangStmt_OMPSectionsDirectiveClass:
-        case ZigClangStmt_OMPSingleDirectiveClass:
-        case ZigClangStmt_OMPTargetDataDirectiveClass:
-        case ZigClangStmt_OMPTargetDirectiveClass:
-        case ZigClangStmt_OMPTargetEnterDataDirectiveClass:
-        case ZigClangStmt_OMPTargetExitDataDirectiveClass:
-        case ZigClangStmt_OMPTargetParallelDirectiveClass:
-        case ZigClangStmt_OMPTargetParallelForDirectiveClass:
-        case ZigClangStmt_OMPTargetTeamsDirectiveClass:
-        case ZigClangStmt_OMPTargetUpdateDirectiveClass:
-        case ZigClangStmt_OMPTaskDirectiveClass:
-        case ZigClangStmt_OMPTaskgroupDirectiveClass:
-        case ZigClangStmt_OMPTaskwaitDirectiveClass:
-        case ZigClangStmt_OMPTaskyieldDirectiveClass:
-        case ZigClangStmt_OMPTeamsDirectiveClass:
-        case ZigClangStmt_ObjCAtCatchStmtClass:
-        case ZigClangStmt_ObjCAtFinallyStmtClass:
-        case ZigClangStmt_ObjCAtSynchronizedStmtClass:
-        case ZigClangStmt_ObjCAtThrowStmtClass:
-        case ZigClangStmt_ObjCAtTryStmtClass:
-        case ZigClangStmt_ObjCAutoreleasePoolStmtClass:
-        case ZigClangStmt_ObjCForCollectionStmtClass:
-        case ZigClangStmt_ReturnStmtClass:
-        case ZigClangStmt_SEHExceptStmtClass:
-        case ZigClangStmt_SEHFinallyStmtClass:
-        case ZigClangStmt_SEHLeaveStmtClass:
-        case ZigClangStmt_SEHTryStmtClass:
-        case ZigClangStmt_CaseStmtClass:
-        case ZigClangStmt_DefaultStmtClass:
-        case ZigClangStmt_SwitchStmtClass:
-        case ZigClangStmt_AttributedStmtClass:
-        case ZigClangStmt_BinaryConditionalOperatorClass:
-        case ZigClangStmt_ConditionalOperatorClass:
-        case ZigClangStmt_AddrLabelExprClass:
-        case ZigClangStmt_ArrayInitIndexExprClass:
-        case ZigClangStmt_ArrayInitLoopExprClass:
-        case ZigClangStmt_ArraySubscriptExprClass:
-        case ZigClangStmt_ArrayTypeTraitExprClass:
-        case ZigClangStmt_AsTypeExprClass:
-        case ZigClangStmt_AtomicExprClass:
-        case ZigClangStmt_BinaryOperatorClass:
-        case ZigClangStmt_CompoundAssignOperatorClass:
-        case ZigClangStmt_BlockExprClass:
-        case ZigClangStmt_CXXBindTemporaryExprClass:
-        case ZigClangStmt_CXXBoolLiteralExprClass:
-        case ZigClangStmt_CXXConstructExprClass:
-        case ZigClangStmt_CXXTemporaryObjectExprClass:
-        case ZigClangStmt_CXXDefaultArgExprClass:
-        case ZigClangStmt_CXXDefaultInitExprClass:
-        case ZigClangStmt_CXXDeleteExprClass:
-        case ZigClangStmt_CXXDependentScopeMemberExprClass:
-        case ZigClangStmt_CXXFoldExprClass:
-        case ZigClangStmt_CXXInheritedCtorInitExprClass:
-        case ZigClangStmt_CXXNewExprClass:
-        case ZigClangStmt_CXXNoexceptExprClass:
-        case ZigClangStmt_CXXNullPtrLiteralExprClass:
-        case ZigClangStmt_CXXPseudoDestructorExprClass:
-        case ZigClangStmt_CXXRewrittenBinaryOperatorClass:
-        case ZigClangStmt_CXXScalarValueInitExprClass:
-        case ZigClangStmt_CXXStdInitializerListExprClass:
-        case ZigClangStmt_CXXThisExprClass:
-        case ZigClangStmt_CXXThrowExprClass:
-        case ZigClangStmt_CXXTypeidExprClass:
-        case ZigClangStmt_CXXUnresolvedConstructExprClass:
-        case ZigClangStmt_CXXUuidofExprClass:
-        case ZigClangStmt_CallExprClass:
-        case ZigClangStmt_CUDAKernelCallExprClass:
-        case ZigClangStmt_CXXMemberCallExprClass:
-        case ZigClangStmt_CXXOperatorCallExprClass:
-        case ZigClangStmt_UserDefinedLiteralClass:
-        case ZigClangStmt_BuiltinBitCastExprClass:
-        case ZigClangStmt_CStyleCastExprClass:
-        case ZigClangStmt_CXXFunctionalCastExprClass:
-        case ZigClangStmt_CXXAddrspaceCastExprClass:
-        case ZigClangStmt_CXXConstCastExprClass:
-        case ZigClangStmt_CXXDynamicCastExprClass:
-        case ZigClangStmt_CXXReinterpretCastExprClass:
-        case ZigClangStmt_CXXStaticCastExprClass:
-        case ZigClangStmt_ObjCBridgedCastExprClass:
-        case ZigClangStmt_ImplicitCastExprClass:
-        case ZigClangStmt_CharacterLiteralClass:
-        case ZigClangStmt_ChooseExprClass:
-        case ZigClangStmt_CompoundLiteralExprClass:
-        case ZigClangStmt_ConceptSpecializationExprClass:
-        case ZigClangStmt_ConvertVectorExprClass:
-        case ZigClangStmt_CoawaitExprClass:
-        case ZigClangStmt_CoyieldExprClass:
-        case ZigClangStmt_DeclRefExprClass:
-        case ZigClangStmt_DependentCoawaitExprClass:
-        case ZigClangStmt_DependentScopeDeclRefExprClass:
-        case ZigClangStmt_DesignatedInitExprClass:
-        case ZigClangStmt_DesignatedInitUpdateExprClass:
-        case ZigClangStmt_ExpressionTraitExprClass:
-        case ZigClangStmt_ExtVectorElementExprClass:
-        case ZigClangStmt_FixedPointLiteralClass:
-        case ZigClangStmt_FloatingLiteralClass:
-        case ZigClangStmt_ConstantExprClass:
-        case ZigClangStmt_ExprWithCleanupsClass:
-        case ZigClangStmt_FunctionParmPackExprClass:
-        case ZigClangStmt_GNUNullExprClass:
-        case ZigClangStmt_GenericSelectionExprClass:
-        case ZigClangStmt_ImaginaryLiteralClass:
-        case ZigClangStmt_ImplicitValueInitExprClass:
-        case ZigClangStmt_InitListExprClass:
-        case ZigClangStmt_IntegerLiteralClass:
-        case ZigClangStmt_LambdaExprClass:
-        case ZigClangStmt_MSPropertyRefExprClass:
-        case ZigClangStmt_MSPropertySubscriptExprClass:
-        case ZigClangStmt_MaterializeTemporaryExprClass:
-        case ZigClangStmt_MatrixSubscriptExprClass:
-        case ZigClangStmt_MemberExprClass:
-        case ZigClangStmt_NoInitExprClass:
-        case ZigClangStmt_OMPArraySectionExprClass:
-        case ZigClangStmt_OMPArrayShapingExprClass:
-        case ZigClangStmt_OMPIteratorExprClass:
-        case ZigClangStmt_ObjCArrayLiteralClass:
-        case ZigClangStmt_ObjCAvailabilityCheckExprClass:
-        case ZigClangStmt_ObjCBoolLiteralExprClass:
-        case ZigClangStmt_ObjCBoxedExprClass:
-        case ZigClangStmt_ObjCDictionaryLiteralClass:
-        case ZigClangStmt_ObjCEncodeExprClass:
-        case ZigClangStmt_ObjCIndirectCopyRestoreExprClass:
-        case ZigClangStmt_ObjCIsaExprClass:
-        case ZigClangStmt_ObjCIvarRefExprClass:
-        case ZigClangStmt_ObjCMessageExprClass:
-        case ZigClangStmt_ObjCPropertyRefExprClass:
-        case ZigClangStmt_ObjCProtocolExprClass:
-        case ZigClangStmt_ObjCSelectorExprClass:
-        case ZigClangStmt_ObjCStringLiteralClass:
-        case ZigClangStmt_ObjCSubscriptRefExprClass:
-        case ZigClangStmt_OffsetOfExprClass:
-        case ZigClangStmt_OpaqueValueExprClass:
-        case ZigClangStmt_UnresolvedLookupExprClass:
-        case ZigClangStmt_UnresolvedMemberExprClass:
-        case ZigClangStmt_PackExpansionExprClass:
-        case ZigClangStmt_ParenExprClass:
-        case ZigClangStmt_ParenListExprClass:
-        case ZigClangStmt_PredefinedExprClass:
-        case ZigClangStmt_PseudoObjectExprClass:
-        case ZigClangStmt_RecoveryExprClass:
-        case ZigClangStmt_RequiresExprClass:
-        case ZigClangStmt_ShuffleVectorExprClass:
-        case ZigClangStmt_SizeOfPackExprClass:
-        case ZigClangStmt_SourceLocExprClass:
-        case ZigClangStmt_StmtExprClass:
-        case ZigClangStmt_StringLiteralClass:
-        case ZigClangStmt_SubstNonTypeTemplateParmExprClass:
-        case ZigClangStmt_SubstNonTypeTemplateParmPackExprClass:
-        case ZigClangStmt_TypeTraitExprClass:
-        case ZigClangStmt_TypoExprClass:
-        case ZigClangStmt_UnaryExprOrTypeTraitExprClass:
-        case ZigClangStmt_UnaryOperatorClass:
-        case ZigClangStmt_VAArgExprClass:
-        case ZigClangStmt_LabelStmtClass:
-        case ZigClangStmt_WhileStmtClass:
+    switch (x) {
+        case clang::Stmt::NoStmtClass:
+        case clang::Stmt::GCCAsmStmtClass:
+        case clang::Stmt::MSAsmStmtClass:
+        case clang::Stmt::BreakStmtClass:
+        case clang::Stmt::CXXCatchStmtClass:
+        case clang::Stmt::CXXForRangeStmtClass:
+        case clang::Stmt::CXXTryStmtClass:
+        case clang::Stmt::CapturedStmtClass:
+        case clang::Stmt::CompoundStmtClass:
+        case clang::Stmt::ContinueStmtClass:
+        case clang::Stmt::CoreturnStmtClass:
+        case clang::Stmt::CoroutineBodyStmtClass:
+        case clang::Stmt::DeclStmtClass:
+        case clang::Stmt::DoStmtClass:
+        case clang::Stmt::ForStmtClass:
+        case clang::Stmt::GotoStmtClass:
+        case clang::Stmt::IfStmtClass:
+        case clang::Stmt::IndirectGotoStmtClass:
+        case clang::Stmt::MSDependentExistsStmtClass:
+        case clang::Stmt::NullStmtClass:
+        case clang::Stmt::OMPCanonicalLoopClass:
+        case clang::Stmt::OMPAtomicDirectiveClass:
+        case clang::Stmt::OMPBarrierDirectiveClass:
+        case clang::Stmt::OMPCancelDirectiveClass:
+        case clang::Stmt::OMPCancellationPointDirectiveClass:
+        case clang::Stmt::OMPCriticalDirectiveClass:
+        case clang::Stmt::OMPDepobjDirectiveClass:
+        case clang::Stmt::OMPDispatchDirectiveClass:
+        case clang::Stmt::OMPFlushDirectiveClass:
+        case clang::Stmt::OMPInteropDirectiveClass:
+        case clang::Stmt::OMPDistributeDirectiveClass:
+        case clang::Stmt::OMPDistributeParallelForDirectiveClass:
+        case clang::Stmt::OMPDistributeParallelForSimdDirectiveClass:
+        case clang::Stmt::OMPDistributeSimdDirectiveClass:
+        case clang::Stmt::OMPForDirectiveClass:
+        case clang::Stmt::OMPForSimdDirectiveClass:
+        case clang::Stmt::OMPMasterTaskLoopDirectiveClass:
+        case clang::Stmt::OMPMasterTaskLoopSimdDirectiveClass:
+        case clang::Stmt::OMPParallelForDirectiveClass:
+        case clang::Stmt::OMPParallelForSimdDirectiveClass:
+        case clang::Stmt::OMPParallelMasterTaskLoopDirectiveClass:
+        case clang::Stmt::OMPParallelMasterTaskLoopSimdDirectiveClass:
+        case clang::Stmt::OMPSimdDirectiveClass:
+        case clang::Stmt::OMPTargetParallelForSimdDirectiveClass:
+        case clang::Stmt::OMPTargetSimdDirectiveClass:
+        case clang::Stmt::OMPTargetTeamsDistributeDirectiveClass:
+        case clang::Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass:
+        case clang::Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass:
+        case clang::Stmt::OMPTargetTeamsDistributeSimdDirectiveClass:
+        case clang::Stmt::OMPTaskLoopDirectiveClass:
+        case clang::Stmt::OMPTaskLoopSimdDirectiveClass:
+        case clang::Stmt::OMPTeamsDistributeDirectiveClass:
+        case clang::Stmt::OMPTeamsDistributeParallelForDirectiveClass:
+        case clang::Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass:
+        case clang::Stmt::OMPTeamsDistributeSimdDirectiveClass:
+        case clang::Stmt::OMPTileDirectiveClass:
+        case clang::Stmt::OMPUnrollDirectiveClass:
+        case clang::Stmt::OMPMaskedDirectiveClass:
+        case clang::Stmt::OMPMasterDirectiveClass:
+        case clang::Stmt::OMPOrderedDirectiveClass:
+        case clang::Stmt::OMPParallelDirectiveClass:
+        case clang::Stmt::OMPParallelMasterDirectiveClass:
+        case clang::Stmt::OMPParallelSectionsDirectiveClass:
+        case clang::Stmt::OMPScanDirectiveClass:
+        case clang::Stmt::OMPSectionDirectiveClass:
+        case clang::Stmt::OMPSectionsDirectiveClass:
+        case clang::Stmt::OMPSingleDirectiveClass:
+        case clang::Stmt::OMPTargetDataDirectiveClass:
+        case clang::Stmt::OMPTargetDirectiveClass:
+        case clang::Stmt::OMPTargetEnterDataDirectiveClass:
+        case clang::Stmt::OMPTargetExitDataDirectiveClass:
+        case clang::Stmt::OMPTargetParallelDirectiveClass:
+        case clang::Stmt::OMPTargetParallelForDirectiveClass:
+        case clang::Stmt::OMPTargetTeamsDirectiveClass:
+        case clang::Stmt::OMPTargetUpdateDirectiveClass:
+        case clang::Stmt::OMPTaskDirectiveClass:
+        case clang::Stmt::OMPTaskgroupDirectiveClass:
+        case clang::Stmt::OMPTaskwaitDirectiveClass:
+        case clang::Stmt::OMPTaskyieldDirectiveClass:
+        case clang::Stmt::OMPTeamsDirectiveClass:
+        case clang::Stmt::ObjCAtCatchStmtClass:
+        case clang::Stmt::ObjCAtFinallyStmtClass:
+        case clang::Stmt::ObjCAtSynchronizedStmtClass:
+        case clang::Stmt::ObjCAtThrowStmtClass:
+        case clang::Stmt::ObjCAtTryStmtClass:
+        case clang::Stmt::ObjCAutoreleasePoolStmtClass:
+        case clang::Stmt::ObjCForCollectionStmtClass:
+        case clang::Stmt::ReturnStmtClass:
+        case clang::Stmt::SEHExceptStmtClass:
+        case clang::Stmt::SEHFinallyStmtClass:
+        case clang::Stmt::SEHLeaveStmtClass:
+        case clang::Stmt::SEHTryStmtClass:
+        case clang::Stmt::CaseStmtClass:
+        case clang::Stmt::DefaultStmtClass:
+        case clang::Stmt::SwitchStmtClass:
+        case clang::Stmt::AttributedStmtClass:
+        case clang::Stmt::BinaryConditionalOperatorClass:
+        case clang::Stmt::ConditionalOperatorClass:
+        case clang::Stmt::AddrLabelExprClass:
+        case clang::Stmt::ArrayInitIndexExprClass:
+        case clang::Stmt::ArrayInitLoopExprClass:
+        case clang::Stmt::ArraySubscriptExprClass:
+        case clang::Stmt::ArrayTypeTraitExprClass:
+        case clang::Stmt::AsTypeExprClass:
+        case clang::Stmt::AtomicExprClass:
+        case clang::Stmt::BinaryOperatorClass:
+        case clang::Stmt::CompoundAssignOperatorClass:
+        case clang::Stmt::BlockExprClass:
+        case clang::Stmt::CXXBindTemporaryExprClass:
+        case clang::Stmt::CXXBoolLiteralExprClass:
+        case clang::Stmt::CXXConstructExprClass:
+        case clang::Stmt::CXXTemporaryObjectExprClass:
+        case clang::Stmt::CXXDefaultArgExprClass:
+        case clang::Stmt::CXXDefaultInitExprClass:
+        case clang::Stmt::CXXDeleteExprClass:
+        case clang::Stmt::CXXDependentScopeMemberExprClass:
+        case clang::Stmt::CXXFoldExprClass:
+        case clang::Stmt::CXXInheritedCtorInitExprClass:
+        case clang::Stmt::CXXNewExprClass:
+        case clang::Stmt::CXXNoexceptExprClass:
+        case clang::Stmt::CXXNullPtrLiteralExprClass:
+        case clang::Stmt::CXXPseudoDestructorExprClass:
+        case clang::Stmt::CXXRewrittenBinaryOperatorClass:
+        case clang::Stmt::CXXScalarValueInitExprClass:
+        case clang::Stmt::CXXStdInitializerListExprClass:
+        case clang::Stmt::CXXThisExprClass:
+        case clang::Stmt::CXXThrowExprClass:
+        case clang::Stmt::CXXTypeidExprClass:
+        case clang::Stmt::CXXUnresolvedConstructExprClass:
+        case clang::Stmt::CXXUuidofExprClass:
+        case clang::Stmt::CallExprClass:
+        case clang::Stmt::CUDAKernelCallExprClass:
+        case clang::Stmt::CXXMemberCallExprClass:
+        case clang::Stmt::CXXOperatorCallExprClass:
+        case clang::Stmt::UserDefinedLiteralClass:
+        case clang::Stmt::BuiltinBitCastExprClass:
+        case clang::Stmt::CStyleCastExprClass:
+        case clang::Stmt::CXXFunctionalCastExprClass:
+        case clang::Stmt::CXXAddrspaceCastExprClass:
+        case clang::Stmt::CXXConstCastExprClass:
+        case clang::Stmt::CXXDynamicCastExprClass:
+        case clang::Stmt::CXXReinterpretCastExprClass:
+        case clang::Stmt::CXXStaticCastExprClass:
+        case clang::Stmt::ObjCBridgedCastExprClass:
+        case clang::Stmt::ImplicitCastExprClass:
+        case clang::Stmt::CharacterLiteralClass:
+        case clang::Stmt::ChooseExprClass:
+        case clang::Stmt::CompoundLiteralExprClass:
+        case clang::Stmt::ConceptSpecializationExprClass:
+        case clang::Stmt::ConvertVectorExprClass:
+        case clang::Stmt::CoawaitExprClass:
+        case clang::Stmt::CoyieldExprClass:
+        case clang::Stmt::DeclRefExprClass:
+        case clang::Stmt::DependentCoawaitExprClass:
+        case clang::Stmt::DependentScopeDeclRefExprClass:
+        case clang::Stmt::DesignatedInitExprClass:
+        case clang::Stmt::DesignatedInitUpdateExprClass:
+        case clang::Stmt::ExpressionTraitExprClass:
+        case clang::Stmt::ExtVectorElementExprClass:
+        case clang::Stmt::FixedPointLiteralClass:
+        case clang::Stmt::FloatingLiteralClass:
+        case clang::Stmt::ConstantExprClass:
+        case clang::Stmt::ExprWithCleanupsClass:
+        case clang::Stmt::FunctionParmPackExprClass:
+        case clang::Stmt::GNUNullExprClass:
+        case clang::Stmt::GenericSelectionExprClass:
+        case clang::Stmt::ImaginaryLiteralClass:
+        case clang::Stmt::ImplicitValueInitExprClass:
+        case clang::Stmt::InitListExprClass:
+        case clang::Stmt::IntegerLiteralClass:
+        case clang::Stmt::LambdaExprClass:
+        case clang::Stmt::MSPropertyRefExprClass:
+        case clang::Stmt::MSPropertySubscriptExprClass:
+        case clang::Stmt::MaterializeTemporaryExprClass:
+        case clang::Stmt::MatrixSubscriptExprClass:
+        case clang::Stmt::MemberExprClass:
+        case clang::Stmt::NoInitExprClass:
+        case clang::Stmt::OMPArraySectionExprClass:
+        case clang::Stmt::OMPArrayShapingExprClass:
+        case clang::Stmt::OMPIteratorExprClass:
+        case clang::Stmt::ObjCArrayLiteralClass:
+        case clang::Stmt::ObjCAvailabilityCheckExprClass:
+        case clang::Stmt::ObjCBoolLiteralExprClass:
+        case clang::Stmt::ObjCBoxedExprClass:
+        case clang::Stmt::ObjCDictionaryLiteralClass:
+        case clang::Stmt::ObjCEncodeExprClass:
+        case clang::Stmt::ObjCIndirectCopyRestoreExprClass:
+        case clang::Stmt::ObjCIsaExprClass:
+        case clang::Stmt::ObjCIvarRefExprClass:
+        case clang::Stmt::ObjCMessageExprClass:
+        case clang::Stmt::ObjCPropertyRefExprClass:
+        case clang::Stmt::ObjCProtocolExprClass:
+        case clang::Stmt::ObjCSelectorExprClass:
+        case clang::Stmt::ObjCStringLiteralClass:
+        case clang::Stmt::ObjCSubscriptRefExprClass:
+        case clang::Stmt::OffsetOfExprClass:
+        case clang::Stmt::OpaqueValueExprClass:
+        case clang::Stmt::UnresolvedLookupExprClass:
+        case clang::Stmt::UnresolvedMemberExprClass:
+        case clang::Stmt::PackExpansionExprClass:
+        case clang::Stmt::ParenExprClass:
+        case clang::Stmt::ParenListExprClass:
+        case clang::Stmt::PredefinedExprClass:
+        case clang::Stmt::PseudoObjectExprClass:
+        case clang::Stmt::RecoveryExprClass:
+        case clang::Stmt::RequiresExprClass:
+        case clang::Stmt::SYCLUniqueStableNameExprClass:
+        case clang::Stmt::ShuffleVectorExprClass:
+        case clang::Stmt::SizeOfPackExprClass:
+        case clang::Stmt::SourceLocExprClass:
+        case clang::Stmt::StmtExprClass:
+        case clang::Stmt::StringLiteralClass:
+        case clang::Stmt::SubstNonTypeTemplateParmExprClass:
+        case clang::Stmt::SubstNonTypeTemplateParmPackExprClass:
+        case clang::Stmt::TypeTraitExprClass:
+        case clang::Stmt::TypoExprClass:
+        case clang::Stmt::UnaryExprOrTypeTraitExprClass:
+        case clang::Stmt::UnaryOperatorClass:
+        case clang::Stmt::VAArgExprClass:
+        case clang::Stmt::LabelStmtClass:
+        case clang::Stmt::WhileStmtClass:
             break;
     }
 }
@@ -629,13 +638,16 @@ static_assert((clang::Stmt::StmtClass)ZigClangStmt_IfStmtClass == clang::Stmt::I
 static_assert((clang::Stmt::StmtClass)ZigClangStmt_IndirectGotoStmtClass == clang::Stmt::IndirectGotoStmtClass, "");
 static_assert((clang::Stmt::StmtClass)ZigClangStmt_MSDependentExistsStmtClass == clang::Stmt::MSDependentExistsStmtClass, "");
 static_assert((clang::Stmt::StmtClass)ZigClangStmt_NullStmtClass == clang::Stmt::NullStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPCanonicalLoopClass == clang::Stmt::OMPCanonicalLoopClass, "");
 static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPAtomicDirectiveClass == clang::Stmt::OMPAtomicDirectiveClass, "");
 static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPBarrierDirectiveClass == clang::Stmt::OMPBarrierDirectiveClass, "");
 static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPCancelDirectiveClass == clang::Stmt::OMPCancelDirectiveClass, "");
 static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPCancellationPointDirectiveClass == clang::Stmt::OMPCancellationPointDirectiveClass, "");
 static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPCriticalDirectiveClass == clang::Stmt::OMPCriticalDirectiveClass, "");
 static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPDepobjDirectiveClass == clang::Stmt::OMPDepobjDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPDispatchDirectiveClass == clang::Stmt::OMPDispatchDirectiveClass, "");
 static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPFlushDirectiveClass == clang::Stmt::OMPFlushDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPInteropDirectiveClass == clang::Stmt::OMPInteropDirectiveClass, "");
 static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPDistributeDirectiveClass == clang::Stmt::OMPDistributeDirectiveClass, "");
 static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPDistributeParallelForDirectiveClass == clang::Stmt::OMPDistributeParallelForDirectiveClass, "");
 static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPDistributeParallelForSimdDirectiveClass == clang::Stmt::OMPDistributeParallelForSimdDirectiveClass, "");
@@ -661,6 +673,9 @@ static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTeamsDistributeDirectiveCl
 static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTeamsDistributeParallelForDirectiveClass == clang::Stmt::OMPTeamsDistributeParallelForDirectiveClass, "");
 static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTeamsDistributeParallelForSimdDirectiveClass == clang::Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass, "");
 static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTeamsDistributeSimdDirectiveClass == clang::Stmt::OMPTeamsDistributeSimdDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTileDirectiveClass == clang::Stmt::OMPTileDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPUnrollDirectiveClass == clang::Stmt::OMPUnrollDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPMaskedDirectiveClass == clang::Stmt::OMPMaskedDirectiveClass, "");
 static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPMasterDirectiveClass == clang::Stmt::OMPMasterDirectiveClass, "");
 static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPOrderedDirectiveClass == clang::Stmt::OMPOrderedDirectiveClass, "");
 static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPParallelDirectiveClass == clang::Stmt::OMPParallelDirectiveClass, "");
@@ -809,6 +824,7 @@ static_assert((clang::Stmt::StmtClass)ZigClangStmt_PredefinedExprClass == clang:
 static_assert((clang::Stmt::StmtClass)ZigClangStmt_PseudoObjectExprClass == clang::Stmt::PseudoObjectExprClass, "");
 static_assert((clang::Stmt::StmtClass)ZigClangStmt_RecoveryExprClass == clang::Stmt::RecoveryExprClass, "");
 static_assert((clang::Stmt::StmtClass)ZigClangStmt_RequiresExprClass == clang::Stmt::RequiresExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_SYCLUniqueStableNameExprClass == clang::Stmt::SYCLUniqueStableNameExprClass, "");
 static_assert((clang::Stmt::StmtClass)ZigClangStmt_ShuffleVectorExprClass == clang::Stmt::ShuffleVectorExprClass, "");
 static_assert((clang::Stmt::StmtClass)ZigClangStmt_SizeOfPackExprClass == clang::Stmt::SizeOfPackExprClass, "");
 static_assert((clang::Stmt::StmtClass)ZigClangStmt_SourceLocExprClass == clang::Stmt::SourceLocExprClass, "");
@@ -876,6 +892,8 @@ void ZigClang_detect_enum_DeclKind(clang::Decl::Kind x) {
         case clang::Decl::Import:
         case clang::Decl::LifetimeExtendedTemporary:
         case clang::Decl::LinkageSpec:
+        case clang::Decl::Using:
+        case clang::Decl::UsingEnum:
         case clang::Decl::Label:
         case clang::Decl::Namespace:
         case clang::Decl::NamespaceAlias:
@@ -904,7 +922,7 @@ void ZigClang_detect_enum_DeclKind(clang::Decl::Kind x) {
         case clang::Decl::TypeAlias:
         case clang::Decl::Typedef:
         case clang::Decl::UnresolvedUsingTypename:
-        case clang::Decl::Using:
+        case clang::Decl::UnresolvedUsingIfExists:
         case clang::Decl::UsingDirective:
         case clang::Decl::UsingPack:
         case clang::Decl::UsingShadow:
@@ -961,6 +979,8 @@ static_assert((clang::Decl::Kind)ZigClangDeclFriendTemplate == clang::Decl::Frie
 static_assert((clang::Decl::Kind)ZigClangDeclImport == clang::Decl::Import, "");
 static_assert((clang::Decl::Kind)ZigClangDeclLifetimeExtendedTemporary == clang::Decl::LifetimeExtendedTemporary, "");
 static_assert((clang::Decl::Kind)ZigClangDeclLinkageSpec == clang::Decl::LinkageSpec, "");
+static_assert((clang::Decl::Kind)ZigClangDeclUsing == clang::Decl::Using, "");
+static_assert((clang::Decl::Kind)ZigClangDeclUsingEnum == clang::Decl::UsingEnum, "");
 static_assert((clang::Decl::Kind)ZigClangDeclLabel == clang::Decl::Label, "");
 static_assert((clang::Decl::Kind)ZigClangDeclNamespace == clang::Decl::Namespace, "");
 static_assert((clang::Decl::Kind)ZigClangDeclNamespaceAlias == clang::Decl::NamespaceAlias, "");
@@ -989,8 +1009,8 @@ static_assert((clang::Decl::Kind)ZigClangDeclObjCTypeParam == clang::Decl::ObjCT
 static_assert((clang::Decl::Kind)ZigClangDeclTypeAlias == clang::Decl::TypeAlias, "");
 static_assert((clang::Decl::Kind)ZigClangDeclTypedef == clang::Decl::Typedef, "");
 static_assert((clang::Decl::Kind)ZigClangDeclUnresolvedUsingTypename == clang::Decl::UnresolvedUsingTypename, "");
+static_assert((clang::Decl::Kind)ZigClangDeclUnresolvedUsingIfExists == clang::Decl::UnresolvedUsingIfExists, "");
 static_assert((clang::Decl::Kind)ZigClangDeclOMPAllocate == clang::Decl::OMPAllocate, "");
-static_assert((clang::Decl::Kind)ZigClangDeclUsing == clang::Decl::Using, "");
 static_assert((clang::Decl::Kind)ZigClangDeclUsingDirective == clang::Decl::UsingDirective, "");
 static_assert((clang::Decl::Kind)ZigClangDeclUsingPack == clang::Decl::UsingPack, "");
 static_assert((clang::Decl::Kind)ZigClangDeclUsingShadow == clang::Decl::UsingShadow, "");
@@ -1131,6 +1151,72 @@ void ZigClang_detect_enum_BuiltinTypeKind(clang::BuiltinType::Kind x) {
         case clang::BuiltinType::SveBool:
         case clang::BuiltinType::VectorQuad:
         case clang::BuiltinType::VectorPair:
+        case clang::BuiltinType::RvvInt8mf8:
+        case clang::BuiltinType::RvvInt8mf4:
+        case clang::BuiltinType::RvvInt8mf2:
+        case clang::BuiltinType::RvvInt8m1:
+        case clang::BuiltinType::RvvInt8m2:
+        case clang::BuiltinType::RvvInt8m4:
+        case clang::BuiltinType::RvvInt8m8:
+        case clang::BuiltinType::RvvUint8mf8:
+        case clang::BuiltinType::RvvUint8mf4:
+        case clang::BuiltinType::RvvUint8mf2:
+        case clang::BuiltinType::RvvUint8m1:
+        case clang::BuiltinType::RvvUint8m2:
+        case clang::BuiltinType::RvvUint8m4:
+        case clang::BuiltinType::RvvUint8m8:
+        case clang::BuiltinType::RvvInt16mf4:
+        case clang::BuiltinType::RvvInt16mf2:
+        case clang::BuiltinType::RvvInt16m1:
+        case clang::BuiltinType::RvvInt16m2:
+        case clang::BuiltinType::RvvInt16m4:
+        case clang::BuiltinType::RvvInt16m8:
+        case clang::BuiltinType::RvvUint16mf4:
+        case clang::BuiltinType::RvvUint16mf2:
+        case clang::BuiltinType::RvvUint16m1:
+        case clang::BuiltinType::RvvUint16m2:
+        case clang::BuiltinType::RvvUint16m4:
+        case clang::BuiltinType::RvvUint16m8:
+        case clang::BuiltinType::RvvInt32mf2:
+        case clang::BuiltinType::RvvInt32m1:
+        case clang::BuiltinType::RvvInt32m2:
+        case clang::BuiltinType::RvvInt32m4:
+        case clang::BuiltinType::RvvInt32m8:
+        case clang::BuiltinType::RvvUint32mf2:
+        case clang::BuiltinType::RvvUint32m1:
+        case clang::BuiltinType::RvvUint32m2:
+        case clang::BuiltinType::RvvUint32m4:
+        case clang::BuiltinType::RvvUint32m8:
+        case clang::BuiltinType::RvvInt64m1:
+        case clang::BuiltinType::RvvInt64m2:
+        case clang::BuiltinType::RvvInt64m4:
+        case clang::BuiltinType::RvvInt64m8:
+        case clang::BuiltinType::RvvUint64m1:
+        case clang::BuiltinType::RvvUint64m2:
+        case clang::BuiltinType::RvvUint64m4:
+        case clang::BuiltinType::RvvUint64m8:
+        case clang::BuiltinType::RvvFloat16mf4:
+        case clang::BuiltinType::RvvFloat16mf2:
+        case clang::BuiltinType::RvvFloat16m1:
+        case clang::BuiltinType::RvvFloat16m2:
+        case clang::BuiltinType::RvvFloat16m4:
+        case clang::BuiltinType::RvvFloat16m8:
+        case clang::BuiltinType::RvvFloat32mf2:
+        case clang::BuiltinType::RvvFloat32m1:
+        case clang::BuiltinType::RvvFloat32m2:
+        case clang::BuiltinType::RvvFloat32m4:
+        case clang::BuiltinType::RvvFloat32m8:
+        case clang::BuiltinType::RvvFloat64m1:
+        case clang::BuiltinType::RvvFloat64m2:
+        case clang::BuiltinType::RvvFloat64m4:
+        case clang::BuiltinType::RvvFloat64m8:
+        case clang::BuiltinType::RvvBool1:
+        case clang::BuiltinType::RvvBool2:
+        case clang::BuiltinType::RvvBool4:
+        case clang::BuiltinType::RvvBool8:
+        case clang::BuiltinType::RvvBool16:
+        case clang::BuiltinType::RvvBool32:
+        case clang::BuiltinType::RvvBool64:
         case clang::BuiltinType::Void:
         case clang::BuiltinType::Bool:
         case clang::BuiltinType::Char_U:
@@ -1306,6 +1392,72 @@ static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeSveBFloat16x4 == clan
 static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeSveBool == clang::BuiltinType::SveBool, "");
 static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeVectorQuad == clang::BuiltinType::VectorQuad, "");
 static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeVectorPair == clang::BuiltinType::VectorPair, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvInt8mf8 == clang::BuiltinType::RvvInt8mf8, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvInt8mf4 == clang::BuiltinType::RvvInt8mf4, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvInt8mf2 == clang::BuiltinType::RvvInt8mf2, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvInt8m1 == clang::BuiltinType::RvvInt8m1, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvInt8m2 == clang::BuiltinType::RvvInt8m2, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvInt8m4 == clang::BuiltinType::RvvInt8m4, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvInt8m8 == clang::BuiltinType::RvvInt8m8, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvUint8mf8 == clang::BuiltinType::RvvUint8mf8, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvUint8mf4 == clang::BuiltinType::RvvUint8mf4, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvUint8mf2 == clang::BuiltinType::RvvUint8mf2, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvUint8m1 == clang::BuiltinType::RvvUint8m1, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvUint8m2 == clang::BuiltinType::RvvUint8m2, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvUint8m4 == clang::BuiltinType::RvvUint8m4, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvUint8m8 == clang::BuiltinType::RvvUint8m8, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvInt16mf4 == clang::BuiltinType::RvvInt16mf4, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvInt16mf2 == clang::BuiltinType::RvvInt16mf2, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvInt16m1 == clang::BuiltinType::RvvInt16m1, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvInt16m2 == clang::BuiltinType::RvvInt16m2, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvInt16m4 == clang::BuiltinType::RvvInt16m4, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvInt16m8 == clang::BuiltinType::RvvInt16m8, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvUint16mf4 == clang::BuiltinType::RvvUint16mf4, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvUint16mf2 == clang::BuiltinType::RvvUint16mf2, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvUint16m1 == clang::BuiltinType::RvvUint16m1, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvUint16m2 == clang::BuiltinType::RvvUint16m2, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvUint16m4 == clang::BuiltinType::RvvUint16m4, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvUint16m8 == clang::BuiltinType::RvvUint16m8, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvInt32mf2 == clang::BuiltinType::RvvInt32mf2, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvInt32m1 == clang::BuiltinType::RvvInt32m1, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvInt32m2 == clang::BuiltinType::RvvInt32m2, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvInt32m4 == clang::BuiltinType::RvvInt32m4, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvInt32m8 == clang::BuiltinType::RvvInt32m8, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvUint32mf2 == clang::BuiltinType::RvvUint32mf2, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvUint32m1 == clang::BuiltinType::RvvUint32m1, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvUint32m2 == clang::BuiltinType::RvvUint32m2, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvUint32m4 == clang::BuiltinType::RvvUint32m4, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvUint32m8 == clang::BuiltinType::RvvUint32m8, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvInt64m1 == clang::BuiltinType::RvvInt64m1, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvInt64m2 == clang::BuiltinType::RvvInt64m2, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvInt64m4 == clang::BuiltinType::RvvInt64m4, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvInt64m8 == clang::BuiltinType::RvvInt64m8, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvUint64m1 == clang::BuiltinType::RvvUint64m1, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvUint64m2 == clang::BuiltinType::RvvUint64m2, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvUint64m4 == clang::BuiltinType::RvvUint64m4, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvUint64m8 == clang::BuiltinType::RvvUint64m8, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvFloat16mf4 == clang::BuiltinType::RvvFloat16mf4, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvFloat16mf2 == clang::BuiltinType::RvvFloat16mf2, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvFloat16m1 == clang::BuiltinType::RvvFloat16m1, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvFloat16m2 == clang::BuiltinType::RvvFloat16m2, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvFloat16m4 == clang::BuiltinType::RvvFloat16m4, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvFloat16m8 == clang::BuiltinType::RvvFloat16m8, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvFloat32mf2 == clang::BuiltinType::RvvFloat32mf2, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvFloat32m1 == clang::BuiltinType::RvvFloat32m1, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvFloat32m2 == clang::BuiltinType::RvvFloat32m2, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvFloat32m4 == clang::BuiltinType::RvvFloat32m4, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvFloat32m8 == clang::BuiltinType::RvvFloat32m8, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvFloat64m1 == clang::BuiltinType::RvvFloat64m1, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvFloat64m2 == clang::BuiltinType::RvvFloat64m2, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvFloat64m4 == clang::BuiltinType::RvvFloat64m4, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvFloat64m8 == clang::BuiltinType::RvvFloat64m8, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvBool1 == clang::BuiltinType::RvvBool1, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvBool2 == clang::BuiltinType::RvvBool2, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvBool4 == clang::BuiltinType::RvvBool4, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvBool8 == clang::BuiltinType::RvvBool8, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvBool16 == clang::BuiltinType::RvvBool16, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvBool32 == clang::BuiltinType::RvvBool32, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeRvvBool64 == clang::BuiltinType::RvvBool64, "");
 static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeVoid == clang::BuiltinType::Void, "");
 static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeBool == clang::BuiltinType::Bool, "");
 static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeChar_U == clang::BuiltinType::Char_U, "");
@@ -1396,6 +1548,7 @@ void ZigClang_detect_enum_CallingConv(clang::CallingConv x) {
         case clang::CC_SpirFunction:
         case clang::CC_OpenCLKernel:
         case clang::CC_Swift:
+        case clang::CC_SwiftAsync:
         case clang::CC_PreserveMost:
         case clang::CC_PreserveAll:
         case clang::CC_AArch64VectorCall:
@@ -1418,6 +1571,7 @@ static_assert((clang::CallingConv)ZigClangCallingConv_IntelOclBicc == clang::CC_
 static_assert((clang::CallingConv)ZigClangCallingConv_SpirFunction == clang::CC_SpirFunction, "");
 static_assert((clang::CallingConv)ZigClangCallingConv_OpenCLKernel == clang::CC_OpenCLKernel, "");
 static_assert((clang::CallingConv)ZigClangCallingConv_Swift == clang::CC_Swift, "");
+static_assert((clang::CallingConv)ZigClangCallingConv_SwiftAsync == clang::CC_SwiftAsync, "");
 static_assert((clang::CallingConv)ZigClangCallingConv_PreserveMost == clang::CC_PreserveMost, "");
 static_assert((clang::CallingConv)ZigClangCallingConv_PreserveAll == clang::CC_PreserveAll, "");
 static_assert((clang::CallingConv)ZigClangCallingConv_AArch64VectorCall == clang::CC_AArch64VectorCall, "");
diff --git a/src/zig_clang.h b/src/zig_clang.h
index 26b4b3ca9a..f704b50b18 100644
--- a/src/zig_clang.h
+++ b/src/zig_clang.h
@@ -318,13 +318,16 @@ enum ZigClangStmtClass {
     ZigClangStmt_IndirectGotoStmtClass,
     ZigClangStmt_MSDependentExistsStmtClass,
     ZigClangStmt_NullStmtClass,
+    ZigClangStmt_OMPCanonicalLoopClass,
     ZigClangStmt_OMPAtomicDirectiveClass,
     ZigClangStmt_OMPBarrierDirectiveClass,
     ZigClangStmt_OMPCancelDirectiveClass,
     ZigClangStmt_OMPCancellationPointDirectiveClass,
     ZigClangStmt_OMPCriticalDirectiveClass,
     ZigClangStmt_OMPDepobjDirectiveClass,
+    ZigClangStmt_OMPDispatchDirectiveClass,
     ZigClangStmt_OMPFlushDirectiveClass,
+    ZigClangStmt_OMPInteropDirectiveClass,
     ZigClangStmt_OMPDistributeDirectiveClass,
     ZigClangStmt_OMPDistributeParallelForDirectiveClass,
     ZigClangStmt_OMPDistributeParallelForSimdDirectiveClass,
@@ -350,6 +353,9 @@ enum ZigClangStmtClass {
     ZigClangStmt_OMPTeamsDistributeParallelForDirectiveClass,
     ZigClangStmt_OMPTeamsDistributeParallelForSimdDirectiveClass,
     ZigClangStmt_OMPTeamsDistributeSimdDirectiveClass,
+    ZigClangStmt_OMPTileDirectiveClass,
+    ZigClangStmt_OMPUnrollDirectiveClass,
+    ZigClangStmt_OMPMaskedDirectiveClass,
     ZigClangStmt_OMPMasterDirectiveClass,
     ZigClangStmt_OMPOrderedDirectiveClass,
     ZigClangStmt_OMPParallelDirectiveClass,
@@ -498,6 +504,7 @@ enum ZigClangStmtClass {
     ZigClangStmt_PseudoObjectExprClass,
     ZigClangStmt_RecoveryExprClass,
     ZigClangStmt_RequiresExprClass,
+    ZigClangStmt_SYCLUniqueStableNameExprClass,
     ZigClangStmt_ShuffleVectorExprClass,
     ZigClangStmt_SizeOfPackExprClass,
     ZigClangStmt_SourceLocExprClass,
@@ -540,6 +547,7 @@ enum ZigClangCK {
     ZigClangCK_PointerToIntegral,
     ZigClangCK_PointerToBoolean,
     ZigClangCK_ToVoid,
+    ZigClangCK_MatrixCast,
     ZigClangCK_VectorSplat,
     ZigClangCK_IntegralCast,
     ZigClangCK_IntegralToBoolean,
@@ -595,6 +603,8 @@ enum ZigClangDeclKind {
     ZigClangDeclImport,
     ZigClangDeclLifetimeExtendedTemporary,
     ZigClangDeclLinkageSpec,
+    ZigClangDeclUsing,
+    ZigClangDeclUsingEnum,
     ZigClangDeclLabel,
     ZigClangDeclNamespace,
     ZigClangDeclNamespaceAlias,
@@ -623,7 +633,7 @@ enum ZigClangDeclKind {
     ZigClangDeclTypeAlias,
     ZigClangDeclTypedef,
     ZigClangDeclUnresolvedUsingTypename,
-    ZigClangDeclUsing,
+    ZigClangDeclUnresolvedUsingIfExists,
     ZigClangDeclUsingDirective,
     ZigClangDeclUsingPack,
     ZigClangDeclUsingShadow,
@@ -765,6 +775,72 @@ enum ZigClangBuiltinTypeKind {
     ZigClangBuiltinTypeSveBool,
     ZigClangBuiltinTypeVectorQuad,
     ZigClangBuiltinTypeVectorPair,
+    ZigClangBuiltinTypeRvvInt8mf8,
+    ZigClangBuiltinTypeRvvInt8mf4,
+    ZigClangBuiltinTypeRvvInt8mf2,
+    ZigClangBuiltinTypeRvvInt8m1,
+    ZigClangBuiltinTypeRvvInt8m2,
+    ZigClangBuiltinTypeRvvInt8m4,
+    ZigClangBuiltinTypeRvvInt8m8,
+    ZigClangBuiltinTypeRvvUint8mf8,
+    ZigClangBuiltinTypeRvvUint8mf4,
+    ZigClangBuiltinTypeRvvUint8mf2,
+    ZigClangBuiltinTypeRvvUint8m1,
+    ZigClangBuiltinTypeRvvUint8m2,
+    ZigClangBuiltinTypeRvvUint8m4,
+    ZigClangBuiltinTypeRvvUint8m8,
+    ZigClangBuiltinTypeRvvInt16mf4,
+    ZigClangBuiltinTypeRvvInt16mf2,
+    ZigClangBuiltinTypeRvvInt16m1,
+    ZigClangBuiltinTypeRvvInt16m2,
+    ZigClangBuiltinTypeRvvInt16m4,
+    ZigClangBuiltinTypeRvvInt16m8,
+    ZigClangBuiltinTypeRvvUint16mf4,
+    ZigClangBuiltinTypeRvvUint16mf2,
+    ZigClangBuiltinTypeRvvUint16m1,
+    ZigClangBuiltinTypeRvvUint16m2,
+    ZigClangBuiltinTypeRvvUint16m4,
+    ZigClangBuiltinTypeRvvUint16m8,
+    ZigClangBuiltinTypeRvvInt32mf2,
+    ZigClangBuiltinTypeRvvInt32m1,
+    ZigClangBuiltinTypeRvvInt32m2,
+    ZigClangBuiltinTypeRvvInt32m4,
+    ZigClangBuiltinTypeRvvInt32m8,
+    ZigClangBuiltinTypeRvvUint32mf2,
+    ZigClangBuiltinTypeRvvUint32m1,
+    ZigClangBuiltinTypeRvvUint32m2,
+    ZigClangBuiltinTypeRvvUint32m4,
+    ZigClangBuiltinTypeRvvUint32m8,
+    ZigClangBuiltinTypeRvvInt64m1,
+    ZigClangBuiltinTypeRvvInt64m2,
+    ZigClangBuiltinTypeRvvInt64m4,
+    ZigClangBuiltinTypeRvvInt64m8,
+    ZigClangBuiltinTypeRvvUint64m1,
+    ZigClangBuiltinTypeRvvUint64m2,
+    ZigClangBuiltinTypeRvvUint64m4,
+    ZigClangBuiltinTypeRvvUint64m8,
+    ZigClangBuiltinTypeRvvFloat16mf4,
+    ZigClangBuiltinTypeRvvFloat16mf2,
+    ZigClangBuiltinTypeRvvFloat16m1,
+    ZigClangBuiltinTypeRvvFloat16m2,
+    ZigClangBuiltinTypeRvvFloat16m4,
+    ZigClangBuiltinTypeRvvFloat16m8,
+    ZigClangBuiltinTypeRvvFloat32mf2,
+    ZigClangBuiltinTypeRvvFloat32m1,
+    ZigClangBuiltinTypeRvvFloat32m2,
+    ZigClangBuiltinTypeRvvFloat32m4,
+    ZigClangBuiltinTypeRvvFloat32m8,
+    ZigClangBuiltinTypeRvvFloat64m1,
+    ZigClangBuiltinTypeRvvFloat64m2,
+    ZigClangBuiltinTypeRvvFloat64m4,
+    ZigClangBuiltinTypeRvvFloat64m8,
+    ZigClangBuiltinTypeRvvBool1,
+    ZigClangBuiltinTypeRvvBool2,
+    ZigClangBuiltinTypeRvvBool4,
+    ZigClangBuiltinTypeRvvBool8,
+    ZigClangBuiltinTypeRvvBool16,
+    ZigClangBuiltinTypeRvvBool32,
+    ZigClangBuiltinTypeRvvBool64,
     ZigClangBuiltinTypeVoid,
     ZigClangBuiltinTypeBool,
     ZigClangBuiltinTypeChar_U,
@@ -855,6 +931,7 @@ enum ZigClangCallingConv {
     ZigClangCallingConv_SpirFunction, // default for OpenCL functions on SPIR target
     ZigClangCallingConv_OpenCLKernel, // inferred for OpenCL kernels
     ZigClangCallingConv_Swift,        // __attribute__((swiftcall))
+    ZigClangCallingConv_SwiftAsync,   // __attribute__((swiftasynccall))
     ZigClangCallingConv_PreserveMost, // __attribute__((preserve_most))
     ZigClangCallingConv_PreserveAll,  // __attribute__((preserve_all))
     ZigClangCallingConv_AArch64VectorCall, // __attribute__((aarch64_vector_pcs))
diff --git a/src/zig_clang_cc1_main.cpp b/src/zig_clang_cc1_main.cpp
index 0918860015..396d6ff529 100644
--- a/src/zig_clang_cc1_main.cpp
+++ b/src/zig_clang_cc1_main.cpp
@@ -203,6 +203,12 @@ int cc1_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
   TextDiagnosticBuffer *DiagsBuffer = new TextDiagnosticBuffer;
   DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagsBuffer);
+
+  // Setup round-trip remarks for the DiagnosticsEngine used in CreateFromArgs.
+  if (find(Argv, StringRef("-Rround-trip-cc1-args")) != Argv.end())
+    Diags.setSeverity(diag::remark_cc1_round_trip_generated,
+                      diag::Severity::Remark, {});
+
   bool Success = CompilerInvocation::CreateFromArgs(Clang->getInvocation(),
                                                     Argv, Diags, Argv0);
 
@@ -248,12 +254,9 @@ int cc1_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
   if (llvm::timeTraceProfilerEnabled()) {
     SmallString<128> Path(Clang->getFrontendOpts().OutputFile);
     llvm::sys::path::replace_extension(Path, "json");
-    if (auto profilerOutput =
-            Clang->createOutputFile(Path.str(),
-                                    /*Binary=*/false,
-                                    /*RemoveFileOnSignal=*/false,
-                                    /*useTemporary=*/false)) {
-
+    if (auto profilerOutput = Clang->createOutputFile(
+            Path.str(), /*Binary=*/false, /*RemoveFileOnSignal=*/false,
+            /*useTemporary=*/false)) {
       llvm::timeTraceProfilerWrite(*profilerOutput);
       // FIXME(ibiryukov): make profilerOutput flush in destructor instead.
       profilerOutput->flush();
diff --git a/src/zig_clang_cc1as_main.cpp b/src/zig_clang_cc1as_main.cpp
index de71026fbf..086ce0ea77 100644
--- a/src/zig_clang_cc1as_main.cpp
+++ b/src/zig_clang_cc1as_main.cpp
@@ -91,6 +91,7 @@ struct AssemblerInvocation {
   unsigned SaveTemporaryLabels : 1;
   unsigned GenDwarfForAssembly : 1;
   unsigned RelaxELFRelocations : 1;
+  unsigned Dwarf64 : 1;
   unsigned DwarfVersion;
   std::string DwarfDebugFlags;
   std::string DwarfDebugProducer;
@@ -160,6 +161,7 @@ public:
     FatalWarnings = 0;
     NoWarn = 0;
     IncrementalLinkerCompatible = 0;
+    Dwarf64 = 0;
     DwarfVersion = 0;
     EmbedBitcode = 0;
   }
@@ -231,13 +233,16 @@ bool AssemblerInvocation::CreateFromArgs(AssemblerInvocation &Opts,
   }
 
   Opts.RelaxELFRelocations = Args.hasArg(OPT_mrelax_relocations);
+  if (auto *DwarfFormatArg = Args.getLastArg(OPT_gdwarf64, OPT_gdwarf32))
+    Opts.Dwarf64 = DwarfFormatArg->getOption().matches(OPT_gdwarf64);
   Opts.DwarfVersion = getLastArgIntValue(Args, OPT_dwarf_version_EQ, 2, Diags);
   Opts.DwarfDebugFlags =
       std::string(Args.getLastArgValue(OPT_dwarf_debug_flags));
   Opts.DwarfDebugProducer =
       std::string(Args.getLastArgValue(OPT_dwarf_debug_producer));
-  Opts.DebugCompilationDir =
-      std::string(Args.getLastArgValue(OPT_fdebug_compilation_dir));
+  if (const Arg *A = Args.getLastArg(options::OPT_ffile_compilation_dir_EQ,
+                                     options::OPT_fdebug_compilation_dir_EQ))
+    Opts.DebugCompilationDir = A->getValue();
   Opts.MainFileName = std::string(Args.getLastArgValue(OPT_main_file_name));
 
   for (const auto &Arg : Args.getAllArgValues(OPT_fdebug_prefix_map_EQ)) {
@@ -319,7 +324,7 @@ getOutputStream(StringRef Path, DiagnosticsEngine &Diags, bool Binary) {
 
   std::error_code EC;
   auto Out = std::make_unique<raw_fd_ostream>(
-      Path, EC, (Binary ? sys::fs::OF_None : sys::fs::OF_Text));
+      Path, EC, (Binary ? sys::fs::OF_None : sys::fs::OF_TextWithCRLF));
   if (EC) {
     Diags.Report(diag::err_fe_unable_to_open_output) << Path << EC.message();
     return nullptr;
@@ -328,8 +333,8 @@ getOutputStream(StringRef Path, DiagnosticsEngine &Diags, bool Binary) {
   return Out;
 }
 
-static bool ExecuteAssembler(AssemblerInvocation &Opts,
-                             DiagnosticsEngine &Diags) {
+static bool ExecuteAssemblerImpl(AssemblerInvocation &Opts,
+                                 DiagnosticsEngine &Diags) {
   // Get the target specific parser.
   std::string Error;
   const Target *TheTarget = TargetRegistry::lookupTarget(Opts.Triple, Error);
@@ -337,7 +342,7 @@ static bool ExecuteAssembler(AssemblerInvocation &Opts,
     return Diags.Report(diag::err_target_unknown_triple) << Opts.Triple;
 
   ErrorOr<std::unique_ptr<MemoryBuffer>> Buffer =
-      MemoryBuffer::getFileOrSTDIN(Opts.InputFile);
+      MemoryBuffer::getFileOrSTDIN(Opts.InputFile, /*IsText=*/true);
 
   if (std::error_code EC = Buffer.getError()) {
     Error = EC.message();
@@ -378,11 +383,15 @@ static bool ExecuteAssembler(AssemblerInvocation &Opts,
   if (!Opts.SplitDwarfOutput.empty())
     DwoOS = getOutputStream(Opts.SplitDwarfOutput, Diags, IsBinary);
 
-  // FIXME: This is not pretty. MCContext has a ptr to MCObjectFileInfo and
-  // MCObjectFileInfo needs a MCContext reference in order to initialize itself.
-  std::unique_ptr<MCObjectFileInfo> MOFI(new MCObjectFileInfo());
+  // Build up the feature string from the target feature list.
+  std::string FS = llvm::join(Opts.Features, ",");
 
-  MCContext Ctx(MAI.get(), MRI.get(), MOFI.get(), &SrcMgr, &MCOptions);
+  std::unique_ptr<MCSubtargetInfo> STI(
+      TheTarget->createMCSubtargetInfo(Opts.Triple, Opts.CPU, FS));
+  assert(STI && "Unable to create subtarget info!");
+
+  MCContext Ctx(Triple(Opts.Triple), MAI.get(), MRI.get(), STI.get(), &SrcMgr,
+                &MCOptions);
 
   bool PIC = false;
   if (Opts.RelocationModel == "static") {
@@ -395,7 +404,12 @@ static bool ExecuteAssembler(AssemblerInvocation &Opts,
     PIC = false;
   }
 
-  MOFI->InitMCObjectFileInfo(Triple(Opts.Triple), PIC, Ctx);
+  // FIXME: This is not pretty. MCContext has a ptr to MCObjectFileInfo and
+  // MCObjectFileInfo needs a MCContext reference in order to initialize itself.
+  std::unique_ptr<MCObjectFileInfo> MOFI(
+      TheTarget->createMCObjectFileInfo(Ctx, PIC));
+  Ctx.setObjectFileInfo(MOFI.get());
+
   if (Opts.SaveTemporaryLabels)
     Ctx.setAllowTemporaryLabels(false);
   if (Opts.GenDwarfForAssembly)
@@ -417,23 +431,17 @@ static bool ExecuteAssembler(AssemblerInvocation &Opts,
       Ctx.addDebugPrefixMapEntry(KV.first, KV.second);
   if (!Opts.MainFileName.empty())
     Ctx.setMainFileName(StringRef(Opts.MainFileName));
+  Ctx.setDwarfFormat(Opts.Dwarf64 ? dwarf::DWARF64 : dwarf::DWARF32);
   Ctx.setDwarfVersion(Opts.DwarfVersion);
   if (Opts.GenDwarfForAssembly)
     Ctx.setGenDwarfRootFile(Opts.InputFile,
                             SrcMgr.getMemoryBuffer(BufferIndex)->getBuffer());
 
-  // Build up the feature string from the target feature list.
-  std::string FS = llvm::join(Opts.Features, ",");
-
   std::unique_ptr<MCStreamer> Str;
 
   std::unique_ptr<MCInstrInfo> MCII(TheTarget->createMCInstrInfo());
   assert(MCII && "Unable to create instruction info!");
 
-  std::unique_ptr<MCSubtargetInfo> STI(
-      TheTarget->createMCSubtargetInfo(Opts.Triple, Opts.CPU, FS));
-  assert(STI && "Unable to create subtarget info!");
-
   raw_pwrite_stream *Out = FDOS.get();
   std::unique_ptr<buffer_ostream> BOS;
 
@@ -487,8 +495,7 @@ static bool ExecuteAssembler(AssemblerInvocation &Opts,
 
   // When -fembed-bitcode is passed to clang_as, a 1-byte marker
   // is emitted in __LLVM,__asm section if the object file is MachO format.
-  if (Opts.EmbedBitcode && Ctx.getObjectFileInfo()->getObjectFileType() ==
-                               MCObjectFileInfo::IsMachO) {
+  if (Opts.EmbedBitcode && Ctx.getObjectFileType() == MCContext::IsMachO) {
     MCSection *AsmLabel = Ctx.getMachOSection(
         "__LLVM", "__asm", MachO::S_REGULAR, 4, SectionKind::getReadOnly());
     Str.get()->SwitchSection(AsmLabel);
@@ -525,12 +532,12 @@ static bool ExecuteAssembler(AssemblerInvocation &Opts,
     Failed = Parser->Run(Opts.NoInitialTextSection);
   }
 
-  // Parser has a reference to the output stream (Str), so close Parser first.
-  Parser.reset();
-  Str.reset();
-  // Close the output stream early.
-  BOS.reset();
-  FDOS.reset();
+  return Failed;
+}
+
+static bool ExecuteAssembler(AssemblerInvocation &Opts,
+                             DiagnosticsEngine &Diags) {
+  bool Failed = ExecuteAssemblerImpl(Opts, Diags);
 
   // Delete output file if there were errors.
   if (Failed) {
@@ -578,7 +585,7 @@ int cc1as_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
     return 1;
 
   if (Asm.ShowHelp) {
-    getDriverOptTable().PrintHelp(
+    getDriverOptTable().printHelp(
         llvm::outs(), "clang -cc1as [options] file...",
         "Clang Integrated Assembler",
         /*Include=*/driver::options::CC1AsOption, /*Exclude=*/0,
diff --git a/src/zig_clang_driver.cpp b/src/zig_clang_driver.cpp
index e358fea83a..3c38250df3 100644
--- a/src/zig_clang_driver.cpp
+++ b/src/zig_clang_driver.cpp
@@ -242,20 +242,28 @@ static void getCLEnvVarOptions(std::string &EnvValue, llvm::StringSaver &Saver,
 }
 
 static void SetBackdoorDriverOutputsFromEnvVars(Driver &TheDriver) {
-  // Handle CC_PRINT_OPTIONS and CC_PRINT_OPTIONS_FILE.
-  TheDriver.CCPrintOptions = !!::getenv("CC_PRINT_OPTIONS");
-  if (TheDriver.CCPrintOptions)
-    TheDriver.CCPrintOptionsFilename = ::getenv("CC_PRINT_OPTIONS_FILE");
-
-  // Handle CC_PRINT_HEADERS and CC_PRINT_HEADERS_FILE.
-  TheDriver.CCPrintHeaders = !!::getenv("CC_PRINT_HEADERS");
-  if (TheDriver.CCPrintHeaders)
-    TheDriver.CCPrintHeadersFilename = ::getenv("CC_PRINT_HEADERS_FILE");
-
-  // Handle CC_LOG_DIAGNOSTICS and CC_LOG_DIAGNOSTICS_FILE.
-  TheDriver.CCLogDiagnostics = !!::getenv("CC_LOG_DIAGNOSTICS");
-  if (TheDriver.CCLogDiagnostics)
-    TheDriver.CCLogDiagnosticsFilename = ::getenv("CC_LOG_DIAGNOSTICS_FILE");
+  auto CheckEnvVar = [](const char *EnvOptSet, const char *EnvOptFile,
+                        std::string &OptFile) {
+    bool OptSet = !!::getenv(EnvOptSet);
+    if (OptSet) {
+      if (const char *Var = ::getenv(EnvOptFile))
+        OptFile = Var;
+    }
+    return OptSet;
+  };
+
+  TheDriver.CCPrintOptions =
+      CheckEnvVar("CC_PRINT_OPTIONS", "CC_PRINT_OPTIONS_FILE",
+                  TheDriver.CCPrintOptionsFilename);
+  TheDriver.CCPrintHeaders =
+      CheckEnvVar("CC_PRINT_HEADERS", "CC_PRINT_HEADERS_FILE",
+                  TheDriver.CCPrintHeadersFilename);
+  TheDriver.CCLogDiagnostics =
+      CheckEnvVar("CC_LOG_DIAGNOSTICS", "CC_LOG_DIAGNOSTICS_FILE",
+                  TheDriver.CCLogDiagnosticsFilename);
+  TheDriver.CCPrintProcessStats =
+      CheckEnvVar("CC_PRINT_PROC_STAT", "CC_PRINT_PROC_STAT_FILE",
+                  TheDriver.CCPrintStatReportFilename);
 }
 
 static void FixupDiagPrefixExeName(TextDiagnosticPrinter *DiagClient,
@@ -263,7 +271,7 @@ static void FixupDiagPrefixExeName(TextDiagnosticPrinter *DiagClient,
   // If the clang binary happens to be named cl.exe for compatibility reasons,
   // use clang-cl.exe as the prefix to avoid confusion between clang and MSVC.
   StringRef ExeBasename(llvm::sys::path::stem(Path));
-  if (ExeBasename.equals_lower("cl"))
+  if (ExeBasename.equals_insensitive("cl"))
     ExeBasename = "clang-cl";
   DiagClient->setPrefix(std::string(ExeBasename));
 }
@@ -335,56 +343,49 @@ static int ExecuteCC1Tool(SmallVectorImpl<const char *> &ArgV) {
   return 1;
 }
 
-extern "C" int ZigClang_main(int argc_, const char **argv_);
-int ZigClang_main(int argc_, const char **argv_) {
+extern "C" int ZigClang_main(int Argc, const char **Argv);
+int ZigClang_main(int Argc, const char **Argv) {
   noteBottomOfStack();
-
-  // ZIG MOD: On windows, InitLLVM calls GetCommandLineW(),
+  // ZIG PATCH: On Windows, InitLLVM calls GetCommandLineW(),
   // and overwrites the args.  We don't want it to do that,
   // and we also don't need the signal handlers it installs
   // (we have our own already), so we just use llvm_shutdown_obj
   // instead.
-  // llvm::InitLLVM X(argc_, argv_);
+  // llvm::InitLLVM X(Argc, Argv);
   llvm::llvm_shutdown_obj X;
 
   llvm::setBugReportMsg("PLEASE submit a bug report to " BUG_REPORT_URL
                         " and include the crash backtrace, preprocessed "
                         "source, and associated run script.\n");
-  size_t argv_offset = (strcmp(argv_[1], "-cc1") == 0 || strcmp(argv_[1], "-cc1as") == 0) ? 0 : 1;
-  SmallVector<const char *, 256> argv(argv_ + argv_offset, argv_ + argc_);
+  size_t argv_offset = (strcmp(Argv[1], "-cc1") == 0 || strcmp(Argv[1], "-cc1as") == 0) ? 0 : 1;
+  SmallVector<const char *, 256> Args(Argv + argv_offset, Argv + Argc);
 
   if (llvm::sys::Process::FixupStandardFileDescriptors())
     return 1;
 
   llvm::InitializeAllTargets();
-  auto TargetAndMode = ToolChain::getTargetAndModeFromProgramName(argv[0]);
 
   llvm::BumpPtrAllocator A;
   llvm::StringSaver Saver(A);
 
   // Parse response files using the GNU syntax, unless we're in CL mode. There
-  // are two ways to put clang in CL compatibility mode: argv[0] is either
+  // are two ways to put clang in CL compatibility mode: Args[0] is either
   // clang-cl or cl, or --driver-mode=cl is on the command line. The normal
   // command line parsing can't happen until after response file parsing, so we
   // have to manually search for a --driver-mode=cl argument the hard way.
   // Finally, our -cc1 tools don't care which tokenization mode we use because
   // response files written by clang will tokenize the same way in either mode.
-  bool ClangCLMode = false;
-  if (StringRef(TargetAndMode.DriverMode).equals("--driver-mode=cl") ||
-      llvm::find_if(argv, [](const char *F) {
-        return F && strcmp(F, "--driver-mode=cl") == 0;
-      }) != argv.end()) {
-    ClangCLMode = true;
-  }
+  bool ClangCLMode =
+      IsClangCL(getDriverMode(Args[0], llvm::makeArrayRef(Args).slice(1)));
   enum { Default, POSIX, Windows } RSPQuoting = Default;
-  for (const char *F : argv) {
+  for (const char *F : Args) {
     if (strcmp(F, "--rsp-quoting=posix") == 0)
       RSPQuoting = POSIX;
     else if (strcmp(F, "--rsp-quoting=windows") == 0)
       RSPQuoting = Windows;
   }
 
-  // Determines whether we want nullptr markers in argv to indicate response
+  // Determines whether we want nullptr markers in Args to indicate response
   // files end-of-lines. We only use this for the /LINK driver argument with
   // clang-cl.exe on Windows.
   bool MarkEOLs = ClangCLMode;
@@ -395,31 +396,31 @@ int ZigClang_main(int argc_, const char **argv_) {
   else
     Tokenizer = &llvm::cl::TokenizeGNUCommandLine;
 
-  if (MarkEOLs && argv.size() > 1 && StringRef(argv[1]).startswith("-cc1"))
+  if (MarkEOLs && Args.size() > 1 && StringRef(Args[1]).startswith("-cc1"))
     MarkEOLs = false;
-  llvm::cl::ExpandResponseFiles(Saver, Tokenizer, argv, MarkEOLs);
+  llvm::cl::ExpandResponseFiles(Saver, Tokenizer, Args, MarkEOLs);
 
   // Handle -cc1 integrated tools, even if -cc1 was expanded from a response
   // file.
-  auto FirstArg = std::find_if(argv.begin() + 1, argv.end(),
+  auto FirstArg = std::find_if(Args.begin() + 1, Args.end(),
                                [](const char *A) { return A != nullptr; });
-  if (FirstArg != argv.end() && StringRef(*FirstArg).startswith("-cc1")) {
+  if (FirstArg != Args.end() && StringRef(*FirstArg).startswith("-cc1")) {
     // If -cc1 came from a response file, remove the EOL sentinels.
     if (MarkEOLs) {
-      auto newEnd = std::remove(argv.begin(), argv.end(), nullptr);
-      argv.resize(newEnd - argv.begin());
+      auto newEnd = std::remove(Args.begin(), Args.end(), nullptr);
+      Args.resize(newEnd - Args.begin());
     }
-    return ExecuteCC1Tool(argv);
+    return ExecuteCC1Tool(Args);
   }
 
   // Handle options that need handling before the real command line parsing in
   // Driver::BuildCompilation()
   bool CanonicalPrefixes = true;
-  for (int i = 1, size = argv.size(); i < size; ++i) {
+  for (int i = 1, size = Args.size(); i < size; ++i) {
     // Skip end-of-line response file markers
-    if (argv[i] == nullptr)
+    if (Args[i] == nullptr)
       continue;
-    if (StringRef(argv[i]) == "-no-canonical-prefixes") {
+    if (StringRef(Args[i]) == "-no-canonical-prefixes") {
       CanonicalPrefixes = false;
       break;
     }
@@ -435,7 +436,7 @@ int ZigClang_main(int argc_, const char **argv_) {
       getCLEnvVarOptions(OptCL.getValue(), Saver, PrependedOpts);
 
       // Insert right after the program name to prepend to the argument list.
-      argv.insert(argv.begin() + 1, PrependedOpts.begin(), PrependedOpts.end());
+      Args.insert(Args.begin() + 1, PrependedOpts.begin(), PrependedOpts.end());
     }
     // Arguments in "_CL_" are appended.
     llvm::Optional<std::string> Opt_CL_ = llvm::sys::Process::GetEnv("_CL_");
@@ -444,7 +445,7 @@ int ZigClang_main(int argc_, const char **argv_) {
       getCLEnvVarOptions(Opt_CL_.getValue(), Saver, AppendedOpts);
 
       // Insert at the end of the argument list to append.
-      argv.append(AppendedOpts.begin(), AppendedOpts.end());
+      Args.append(AppendedOpts.begin(), AppendedOpts.end());
     }
   }
 
@@ -453,12 +454,12 @@ int ZigClang_main(int argc_, const char **argv_) {
   // scenes.
   if (const char *OverrideStr = ::getenv("CCC_OVERRIDE_OPTIONS")) {
     // FIXME: Driver shouldn't take extra initial argument.
-    ApplyQAOverride(argv, OverrideStr, SavedStrings);
+    ApplyQAOverride(Args, OverrideStr, SavedStrings);
   }
 
-  // Pass local param `argv_[0]` as fallback.
+  // Pass local param `Argv[0]` as fallback.
   // See https://github.com/ziglang/zig/pull/3292 .
-  std::string Path = GetExecutablePath(argv_[0], CanonicalPrefixes);
+  std::string Path = GetExecutablePath(Argv[0], CanonicalPrefixes);
 
   // Whether the cc1 tool should be called inside the current process, or if we
   // should spawn a new clang subprocess (old behavior).
@@ -467,7 +468,7 @@ int ZigClang_main(int argc_, const char **argv_) {
   bool UseNewCC1Process;
 
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts =
-      CreateAndPopulateDiagOpts(argv, UseNewCC1Process);
+      CreateAndPopulateDiagOpts(Args, UseNewCC1Process);
 
   TextDiagnosticPrinter *DiagClient
     = new TextDiagnosticPrinter(llvm::errs(), &*DiagOpts);
@@ -488,10 +489,11 @@ int ZigClang_main(int argc_, const char **argv_) {
   ProcessWarningOptions(Diags, *DiagOpts, /*ReportDiags=*/false);
 
   Driver TheDriver(Path, llvm::sys::getDefaultTargetTriple(), Diags);
-  SetInstallDir(argv, TheDriver, CanonicalPrefixes);
+  SetInstallDir(Args, TheDriver, CanonicalPrefixes);
+  auto TargetAndMode = ToolChain::getTargetAndModeFromProgramName(Args[0]);
   TheDriver.setTargetAndMode(TargetAndMode);
 
-  insertTargetAndModeArgs(TargetAndMode, argv, SavedStrings);
+  insertTargetAndModeArgs(TargetAndMode, Args, SavedStrings);
 
   SetBackdoorDriverOutputsFromEnvVars(TheDriver);
 
@@ -501,7 +503,7 @@ int ZigClang_main(int argc_, const char **argv_) {
     llvm::CrashRecoveryContext::Enable();
   }
 
-  std::unique_ptr<Compilation> C(TheDriver.BuildCompilation(argv));
+  std::unique_ptr<Compilation> C(TheDriver.BuildCompilation(Args));
   int Res = 1;
   bool IsCrash = false;
   if (C && !C->containsError()) {
diff --git a/src/zig_llvm-ar.cpp b/src/zig_llvm-ar.cpp
index 107f500fcb..9516af4096 100644
--- a/src/zig_llvm-ar.cpp
+++ b/src/zig_llvm-ar.cpp
@@ -1,263 +1,3 @@
-// In this file is copy+pasted WindowsSupport.h from LLVM 12.0.1-rc1.
-// This is so that we can patch it. The upstream sources are incorrectly
-// including "llvm/Config/config.h" which is a private header and thus not
-// available in the include files distributed with LLVM.
-// The patch here changes it to include "llvm/Config/config.h" instead.
-// Patch submitted upstream: https://reviews.llvm.org/D103370
-#if !defined(_WIN32)
-#define LLVM_SUPPORT_WINDOWSSUPPORT_H
-#endif
-
-//===- WindowsSupport.h - Common Windows Include File -----------*- 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 defines things specific to Windows implementations.  In addition to
-// providing some helpers for working with win32 APIs, this header wraps
-// <windows.h> with some portability macros.  Always include WindowsSupport.h
-// instead of including <windows.h> directly.
-//
-//===----------------------------------------------------------------------===//
-
-//===----------------------------------------------------------------------===//
-//=== WARNING: Implementation here must contain only generic Win32 code that
-//===          is guaranteed to work on *all* Win32 variants.
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_SUPPORT_WINDOWSSUPPORT_H
-#define LLVM_SUPPORT_WINDOWSSUPPORT_H
-
-// mingw-w64 tends to define it as 0x0502 in its headers.
-#undef _WIN32_WINNT
-#undef _WIN32_IE
-
-// Require at least Windows 7 API.
-#define _WIN32_WINNT 0x0601
-#define _WIN32_IE    0x0800 // MinGW at it again. FIXME: verify if still needed.
-#define WIN32_LEAN_AND_MEAN
-#ifndef NOMINMAX
-#define NOMINMAX
-#endif
-
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringExtras.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/Twine.h"
-#include "llvm/Config/llvm-config.h" // Get build system configuration settings
-#include "llvm/Support/Allocator.h"
-#include "llvm/Support/Chrono.h"
-#include "llvm/Support/Compiler.h"
-#include "llvm/Support/ErrorHandling.h"
-#include "llvm/Support/VersionTuple.h"
-#include <cassert>
-#include <string>
-#include <system_error>
-#include <windows.h>
-
-// Must be included after windows.h
-#include <wincrypt.h>
-
-namespace llvm {
-
-/// Determines if the program is running on Windows 8 or newer. This
-/// reimplements one of the helpers in the Windows 8.1 SDK, which are intended
-/// to supercede raw calls to GetVersionEx. Old SDKs, Cygwin, and MinGW don't
-/// yet have VersionHelpers.h, so we have our own helper.
-bool RunningWindows8OrGreater();
-
-/// Returns the Windows version as Major.Minor.0.BuildNumber. Uses
-/// RtlGetVersion or GetVersionEx under the hood depending on what is available.
-/// GetVersionEx is deprecated, but this API exposes the build number which can
-/// be useful for working around certain kernel bugs.
-llvm::VersionTuple GetWindowsOSVersion();
-
-bool MakeErrMsg(std::string *ErrMsg, const std::string &prefix);
-
-// Include GetLastError() in a fatal error message.
-LLVM_ATTRIBUTE_NORETURN inline void ReportLastErrorFatal(const char *Msg) {
-  std::string ErrMsg;
-  MakeErrMsg(&ErrMsg, Msg);
-  llvm::report_fatal_error(ErrMsg);
-}
-
-template <typename HandleTraits>
-class ScopedHandle {
-  typedef typename HandleTraits::handle_type handle_type;
-  handle_type Handle;
-
-  ScopedHandle(const ScopedHandle &other) = delete;
-  void operator=(const ScopedHandle &other) = delete;
-public:
-  ScopedHandle()
-    : Handle(HandleTraits::GetInvalid()) {}
-
-  explicit ScopedHandle(handle_type h)
-    : Handle(h) {}
-
-  ~ScopedHandle() {
-    if (HandleTraits::IsValid(Handle))
-      HandleTraits::Close(Handle);
-  }
-
-  handle_type take() {
-    handle_type t = Handle;
-    Handle = HandleTraits::GetInvalid();
-    return t;
-  }
-
-  ScopedHandle &operator=(handle_type h) {
-    if (HandleTraits::IsValid(Handle))
-      HandleTraits::Close(Handle);
-    Handle = h;
-    return *this;
-  }
-
-  // True if Handle is valid.
-  explicit operator bool() const {
-    return HandleTraits::IsValid(Handle) ? true : false;
-  }
-
-  operator handle_type() const {
-    return Handle;
-  }
-};
-
-struct CommonHandleTraits {
-  typedef HANDLE handle_type;
-
-  static handle_type GetInvalid() {
-    return INVALID_HANDLE_VALUE;
-  }
-
-  static void Close(handle_type h) {
-    ::CloseHandle(h);
-  }
-
-  static bool IsValid(handle_type h) {
-    return h != GetInvalid();
-  }
-};
-
-struct JobHandleTraits : CommonHandleTraits {
-  static handle_type GetInvalid() {
-    return NULL;
-  }
-};
-
-struct CryptContextTraits : CommonHandleTraits {
-  typedef HCRYPTPROV handle_type;
-
-  static handle_type GetInvalid() {
-    return 0;
-  }
-
-  static void Close(handle_type h) {
-    ::CryptReleaseContext(h, 0);
-  }
-
-  static bool IsValid(handle_type h) {
-    return h != GetInvalid();
-  }
-};
-
-struct RegTraits : CommonHandleTraits {
-  typedef HKEY handle_type;
-
-  static handle_type GetInvalid() {
-    return NULL;
-  }
-
-  static void Close(handle_type h) {
-    ::RegCloseKey(h);
-  }
-
-  static bool IsValid(handle_type h) {
-    return h != GetInvalid();
-  }
-};
-
-struct FindHandleTraits : CommonHandleTraits {
-  static void Close(handle_type h) {
-    ::FindClose(h);
-  }
-};
-
-struct FileHandleTraits : CommonHandleTraits {};
-
-typedef ScopedHandle<CommonHandleTraits> ScopedCommonHandle;
-typedef ScopedHandle<FileHandleTraits>   ScopedFileHandle;
-typedef ScopedHandle<CryptContextTraits> ScopedCryptContext;
-typedef ScopedHandle<RegTraits>          ScopedRegHandle;
-typedef ScopedHandle<FindHandleTraits>   ScopedFindHandle;
-typedef ScopedHandle<JobHandleTraits>    ScopedJobHandle;
-
-template <class T>
-class SmallVectorImpl;
-
-template <class T>
-typename SmallVectorImpl<T>::const_pointer
-c_str(SmallVectorImpl<T> &str) {
-  str.push_back(0);
-  str.pop_back();
-  return str.data();
-}
-
-namespace sys {
-
-inline std::chrono::nanoseconds toDuration(FILETIME Time) {
-  ULARGE_INTEGER TimeInteger;
-  TimeInteger.LowPart = Time.dwLowDateTime;
-  TimeInteger.HighPart = Time.dwHighDateTime;
-
-  // FILETIME's are # of 100 nanosecond ticks (1/10th of a microsecond)
-  return std::chrono::nanoseconds(100 * TimeInteger.QuadPart);
-}
-
-inline TimePoint<> toTimePoint(FILETIME Time) {
-  ULARGE_INTEGER TimeInteger;
-  TimeInteger.LowPart = Time.dwLowDateTime;
-  TimeInteger.HighPart = Time.dwHighDateTime;
-
-  // Adjust for different epoch
-  TimeInteger.QuadPart -= 11644473600ll * 10000000;
-
-  // FILETIME's are # of 100 nanosecond ticks (1/10th of a microsecond)
-  return TimePoint<>(std::chrono::nanoseconds(100 * TimeInteger.QuadPart));
-}
-
-inline FILETIME toFILETIME(TimePoint<> TP) {
-  ULARGE_INTEGER TimeInteger;
-  TimeInteger.QuadPart = TP.time_since_epoch().count() / 100;
-  TimeInteger.QuadPart += 11644473600ll * 10000000;
-
-  FILETIME Time;
-  Time.dwLowDateTime = TimeInteger.LowPart;
-  Time.dwHighDateTime = TimeInteger.HighPart;
-  return Time;
-}
-
-namespace windows {
-// Returns command line arguments. Unlike arguments given to main(),
-// this function guarantees that the returned arguments are encoded in
-// UTF-8 regardless of the current code page setting.
-std::error_code GetCommandLineArguments(SmallVectorImpl<const char *> &Args,
-                                        BumpPtrAllocator &Alloc);
-
-/// Convert UTF-8 path to a suitable UTF-16 path for use with the Win32 Unicode
-/// File API.
-std::error_code widenPath(const Twine &Path8, SmallVectorImpl<wchar_t> &Path16,
-                          size_t MaxPathLen = MAX_PATH);
-
-} // end namespace windows
-} // end namespace sys
-} // end namespace llvm.
-
-#endif
-
 //===-- llvm-ar.cpp - LLVM archive librarian utility ----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
@@ -386,9 +126,9 @@ MODIFIERS:
 )";
 
 static void printHelpMessage() {
-  if (Stem.contains_lower("ranlib"))
+  if (Stem.contains_insensitive("ranlib"))
     outs() << RanlibHelp;
-  else if (Stem.contains_lower("ar"))
+  else if (Stem.contains_insensitive("ar"))
     outs() << ArHelp;
 }
 
@@ -530,7 +270,8 @@ static void getArchive() {
 }
 
 static object::Archive &readLibrary(const Twine &Library) {
-  auto BufOrErr = MemoryBuffer::getFile(Library, -1, false);
+  auto BufOrErr = MemoryBuffer::getFile(Library, /*IsText=*/false,
+                                        /*RequiresNullTerminator=*/false);
   failIfError(BufOrErr.getError(), "could not open library " + Library);
   ArchiveBuffers.push_back(std::move(*BufOrErr));
   auto LibOrErr =
@@ -1255,8 +996,8 @@ static void performOperation(ArchiveOperation Operation,
 static int performOperation(ArchiveOperation Operation,
                             std::vector<NewArchiveMember> *NewMembers) {
   // Create or open the archive object.
-  ErrorOr<std::unique_ptr<MemoryBuffer>> Buf =
-      MemoryBuffer::getFile(ArchiveName, -1, false);
+  ErrorOr<std::unique_ptr<MemoryBuffer>> Buf = MemoryBuffer::getFile(
+      ArchiveName, /*IsText=*/false, /*RequiresNullTerminator=*/false);
   std::error_code EC = Buf.getError();
   if (EC && EC != errc::no_such_file_or_directory)
     fail("unable to open '" + ArchiveName + "': " + EC.message());
@@ -1522,7 +1263,7 @@ static int ranlib_main(int argc, char **argv) {
 
 extern "C" int ZigLlvmAr_main(int argc, char **argv);
 int ZigLlvmAr_main(int argc, char **argv) {
-  // ZIG MOD: On windows, InitLLVM calls GetCommandLineW(),
+  // ZIG PATCH: On Windows, InitLLVM calls GetCommandLineW(),
   // and overwrites the args.  We don't want it to do that,
   // and we also don't need the signal handlers it installs
   // (we have our own already), so we just use llvm_shutdown_obj
@@ -1543,7 +1284,7 @@ int ZigLlvmAr_main(int argc, char **argv) {
     // Lib.exe -> lib (see D44808, MSBuild runs Lib.exe)
     // dlltool.exe -> dlltool
     // arm-pokymllib32-linux-gnueabi-llvm-ar-10 -> ar
-    auto I = Stem.rfind_lower(Tool);
+    auto I = Stem.rfind_insensitive(Tool);
     return I != StringRef::npos &&
            (I + Tool.size() == Stem.size() || !isAlnum(Stem[I + Tool.size()]));
   };
diff --git a/src/zig_llvm.cpp b/src/zig_llvm.cpp
index 6e136161a6..11cbf38368 100644
--- a/src/zig_llvm.cpp
+++ b/src/zig_llvm.cpp
@@ -155,10 +155,6 @@ LLVMTargetMachineRef ZigLLVMCreateTargetMachine(LLVMTargetRef T, const char *Tri
 
     TargetOptions opt;
 
-    // Work around the missing initialization of this field in the default
-    // constructor. Use -1 so that the default value is used.
-    opt.StackProtectorGuardOffset = (unsigned)-1;
-
     opt.FunctionSections = function_sections;
     switch (float_abi) {
         case ZigLLVMABITypeDefault:
@@ -240,7 +236,7 @@ bool ZigLLVMTargetMachineEmitToFile(LLVMTargetMachineRef targ_machine_ref, LLVMM
 
     if (asm_filename) {
         std::error_code EC;
-        dest_asm_ptr = new(std::nothrow) raw_fd_ostream(asm_filename, EC, sys::fs::F_None);
+        dest_asm_ptr = new(std::nothrow) raw_fd_ostream(asm_filename, EC, sys::fs::OF_None);
         if (EC) {
             *error_message = strdup((const char *)StringRef(EC.message()).bytes_begin());
             return true;
@@ -248,7 +244,7 @@ bool ZigLLVMTargetMachineEmitToFile(LLVMTargetMachineRef targ_machine_ref, LLVMM
     }
     if (bin_filename) {
         std::error_code EC;
-        dest_bin_ptr = new(std::nothrow) raw_fd_ostream(bin_filename, EC, sys::fs::F_None);
+        dest_bin_ptr = new(std::nothrow) raw_fd_ostream(bin_filename, EC, sys::fs::OF_None);
         if (EC) {
             *error_message = strdup((const char *)StringRef(EC.message()).bytes_begin());
             return true;
@@ -256,7 +252,7 @@ bool ZigLLVMTargetMachineEmitToFile(LLVMTargetMachineRef targ_machine_ref, LLVMM
     }
     if (bitcode_filename) {
         std::error_code EC;
-        dest_bitcode_ptr = new(std::nothrow) raw_fd_ostream(bitcode_filename, EC, sys::fs::F_None);
+        dest_bitcode_ptr = new(std::nothrow) raw_fd_ostream(bitcode_filename, EC, sys::fs::OF_None);
         if (EC) {
             *error_message = strdup((const char *)StringRef(EC.message()).bytes_begin());
             return true;
@@ -292,7 +288,7 @@ bool ZigLLVMTargetMachineEmitToFile(LLVMTargetMachineRef targ_machine_ref, LLVMM
     StandardInstrumentations std_instrumentations(false);
     std_instrumentations.registerCallbacks(instr_callbacks);
 
-    PassBuilder pass_builder(false, &target_machine, pipeline_opts,
+    PassBuilder pass_builder(&target_machine, pipeline_opts,
                              None, &instr_callbacks);
     using OptimizationLevel = typename PassBuilder::OptimizationLevel;
 
@@ -1077,31 +1073,6 @@ void ZigLLVMSetModuleCodeModel(LLVMModuleRef module, LLVMCodeModel code_model) {
     assert(!JIT);
 }
 
-static AtomicOrdering mapFromLLVMOrdering(LLVMAtomicOrdering Ordering) {
-    switch (Ordering) {
-        case LLVMAtomicOrderingNotAtomic: return AtomicOrdering::NotAtomic;
-        case LLVMAtomicOrderingUnordered: return AtomicOrdering::Unordered;
-        case LLVMAtomicOrderingMonotonic: return AtomicOrdering::Monotonic;
-        case LLVMAtomicOrderingAcquire: return AtomicOrdering::Acquire;
-        case LLVMAtomicOrderingRelease: return AtomicOrdering::Release;
-        case LLVMAtomicOrderingAcquireRelease: return AtomicOrdering::AcquireRelease;
-        case LLVMAtomicOrderingSequentiallyConsistent: return AtomicOrdering::SequentiallyConsistent;
-    }
-    abort();
-}
-
-LLVMValueRef ZigLLVMBuildCmpXchg(LLVMBuilderRef builder, LLVMValueRef ptr, LLVMValueRef cmp,
-        LLVMValueRef new_val, LLVMAtomicOrdering success_ordering,
-        LLVMAtomicOrdering failure_ordering, bool is_weak, bool is_single_threaded)
-{
-    AtomicCmpXchgInst *inst = unwrap(builder)->CreateAtomicCmpXchg(unwrap(ptr),
-        unwrap(cmp), unwrap(new_val),
-        mapFromLLVMOrdering(success_ordering), mapFromLLVMOrdering(failure_ordering),
-        is_single_threaded ? SyncScope::SingleThread : SyncScope::System);
-    inst->setWeak(is_weak);
-    return wrap(inst);
-}
-
 LLVMValueRef ZigLLVMBuildNSWShl(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMValueRef RHS,
         const char *name)
 {
@@ -1296,25 +1267,6 @@ int ZigLLDLinkWasm(int argc, const char **argv, bool can_exit_early) {
     return lld::wasm::link(args, can_exit_early, llvm::outs(), llvm::errs());
 }
 
-static AtomicRMWInst::BinOp toLLVMRMWBinOp(enum ZigLLVM_AtomicRMWBinOp BinOp) {
-    switch (BinOp) {
-        default:
-        case ZigLLVMAtomicRMWBinOpXchg: return AtomicRMWInst::Xchg;
-        case ZigLLVMAtomicRMWBinOpAdd: return AtomicRMWInst::Add;
-        case ZigLLVMAtomicRMWBinOpSub: return AtomicRMWInst::Sub;
-        case ZigLLVMAtomicRMWBinOpAnd: return AtomicRMWInst::And;
-        case ZigLLVMAtomicRMWBinOpNand: return AtomicRMWInst::Nand;
-        case ZigLLVMAtomicRMWBinOpOr: return AtomicRMWInst::Or;
-        case ZigLLVMAtomicRMWBinOpXor: return AtomicRMWInst::Xor;
-        case ZigLLVMAtomicRMWBinOpMax: return AtomicRMWInst::Max;
-        case ZigLLVMAtomicRMWBinOpMin: return AtomicRMWInst::Min;
-        case ZigLLVMAtomicRMWBinOpUMax: return AtomicRMWInst::UMax;
-        case ZigLLVMAtomicRMWBinOpUMin: return AtomicRMWInst::UMin;
-        case ZigLLVMAtomicRMWBinOpFAdd: return AtomicRMWInst::FAdd;
-        case ZigLLVMAtomicRMWBinOpFSub: return AtomicRMWInst::FSub;
-    }
-}
-
 inline LLVMAttributeRef wrap(Attribute Attr) {
     return reinterpret_cast<LLVMAttributeRef>(Attr.getRawPointer());
 }
@@ -1323,16 +1275,6 @@ inline Attribute unwrap(LLVMAttributeRef Attr) {
     return Attribute::fromRawPointer(Attr);
 }
 
-LLVMValueRef ZigLLVMBuildAtomicRMW(LLVMBuilderRef B, enum ZigLLVM_AtomicRMWBinOp op,
-    LLVMValueRef PTR, LLVMValueRef Val,
-    LLVMAtomicOrdering ordering, LLVMBool singleThread) 
-{
-    AtomicRMWInst::BinOp intop = toLLVMRMWBinOp(op);
-    return wrap(unwrap(B)->CreateAtomicRMW(intop, unwrap(PTR),
-        unwrap(Val), mapFromLLVMOrdering(ordering), 
-        singleThread ? SyncScope::SingleThread : SyncScope::System));
-}
-
 LLVMValueRef ZigLLVMBuildAndReduce(LLVMBuilderRef B, LLVMValueRef Val) {
     return wrap(unwrap(B)->CreateAndReduce(unwrap(Val)));
 }
@@ -1389,6 +1331,7 @@ static_assert((Triple::ArchType)ZigLLVM_bpfel == Triple::bpfel, "");
 static_assert((Triple::ArchType)ZigLLVM_bpfeb == Triple::bpfeb, "");
 static_assert((Triple::ArchType)ZigLLVM_csky == Triple::csky, "");
 static_assert((Triple::ArchType)ZigLLVM_hexagon == Triple::hexagon, "");
+static_assert((Triple::ArchType)ZigLLVM_m68k == Triple::m68k, "");
 static_assert((Triple::ArchType)ZigLLVM_mips == Triple::mips, "");
 static_assert((Triple::ArchType)ZigLLVM_mipsel == Triple::mipsel, "");
 static_assert((Triple::ArchType)ZigLLVM_mips64 == Triple::mips64, "");
@@ -1505,6 +1448,7 @@ static_assert((Triple::EnvironmentType)ZigLLVM_Android == Triple::Android, "");
 static_assert((Triple::EnvironmentType)ZigLLVM_Musl == Triple::Musl, "");
 static_assert((Triple::EnvironmentType)ZigLLVM_MuslEABI == Triple::MuslEABI, "");
 static_assert((Triple::EnvironmentType)ZigLLVM_MuslEABIHF == Triple::MuslEABIHF, "");
+static_assert((Triple::EnvironmentType)ZigLLVM_MuslX32 == Triple::MuslX32, "");
 static_assert((Triple::EnvironmentType)ZigLLVM_MSVC == Triple::MSVC, "");
 static_assert((Triple::EnvironmentType)ZigLLVM_Itanium == Triple::Itanium, "");
 static_assert((Triple::EnvironmentType)ZigLLVM_Cygnus == Triple::Cygnus, "");
diff --git a/src/zig_llvm.h b/src/zig_llvm.h
index 49a4c0e8fd..d1e4fa2556 100644
--- a/src/zig_llvm.h
+++ b/src/zig_llvm.h
@@ -149,10 +149,6 @@ ZIG_EXTERN_C LLVMValueRef ZigLLVMBuildUShlSat(LLVMBuilderRef builder, LLVMValueR
 ZIG_EXTERN_C LLVMValueRef ZigLLVMBuildSShlSat(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMValueRef RHS, const char* name);
 
 
-ZIG_EXTERN_C LLVMValueRef ZigLLVMBuildCmpXchg(LLVMBuilderRef builder, LLVMValueRef ptr, LLVMValueRef cmp,
-        LLVMValueRef new_val, LLVMAtomicOrdering success_ordering,
-        LLVMAtomicOrdering failure_ordering, bool is_weak, bool is_single_threaded);
-
 ZIG_EXTERN_C LLVMValueRef ZigLLVMBuildNSWShl(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMValueRef RHS,
         const char *name);
 ZIG_EXTERN_C LLVMValueRef ZigLLVMBuildNUWShl(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMValueRef RHS,
@@ -315,6 +311,7 @@ enum ZigLLVM_ArchType {
     ZigLLVM_bpfeb,          // eBPF or extended BPF or 64-bit BPF (big endian)
     ZigLLVM_csky,           // CSKY: csky
     ZigLLVM_hexagon,        // Hexagon: hexagon
+    ZigLLVM_m68k,           // M68k: Motorola 680x0 family
     ZigLLVM_mips,           // MIPS: mips, mipsallegrex, mipsr6
     ZigLLVM_mipsel,         // MIPSEL: mipsel, mipsallegrexe, mipsr6el
     ZigLLVM_mips64,         // MIPS64: mips64, mips64r6, mipsn32, mipsn32r6
@@ -357,7 +354,6 @@ enum ZigLLVM_ArchType {
     ZigLLVM_renderscript32, // 32-bit RenderScript
     ZigLLVM_renderscript64, // 64-bit RenderScript
     ZigLLVM_ve,             // NEC SX-Aurora Vector Engine
-
     ZigLLVM_LastArchType = ZigLLVM_ve
 };
 
@@ -442,6 +438,7 @@ enum ZigLLVM_EnvironmentType {
     ZigLLVM_Musl,
     ZigLLVM_MuslEABI,
     ZigLLVM_MuslEABIHF,
+    ZigLLVM_MuslX32,
 
     ZigLLVM_MSVC,
     ZigLLVM_Itanium,
@@ -449,7 +446,6 @@ enum ZigLLVM_EnvironmentType {
     ZigLLVM_CoreCLR,
     ZigLLVM_Simulator, // Simulator variants of other systems, e.g., Apple's iOS
     ZigLLVM_MacABI, // Mac Catalyst variant of Apple's iOS deployment target.
-
     ZigLLVM_LastEnvironmentType = ZigLLVM_MacABI
 };
 
@@ -464,26 +460,6 @@ enum ZigLLVM_ObjectFormatType {
     ZigLLVM_XCOFF,
 };
 
-enum ZigLLVM_AtomicRMWBinOp {
-    ZigLLVMAtomicRMWBinOpXchg,
-    ZigLLVMAtomicRMWBinOpAdd,
-    ZigLLVMAtomicRMWBinOpSub,
-    ZigLLVMAtomicRMWBinOpAnd,
-    ZigLLVMAtomicRMWBinOpNand,
-    ZigLLVMAtomicRMWBinOpOr,
-    ZigLLVMAtomicRMWBinOpXor,
-    ZigLLVMAtomicRMWBinOpMax,
-    ZigLLVMAtomicRMWBinOpMin,
-    ZigLLVMAtomicRMWBinOpUMax,
-    ZigLLVMAtomicRMWBinOpUMin,
-    ZigLLVMAtomicRMWBinOpFAdd,
-    ZigLLVMAtomicRMWBinOpFSub,
-};
-
-LLVMValueRef ZigLLVMBuildAtomicRMW(LLVMBuilderRef B, enum ZigLLVM_AtomicRMWBinOp op,
-    LLVMValueRef PTR, LLVMValueRef Val,
-    LLVMAtomicOrdering ordering, LLVMBool singleThread);
-
 LLVMValueRef ZigLLVMBuildAndReduce(LLVMBuilderRef B, LLVMValueRef Val);
 LLVMValueRef ZigLLVMBuildOrReduce(LLVMBuilderRef B, LLVMValueRef Val);
 LLVMValueRef ZigLLVMBuildXorReduce(LLVMBuilderRef B, LLVMValueRef Val);