Merge pull request #4509 from ziglang/sub-architecture-annihilation

sub-architecture annihilation

10 files changed, 138 insertions, 637 deletions

diff --git a/src/codegen.cpp b/src/codegen.cpp
index a28d2d469d..6e48f9be42 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -8504,25 +8504,9 @@ Buf *codegen_generate_builtin_source(CodeGen *g) {
         for (uint32_t arch_i = 0; arch_i < field_count; arch_i += 1) {
             ZigLLVM_ArchType arch = target_arch_enum(arch_i);
             const char *arch_name = target_arch_name(arch);
-            SubArchList sub_arch_list = target_subarch_list(arch);
-            if (sub_arch_list == SubArchListNone) {
-                if (arch == g->zig_target->arch) {
-                    g->target_arch_index = arch_i;
-                    cur_arch = buf_ptr(buf_sprintf("Arch.%s", arch_name));
-                }
-            } else {
-                const char *sub_arch_list_name = target_subarch_list_name(sub_arch_list);
-                if (arch == g->zig_target->arch) {
-                    size_t sub_count = target_subarch_count(sub_arch_list);
-                    for (size_t sub_i = 0; sub_i < sub_count; sub_i += 1) {
-                        ZigLLVM_SubArchType sub = target_subarch_enum(sub_arch_list, sub_i);
-                        if (sub == g->zig_target->sub_arch) {
-                            g->target_sub_arch_index = sub_i;
-                            cur_arch = buf_ptr(buf_sprintf("Arch{ .%s = Arch.%s.%s }",
-                                        arch_name, sub_arch_list_name, target_subarch_name(sub)));
-                        }
-                    }
-                }
+            if (arch == g->zig_target->arch) {
+                g->target_arch_index = arch_i;
+                cur_arch = arch_name;
             }
         }
     }
@@ -8621,17 +8605,14 @@ Buf *codegen_generate_builtin_source(CodeGen *g) {
     buf_appendf(contents, "pub const is_test = %s;\n", bool_to_str(g->is_test_build));
     buf_appendf(contents, "pub const single_threaded = %s;\n", bool_to_str(g->is_single_threaded));
     buf_appendf(contents, "pub const os = Os.%s;\n", cur_os);
-    buf_appendf(contents, "pub const arch = %s;\n", cur_arch);
+    buf_appendf(contents, "pub const arch = Arch.%s;\n", cur_arch);
     buf_appendf(contents, "pub const abi = Abi.%s;\n", cur_abi);
     {
-        buf_append_str(contents, "pub const cpu_features: CpuFeatures = ");
-        if (g->zig_target->cpu_features != nullptr) {
-            const char *ptr;
-            size_t len;
-            stage2_cpu_features_get_builtin_str(g->zig_target->cpu_features, &ptr, &len);
-            buf_append_mem(contents, ptr, len);
+        buf_append_str(contents, "pub const cpu: Cpu = ");
+        if (g->zig_target->builtin_str != nullptr) {
+            buf_append_str(contents, g->zig_target->builtin_str);
         } else {
-            buf_append_str(contents, "arch.getBaselineCpuFeatures();\n");
+            buf_append_str(contents, "Target.Cpu.baseline(arch);\n");
         }
     }
     if (g->libc_link_lib != nullptr && g->zig_target->glibc_version != nullptr) {
@@ -8730,15 +8711,11 @@ static Error define_builtin_compile_vars(CodeGen *g) {
     cache_int(&cache_hash, g->code_model);
     cache_int(&cache_hash, g->zig_target->is_native);
     cache_int(&cache_hash, g->zig_target->arch);
-    cache_int(&cache_hash, g->zig_target->sub_arch);
     cache_int(&cache_hash, g->zig_target->vendor);
     cache_int(&cache_hash, g->zig_target->os);
     cache_int(&cache_hash, g->zig_target->abi);
-    if (g->zig_target->cpu_features != nullptr) {
-        const char *ptr;
-        size_t len;
-        stage2_cpu_features_get_cache_hash(g->zig_target->cpu_features, &ptr, &len);
-        cache_str(&cache_hash, ptr);
+    if (g->zig_target->cache_hash != nullptr) {
+        cache_str(&cache_hash, g->zig_target->cache_hash);
     }
     if (g->zig_target->glibc_version != nullptr) {
         cache_int(&cache_hash, g->zig_target->glibc_version->major);
@@ -8873,9 +8850,11 @@ static void init(CodeGen *g) {
     }
 
     // Override CPU and features if defined by user.
-    if (g->zig_target->cpu_features != nullptr) {
-        target_specific_cpu_args = stage2_cpu_features_get_llvm_cpu(g->zig_target->cpu_features);
-        target_specific_features = stage2_cpu_features_get_llvm_features(g->zig_target->cpu_features);
+    if (g->zig_target->llvm_cpu_name != nullptr) {
+        target_specific_cpu_args = g->zig_target->llvm_cpu_name;
+    }
+    if (g->zig_target->llvm_cpu_features != nullptr) {
+        target_specific_features = g->zig_target->llvm_cpu_features;
     }
     if (g->verbose_llvm_cpu_features) {
         fprintf(stderr, "name=%s triple=%s\n", buf_ptr(g->root_out_name), buf_ptr(&g->llvm_triple_str));
@@ -9190,19 +9169,17 @@ void add_cc_args(CodeGen *g, ZigList<const char *> &args, const char *out_dep_pa
         args.append("-target");
         args.append(buf_ptr(&g->llvm_triple_str));
 
-        const char *llvm_cpu = stage2_cpu_features_get_llvm_cpu(g->zig_target->cpu_features);
-        if (llvm_cpu != nullptr) {
+        if (g->zig_target->llvm_cpu_name != nullptr) {
             args.append("-Xclang");
             args.append("-target-cpu");
             args.append("-Xclang");
-            args.append(llvm_cpu);
+            args.append(g->zig_target->llvm_cpu_name);
         }
-        const char *llvm_target_features = stage2_cpu_features_get_llvm_features(g->zig_target->cpu_features);
-        if (llvm_target_features != nullptr) {
+        if (g->zig_target->llvm_cpu_features != nullptr) {
             args.append("-Xclang");
             args.append("-target-feature");
             args.append("-Xclang");
-            args.append(llvm_target_features);
+            args.append(g->zig_target->llvm_cpu_features);
         }
     }
 
@@ -9638,7 +9615,6 @@ Error create_c_object_cache(CodeGen *g, CacheHash **out_cache_hash, bool verbose
     cache_list_of_str(cache_hash, g->libc_include_dir_list, g->libc_include_dir_len);
     cache_int(cache_hash, g->zig_target->is_native);
     cache_int(cache_hash, g->zig_target->arch);
-    cache_int(cache_hash, g->zig_target->sub_arch);
     cache_int(cache_hash, g->zig_target->vendor);
     cache_int(cache_hash, g->zig_target->os);
     cache_int(cache_hash, g->zig_target->abi);
@@ -10402,15 +10378,11 @@ static Error check_cache(CodeGen *g, Buf *manifest_dir, Buf *digest) {
     cache_int(ch, g->out_type);
     cache_bool(ch, g->zig_target->is_native);
     cache_int(ch, g->zig_target->arch);
-    cache_int(ch, g->zig_target->sub_arch);
     cache_int(ch, g->zig_target->vendor);
     cache_int(ch, g->zig_target->os);
     cache_int(ch, g->zig_target->abi);
-    if (g->zig_target->cpu_features != nullptr) {
-        const char *ptr;
-        size_t len;
-        stage2_cpu_features_get_cache_hash(g->zig_target->cpu_features, &ptr, &len);
-        cache_str(ch, ptr);
+    if (g->zig_target->cache_hash != nullptr) {
+        cache_str(ch, g->zig_target->cache_hash);
     }
     if (g->zig_target->glibc_version != nullptr) {
         cache_int(ch, g->zig_target->glibc_version->major);
diff --git a/src/error.cpp b/src/error.cpp
index c633e2fe67..730c6e7193 100644
--- a/src/error.cpp
+++ b/src/error.cpp
@@ -59,7 +59,6 @@ const char *err_str(Error err) {
         case ErrorIsAsync: return "is async";
         case ErrorImportOutsidePkgPath: return "import of file outside package path";
         case ErrorUnknownCpu: return "unknown CPU";
-        case ErrorUnknownSubArchitecture: return "unknown sub-architecture";
         case ErrorUnknownCpuFeature: return "unknown CPU feature";
         case ErrorInvalidCpuFeatures: return "invalid CPU features";
         case ErrorInvalidLlvmCpuFeaturesFormat: return "invalid LLVM CPU features format";
diff --git a/src/glibc.cpp b/src/glibc.cpp
index ec45b6afa7..849aac6c77 100644
--- a/src/glibc.cpp
+++ b/src/glibc.cpp
@@ -116,10 +116,8 @@ Error glibc_load_metadata(ZigGLibCAbi **out_result, Buf *zig_lib_dir, bool verbo
                     assert(opt_abi.is_some);
 
 
-                    err = target_parse_archsub(&target->arch, &target->sub_arch,
-                            (char*)opt_arch.value.ptr, opt_arch.value.len);
-                    // there's no sub arch so we might get an error, but the arch is still populated
-                    assert(err == ErrorNone || err == ErrorUnknownArchitecture);
+                    err = target_parse_arch(&target->arch, (char*)opt_arch.value.ptr, opt_arch.value.len);
+                    assert(err == ErrorNone);
 
                     target->os = OsLinux;
 
diff --git a/src/main.cpp b/src/main.cpp
index 5046c92ddd..d6148d4587 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -106,8 +106,7 @@ static int print_full_usage(const char *arg0, FILE *file, int return_code) {
         "  --override-lib-dir [arg]     override path to Zig lib directory\n"
         "  -ffunction-sections          places each function in a separate section\n"
         "  -D[macro]=[value]            define C [macro] to [value] (1 if [value] omitted)\n"
-        "  -target-cpu [cpu]            target one specific CPU by name\n"
-        "  -target-feature [features]   specify the set of CPU features to target\n"
+        "  -mcpu [cpu]                  specify target CPU and feature set\n"
         "  -code-model [default|tiny|   set target code model\n"
         "               small|kernel|\n"
         "               medium|large]\n"
@@ -238,6 +237,14 @@ static int zig_error_no_build_file(void) {
     return EXIT_FAILURE;
 }
 
+static bool str_starts_with(const char *s1, const char *s2) {
+    size_t s2_len = strlen(s2);
+    if (strlen(s1) < s2_len) {
+        return false;
+    }
+    return memcmp(s1, s2, s2_len) == 0;
+}
+
 extern "C" int ZigClang_main(int argc, char **argv);
 
 #ifdef ZIG_ENABLE_MEM_PROFILE
@@ -447,10 +454,8 @@ static int main0(int argc, char **argv) {
     WantStackCheck want_stack_check = WantStackCheckAuto;
     WantCSanitize want_sanitize_c = WantCSanitizeAuto;
     bool function_sections = false;
-    const char *cpu = nullptr;
-    const char *features = nullptr;
+    const char *mcpu = nullptr;
     CodeModel code_model = CodeModelDefault;
-    bool baseline_cpu = false;
 
     ZigList<const char *> llvm_argv = {0};
     llvm_argv.append("zig (LLVM option parsing)");
@@ -717,8 +722,8 @@ static int main0(int argc, char **argv) {
                 emit_llvm_ir = true;
             } else if (strcmp(arg, "-fno-emit-llvm-ir") == 0) {
                 emit_llvm_ir = false;
-            } else if (strcmp(arg, "-mcpu=baseline") == 0) {
-                baseline_cpu = true;
+            } else if (str_starts_with(arg, "-mcpu=")) {
+                mcpu = arg + strlen("-mcpu=");
             } else if (i + 1 >= argc) {
                 fprintf(stderr, "Expected another argument after %s\n", arg);
                 return print_error_usage(arg0);
@@ -895,10 +900,8 @@ static int main0(int argc, char **argv) {
                             , argv[i]);
                         return EXIT_FAILURE;
                     }
-                } else if (strcmp(arg, "-target-cpu") == 0) {
-                    cpu = argv[i];
-                } else if (strcmp(arg, "-target-feature") == 0) {
-                    features = argv[i];
+                } else if (strcmp(arg, "-mcpu") == 0) {
+                    mcpu = argv[i];
                 } else {
                     fprintf(stderr, "Invalid argument: %s\n", arg);
                     return print_error_usage(arg0);
@@ -974,58 +977,30 @@ static int main0(int argc, char **argv) {
     init_all_targets();
 
     ZigTarget target;
-    if (target_string == nullptr) {
-        get_native_target(&target);
+    if ((err = target_parse_triple(&target, target_string, mcpu))) {
+        fprintf(stderr, "invalid target: %s\n"
+                "See `%s targets` to display valid targets.\n", err_str(err), arg0);
+        return print_error_usage(arg0);
+    }
+    if (target_is_glibc(&target)) {
+        target.glibc_version = heap::c_allocator.create<ZigGLibCVersion>();
+
         if (target_glibc != nullptr) {
-            fprintf(stderr, "-target-glibc provided but no -target parameter\n");
-            return print_error_usage(arg0);
-        }
-        if (baseline_cpu) {
-            target.is_native = false;
-        }
-    } else {
-        if ((err = target_parse_triple(&target, target_string))) {
-            if (err == ErrorUnknownArchitecture && target.arch != ZigLLVM_UnknownArch) {
-                fprintf(stderr, "'%s' requires a sub-architecture. Try one of these:\n",
-                        target_arch_name(target.arch));
-                SubArchList sub_arch_list = target_subarch_list(target.arch);
-                size_t subarch_count = target_subarch_count(sub_arch_list);
-                for (size_t sub_i = 0; sub_i < subarch_count; sub_i += 1) {
-                    ZigLLVM_SubArchType sub = target_subarch_enum(sub_arch_list, sub_i);
-                    fprintf(stderr, "  %s%s\n", target_arch_name(target.arch), target_subarch_name(sub));
-                }
-                return print_error_usage(arg0);
-            } else {
-                fprintf(stderr, "invalid target: %s\n", err_str(err));
+            if ((err = target_parse_glibc_version(target.glibc_version, target_glibc))) {
+                fprintf(stderr, "invalid glibc version '%s': %s\n", target_glibc, err_str(err));
                 return print_error_usage(arg0);
             }
+        } else {
+            target_init_default_glibc_version(&target);
         }
-        if (target_is_glibc(&target)) {
-            target.glibc_version = heap::c_allocator.create<ZigGLibCVersion>();
-
-            if (target_glibc != nullptr) {
-                if ((err = target_parse_glibc_version(target.glibc_version, target_glibc))) {
-                    fprintf(stderr, "invalid glibc version '%s': %s\n", target_glibc, err_str(err));
-                    return print_error_usage(arg0);
-                }
-            } else {
-                target_init_default_glibc_version(&target);
-            }
-        } else if (target_glibc != nullptr) {
-            fprintf(stderr, "'%s' is not a glibc-compatible target", target_string);
-            return print_error_usage(arg0);
-        }
+    } else if (target_glibc != nullptr) {
+        fprintf(stderr, "'%s' is not a glibc-compatible target", target_string);
+        return print_error_usage(arg0);
     }
 
     Buf zig_triple_buf = BUF_INIT;
     target_triple_zig(&zig_triple_buf, &target);
 
-    const char *stage2_triple_arg = target.is_native ? nullptr : buf_ptr(&zig_triple_buf);
-    if ((err = stage2_cpu_features_parse(&target.cpu_features, stage2_triple_arg, cpu, features))) {
-        fprintf(stderr, "unable to initialize CPU features: %s\n", err_str(err));
-        return main_exit(root_progress_node, EXIT_FAILURE);
-    }
-
     // If both output_dir and enable_cache are provided, and doing build-lib, we
     // will just do a file copy at the end. This helps when bootstrapping zig from zig0
     // because we want to pass something like this:
diff --git a/src/stage2.cpp b/src/stage2.cpp
index c3abe54d77..736f11622e 100644
--- a/src/stage2.cpp
+++ b/src/stage2.cpp
@@ -4,6 +4,7 @@
 #include "stage2.h"
 #include "util.hpp"
 #include "zig_llvm.h"
+#include "target.hpp"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -90,54 +91,68 @@ void stage2_progress_complete_one(Stage2ProgressNode *node) {}
 void stage2_progress_disable_tty(Stage2Progress *progress) {}
 void stage2_progress_update_node(Stage2ProgressNode *node, size_t completed_count, size_t estimated_total_items){}
 
-struct Stage2CpuFeatures {
-    const char *llvm_cpu_name;
-    const char *llvm_cpu_features;
-    const char *builtin_str;
-    const char *cache_hash;
-};
+Error stage2_target_parse(struct ZigTarget *target, const char *zig_triple, const char *mcpu) {
+    Error err;
 
-Error stage2_cpu_features_parse(struct Stage2CpuFeatures **out, const char *zig_triple,
-        const char *cpu_name, const char *cpu_features)
-{
     if (zig_triple == nullptr) {
-        Stage2CpuFeatures *result = heap::c_allocator.create<Stage2CpuFeatures>();
-        result->llvm_cpu_name = ZigLLVMGetHostCPUName();
-        result->llvm_cpu_features = ZigLLVMGetNativeFeatures();
-        result->builtin_str = "arch.getBaselineCpuFeatures();\n";
-        result->cache_hash = "native\n\n";
-        *out = result;
-        return ErrorNone;
-    }
-    if (cpu_name == nullptr && cpu_features == nullptr) {
-        Stage2CpuFeatures *result = heap::c_allocator.create<Stage2CpuFeatures>();
-        result->builtin_str = "arch.getBaselineCpuFeatures();\n";
-        result->cache_hash = "\n\n";
-        *out = result;
-        return ErrorNone;
+        get_native_target(target);
+
+        if (mcpu == nullptr) {
+            target->llvm_cpu_name = ZigLLVMGetHostCPUName();
+            target->llvm_cpu_features = ZigLLVMGetNativeFeatures();
+            target->builtin_str = "Target.Cpu.baseline(arch);\n";
+            target->cache_hash = "native\n\n";
+        } else if (strcmp(mcpu, "baseline") == 0) {
+            target->is_native = false;
+            target->llvm_cpu_name = "";
+            target->llvm_cpu_features = "";
+            target->builtin_str = "Target.Cpu.baseline(arch);\n";
+            target->cache_hash = "baseline\n\n";
+        } else {
+            const char *msg = "stage0 can't handle CPU/features in the target";
+            stage2_panic(msg, strlen(msg));
+        }
+    } else {
+        // first initialize all to zero
+        *target = {};
+
+        SplitIterator it = memSplit(str(zig_triple), str("-"));
+
+        Optional<Slice<uint8_t>> opt_archsub = SplitIterator_next(&it);
+        Optional<Slice<uint8_t>> opt_os = SplitIterator_next(&it);
+        Optional<Slice<uint8_t>> opt_abi = SplitIterator_next(&it);
+
+        if (!opt_archsub.is_some)
+            return ErrorMissingArchitecture;
+
+        if ((err = target_parse_arch(&target->arch, (char*)opt_archsub.value.ptr, opt_archsub.value.len))) {
+            return err;
+        }
+
+        if (!opt_os.is_some)
+            return ErrorMissingOperatingSystem;
+
+        if ((err = target_parse_os(&target->os, (char*)opt_os.value.ptr, opt_os.value.len))) {
+            return err;
+        }
+
+        if (opt_abi.is_some) {
+            if ((err = target_parse_abi(&target->abi, (char*)opt_abi.value.ptr, opt_abi.value.len))) {
+                return err;
+            }
+        } else {
+            target->abi = target_default_abi(target->arch, target->os);
+        }
+
+        if (mcpu != nullptr && strcmp(mcpu, "baseline") != 0) {
+            const char *msg = "stage0 can't handle CPU/features in the target";
+            stage2_panic(msg, strlen(msg));
+        }
+        target->builtin_str = "Target.Cpu.baseline(arch);\n";
+        target->cache_hash = "\n\n";
     }
 
-    const char *msg = "stage0 called stage2_cpu_features_parse with non-null cpu name or features";
-    stage2_panic(msg, strlen(msg));
-}
-
-void stage2_cpu_features_get_cache_hash(const Stage2CpuFeatures *cpu_features,
-        const char **ptr, size_t *len)
-{
-    *ptr = cpu_features->cache_hash;
-    *len = strlen(cpu_features->cache_hash);
-}
-const char *stage2_cpu_features_get_llvm_cpu(const Stage2CpuFeatures *cpu_features) {
-    return cpu_features->llvm_cpu_name;
-}
-const char *stage2_cpu_features_get_llvm_features(const Stage2CpuFeatures *cpu_features) {
-    return cpu_features->llvm_cpu_features;
-}
-void stage2_cpu_features_get_builtin_str(const Stage2CpuFeatures *cpu_features, 
-        const char **ptr, size_t *len)
-{
-    *ptr = cpu_features->builtin_str;
-    *len = strlen(cpu_features->builtin_str);
+    return ErrorNone;
 }
 
 int stage2_cmd_targets(const char *zig_triple) {
diff --git a/src/stage2.h b/src/stage2.h
index 302cffafc6..e6db241e88 100644
--- a/src/stage2.h
+++ b/src/stage2.h
@@ -81,7 +81,6 @@ enum Error {
     ErrorIsAsync,
     ErrorImportOutsidePkgPath,
     ErrorUnknownCpu,
-    ErrorUnknownSubArchitecture,
     ErrorUnknownCpuFeature,
     ErrorInvalidCpuFeatures,
     ErrorInvalidLlvmCpuFeaturesFormat,
@@ -201,27 +200,6 @@ ZIG_EXTERN_C void stage2_progress_update_node(Stage2ProgressNode *node,
         size_t completed_count, size_t estimated_total_items);
 
 // ABI warning
-struct Stage2CpuFeatures;
-
-// ABI warning
-ZIG_EXTERN_C enum Error stage2_cpu_features_parse(struct Stage2CpuFeatures **result,
-        const char *zig_triple, const char *cpu_name, const char *cpu_features);
-
-// ABI warning
-ZIG_EXTERN_C const char *stage2_cpu_features_get_llvm_cpu(const struct Stage2CpuFeatures *cpu_features);
-
-// ABI warning
-ZIG_EXTERN_C const char *stage2_cpu_features_get_llvm_features(const struct Stage2CpuFeatures *cpu_features);
-
-// ABI warning
-ZIG_EXTERN_C void stage2_cpu_features_get_builtin_str(const struct Stage2CpuFeatures *cpu_features,
-        const char **ptr, size_t *len);
-
-// ABI warning
-ZIG_EXTERN_C void stage2_cpu_features_get_cache_hash(const struct Stage2CpuFeatures *cpu_features,
-        const char **ptr, size_t *len);
-
-// ABI warning
 ZIG_EXTERN_C int stage2_cmd_targets(const char *zig_triple);
 
 // ABI warning
@@ -296,22 +274,32 @@ struct ZigGLibCVersion {
     uint32_t patch;
 };
 
+struct Stage2TargetData;
+
 // ABI warning
 struct ZigTarget {
     enum ZigLLVM_ArchType arch;
-    enum ZigLLVM_SubArchType sub_arch;
     enum ZigLLVM_VendorType vendor;
-    Os os;
+
     enum ZigLLVM_EnvironmentType abi;
-    struct ZigGLibCVersion *glibc_version; // null means default
-    struct Stage2CpuFeatures *cpu_features;
+    Os os;
+
     bool is_native;
+
+    struct ZigGLibCVersion *glibc_version; // null means default
+
+    const char *llvm_cpu_name;
+    const char *llvm_cpu_features;
+    const char *builtin_str;
+    const char *cache_hash;
 };
 
 // ABI warning
 ZIG_EXTERN_C enum Error stage2_detect_dynamic_linker(const struct ZigTarget *target,
         char **out_ptr, size_t *out_len);
 
+// ABI warning
+ZIG_EXTERN_C enum Error stage2_target_parse(struct ZigTarget *target, const char *zig_triple, const char *mcpu);
 
 
 // ABI warning
diff --git a/src/target.cpp b/src/target.cpp
index 209b42f3c9..0a3fb3da5f 100644
--- a/src/target.cpp
+++ b/src/target.cpp
@@ -15,60 +15,6 @@
 
 #include <stdio.h>
 
-static const SubArchList subarch_list_list[] = {
-    SubArchListNone,
-    SubArchListArm32,
-    SubArchListArm64,
-    SubArchListKalimba,
-    SubArchListMips,
-};
-
-static const ZigLLVM_SubArchType subarch_list_arm32[] = {
-    ZigLLVM_ARMSubArch_v8_5a,
-    ZigLLVM_ARMSubArch_v8_4a,
-    ZigLLVM_ARMSubArch_v8_3a,
-    ZigLLVM_ARMSubArch_v8_2a,
-    ZigLLVM_ARMSubArch_v8_1a,
-    ZigLLVM_ARMSubArch_v8,
-    ZigLLVM_ARMSubArch_v8r,
-    ZigLLVM_ARMSubArch_v8m_baseline,
-    ZigLLVM_ARMSubArch_v8m_mainline,
-    ZigLLVM_ARMSubArch_v8_1m_mainline,
-    ZigLLVM_ARMSubArch_v7,
-    ZigLLVM_ARMSubArch_v7em,
-    ZigLLVM_ARMSubArch_v7m,
-    ZigLLVM_ARMSubArch_v7s,
-    ZigLLVM_ARMSubArch_v7k,
-    ZigLLVM_ARMSubArch_v7ve,
-    ZigLLVM_ARMSubArch_v6,
-    ZigLLVM_ARMSubArch_v6m,
-    ZigLLVM_ARMSubArch_v6k,
-    ZigLLVM_ARMSubArch_v6t2,
-    ZigLLVM_ARMSubArch_v5,
-    ZigLLVM_ARMSubArch_v5te,
-    ZigLLVM_ARMSubArch_v4t,
-
-};
-
-static const ZigLLVM_SubArchType subarch_list_arm64[] = {
-    ZigLLVM_ARMSubArch_v8_5a,
-    ZigLLVM_ARMSubArch_v8_4a,
-    ZigLLVM_ARMSubArch_v8_3a,
-    ZigLLVM_ARMSubArch_v8_2a,
-    ZigLLVM_ARMSubArch_v8_1a,
-    ZigLLVM_ARMSubArch_v8,
-};
-
-static const ZigLLVM_SubArchType subarch_list_kalimba[] = {
-    ZigLLVM_KalimbaSubArch_v5,
-    ZigLLVM_KalimbaSubArch_v4,
-    ZigLLVM_KalimbaSubArch_v3,
-};
-
-static const ZigLLVM_SubArchType subarch_list_mips[] = {
-    ZigLLVM_MipsSubArch_r6,
-};
-
 static const ZigLLVM_ArchType arch_list[] = {
     ZigLLVM_arm,            // ARM (little endian): arm, armv.*, xscale
     ZigLLVM_armeb,          // ARM (big endian): armeb
@@ -509,7 +455,6 @@ void get_native_target(ZigTarget *target) {
     ZigLLVM_ObjectFormatType oformat; // ignored; based on arch/os
     ZigLLVMGetNativeTarget(
             &target->arch,
-            &target->sub_arch,
             &target->vendor,
             &os_type,
             &target->abi,
@@ -535,223 +480,18 @@ void target_init_default_glibc_version(ZigTarget *target) {
     *target->glibc_version = {2, 17, 0};
 }
 
-Error target_parse_archsub(ZigLLVM_ArchType *out_arch, ZigLLVM_SubArchType *out_sub,
-        const char *archsub_ptr, size_t archsub_len)
-{
+Error target_parse_arch(ZigLLVM_ArchType *out_arch, const char *arch_ptr, size_t arch_len) {
     *out_arch = ZigLLVM_UnknownArch;
-    *out_sub = ZigLLVM_NoSubArch;
     for (size_t arch_i = 0; arch_i < array_length(arch_list); arch_i += 1) {
         ZigLLVM_ArchType arch = arch_list[arch_i];
-        SubArchList sub_arch_list = target_subarch_list(arch);
-        size_t subarch_count = target_subarch_count(sub_arch_list);
-        if (mem_eql_str(archsub_ptr, archsub_len, target_arch_name(arch))) {
+        if (mem_eql_str(arch_ptr, arch_len, target_arch_name(arch))) {
             *out_arch = arch;
-            if (subarch_count == 0) {
-                return ErrorNone;
-            }
-        }
-        for (size_t sub_i = 0; sub_i < subarch_count; sub_i += 1) {
-            ZigLLVM_SubArchType sub = target_subarch_enum(sub_arch_list, sub_i);
-            char arch_name[64];
-            int n = sprintf(arch_name, "%s%s", target_arch_name(arch), target_subarch_name(sub));
-            if (mem_eql_mem(arch_name, n, archsub_ptr, archsub_len)) {
-                *out_arch = arch;
-                *out_sub = sub;
-                return ErrorNone;
-            }
+            return ErrorNone;
         }
     }
     return ErrorUnknownArchitecture;
 }
 
-SubArchList target_subarch_list(ZigLLVM_ArchType arch) {
-    switch (arch) {
-        case ZigLLVM_UnknownArch:
-            zig_unreachable();
-        case ZigLLVM_arm:
-        case ZigLLVM_armeb:
-        case ZigLLVM_thumb:
-        case ZigLLVM_thumbeb:
-            return SubArchListArm32;
-
-        case ZigLLVM_aarch64:
-        case ZigLLVM_aarch64_be:
-        case ZigLLVM_aarch64_32:
-            return SubArchListArm64;
-
-        case ZigLLVM_kalimba:
-            return SubArchListKalimba;
-
-        case ZigLLVM_arc:
-        case ZigLLVM_avr:
-        case ZigLLVM_bpfel:
-        case ZigLLVM_bpfeb:
-        case ZigLLVM_hexagon:
-        case ZigLLVM_mips:
-        case ZigLLVM_mipsel:
-        case ZigLLVM_mips64:
-        case ZigLLVM_mips64el:
-        case ZigLLVM_msp430:
-        case ZigLLVM_ppc:
-        case ZigLLVM_ppc64:
-        case ZigLLVM_ppc64le:
-        case ZigLLVM_r600:
-        case ZigLLVM_amdgcn:
-        case ZigLLVM_riscv32:
-        case ZigLLVM_riscv64:
-        case ZigLLVM_sparc:
-        case ZigLLVM_sparcv9:
-        case ZigLLVM_sparcel:
-        case ZigLLVM_systemz:
-        case ZigLLVM_tce:
-        case ZigLLVM_tcele:
-        case ZigLLVM_x86:
-        case ZigLLVM_x86_64:
-        case ZigLLVM_xcore:
-        case ZigLLVM_nvptx:
-        case ZigLLVM_nvptx64:
-        case ZigLLVM_le32:
-        case ZigLLVM_le64:
-        case ZigLLVM_amdil:
-        case ZigLLVM_amdil64:
-        case ZigLLVM_hsail:
-        case ZigLLVM_hsail64:
-        case ZigLLVM_spir:
-        case ZigLLVM_spir64:
-        case ZigLLVM_shave:
-        case ZigLLVM_lanai:
-        case ZigLLVM_wasm32:
-        case ZigLLVM_wasm64:
-        case ZigLLVM_renderscript32:
-        case ZigLLVM_renderscript64:
-            return SubArchListNone;
-    }
-    zig_unreachable();
-}
-
-size_t target_subarch_count(SubArchList sub_arch_list) {
-    switch (sub_arch_list) {
-        case SubArchListNone:
-            return 0;
-        case SubArchListArm32:
-            return array_length(subarch_list_arm32);
-        case SubArchListArm64:
-            return array_length(subarch_list_arm64);
-        case SubArchListKalimba:
-            return array_length(subarch_list_kalimba);
-        case SubArchListMips:
-            return array_length(subarch_list_mips);
-    }
-    zig_unreachable();
-}
-
-ZigLLVM_SubArchType target_subarch_enum(SubArchList sub_arch_list, size_t i) {
-    switch (sub_arch_list) {
-        case SubArchListNone:
-            zig_unreachable();
-        case SubArchListArm32:
-            assert(i < array_length(subarch_list_arm32));
-            return subarch_list_arm32[i];
-        case SubArchListArm64:
-            assert(i < array_length(subarch_list_arm64));
-            return subarch_list_arm64[i];
-        case SubArchListKalimba:
-            assert(i < array_length(subarch_list_kalimba));
-            return subarch_list_kalimba[i];
-        case SubArchListMips:
-            assert(i < array_length(subarch_list_mips));
-            return subarch_list_mips[i];
-    }
-    zig_unreachable();
-}
-
-const char *target_subarch_name(ZigLLVM_SubArchType subarch) {
-    switch (subarch) {
-        case ZigLLVM_NoSubArch:
-            return "";
-        case ZigLLVM_ARMSubArch_v8_5a:
-            return "v8_5a";
-        case ZigLLVM_ARMSubArch_v8_4a:
-            return "v8_4a";
-        case ZigLLVM_ARMSubArch_v8_3a:
-            return "v8_3a";
-        case ZigLLVM_ARMSubArch_v8_2a:
-            return "v8_2a";
-        case ZigLLVM_ARMSubArch_v8_1a:
-            return "v8_1a";
-        case ZigLLVM_ARMSubArch_v8:
-            return "v8a";
-        case ZigLLVM_ARMSubArch_v8r:
-            return "v8r";
-        case ZigLLVM_ARMSubArch_v8m_baseline:
-            return "v8m_baseline";
-        case ZigLLVM_ARMSubArch_v8m_mainline:
-            return "v8m_mainline";
-        case ZigLLVM_ARMSubArch_v8_1m_mainline:
-            return "v8_1m_mainline";
-        case ZigLLVM_ARMSubArch_v7:
-            return "v7a";
-        case ZigLLVM_ARMSubArch_v7em:
-            return "v7em";
-        case ZigLLVM_ARMSubArch_v7m:
-            return "v7m";
-        case ZigLLVM_ARMSubArch_v7s:
-            return "v7s";
-        case ZigLLVM_ARMSubArch_v7k:
-            return "v7k";
-        case ZigLLVM_ARMSubArch_v7ve:
-            return "v7ve";
-        case ZigLLVM_ARMSubArch_v6:
-            return "v6";
-        case ZigLLVM_ARMSubArch_v6m:
-            return "v6m";
-        case ZigLLVM_ARMSubArch_v6k:
-            return "v6k";
-        case ZigLLVM_ARMSubArch_v6t2:
-            return "v6t2";
-        case ZigLLVM_ARMSubArch_v5:
-            return "v5";
-        case ZigLLVM_ARMSubArch_v5te:
-            return "v5te";
-        case ZigLLVM_ARMSubArch_v4t:
-            return "v4t";
-        case ZigLLVM_KalimbaSubArch_v3:
-            return "v3";
-        case ZigLLVM_KalimbaSubArch_v4:
-            return "v4";
-        case ZigLLVM_KalimbaSubArch_v5:
-            return "v5";
-        case ZigLLVM_MipsSubArch_r6:
-            return "r6";
-    }
-    zig_unreachable();
-}
-
-size_t target_subarch_list_count(void) {
-    return array_length(subarch_list_list);
-}
-
-SubArchList target_subarch_list_enum(size_t index) {
-    assert(index < array_length(subarch_list_list));
-    return subarch_list_list[index];
-}
-
-const char *target_subarch_list_name(SubArchList sub_arch_list) {
-    switch (sub_arch_list) {
-        case SubArchListNone:
-            return "None";
-        case SubArchListArm32:
-            return "Arm32";
-        case SubArchListArm64:
-            return "Arm64";
-        case SubArchListKalimba:
-            return "Kalimba";
-        case SubArchListMips:
-            return "Mips";
-    }
-    zig_unreachable();
-}
-
 Error target_parse_os(Os *out_os, const char *os_ptr, size_t os_len) {
     for (size_t i = 0; i < array_length(os_list); i += 1) {
         Os os = os_list[i];
@@ -776,42 +516,8 @@ Error target_parse_abi(ZigLLVM_EnvironmentType *out_abi, const char *abi_ptr, si
     return ErrorUnknownABI;
 }
 
-Error target_parse_triple(ZigTarget *target, const char *triple) {
-    Error err;
-
-    // first initialize all to zero
-    *target = {};
-
-    SplitIterator it = memSplit(str(triple), str("-"));
-
-    Optional<Slice<uint8_t>> opt_archsub = SplitIterator_next(&it);
-    Optional<Slice<uint8_t>> opt_os = SplitIterator_next(&it);
-    Optional<Slice<uint8_t>> opt_abi = SplitIterator_next(&it);
-
-    if (!opt_archsub.is_some)
-        return ErrorMissingArchitecture;
-
-    if ((err = target_parse_archsub(&target->arch, &target->sub_arch,
-                    (char*)opt_archsub.value.ptr, opt_archsub.value.len)))
-    {
-        return err;
-    }
-
-    if (!opt_os.is_some)
-        return ErrorMissingOperatingSystem;
-
-    if ((err = target_parse_os(&target->os, (char*)opt_os.value.ptr, opt_os.value.len))) {
-        return err;
-    }
-
-    if (opt_abi.is_some) {
-        if ((err = target_parse_abi(&target->abi, (char*)opt_abi.value.ptr, opt_abi.value.len))) {
-            return err;
-        }
-    } else {
-        target->abi = target_default_abi(target->arch, target->os);
-    }
-    return ErrorNone;
+Error target_parse_triple(ZigTarget *target, const char *triple, const char *mcpu) {
+    return stage2_target_parse(target, triple, mcpu);
 }
 
 const char *target_arch_name(ZigLLVM_ArchType arch) {
@@ -828,18 +534,16 @@ void init_all_targets(void) {
 
 void target_triple_zig(Buf *triple, const ZigTarget *target) {
     buf_resize(triple, 0);
-    buf_appendf(triple, "%s%s-%s-%s",
+    buf_appendf(triple, "%s-%s-%s",
             target_arch_name(target->arch),
-            target_subarch_name(target->sub_arch),
             target_os_name(target->os),
             target_abi_name(target->abi));
 }
 
 void target_triple_llvm(Buf *triple, const ZigTarget *target) {
     buf_resize(triple, 0);
-    buf_appendf(triple, "%s%s-%s-%s-%s",
+    buf_appendf(triple, "%s-%s-%s-%s",
             ZigLLVMGetArchTypeName(target->arch),
-            ZigLLVMGetSubArchTypeName(target->sub_arch),
             ZigLLVMGetVendorTypeName(target->vendor),
             ZigLLVMGetOSTypeName(get_llvm_os_type(target->os)),
             ZigLLVMGetEnvironmentTypeName(target->abi));
@@ -1216,10 +920,8 @@ bool target_can_exec(const ZigTarget *host_target, const ZigTarget *guest_target
         return true;
     }
 
-    if (guest_target->os == host_target->os && guest_target->arch == host_target->arch &&
-        guest_target->sub_arch == host_target->sub_arch)
-    {
-        // OS, arch, and sub-arch match
+    if (guest_target->os == host_target->os && guest_target->arch == host_target->arch) {
+        // OS and arch match
         return true;
     }
 
@@ -1641,7 +1343,6 @@ void target_libc_enum(size_t index, ZigTarget *out_target) {
     out_target->arch = libcs_available[index].arch;
     out_target->os = libcs_available[index].os;
     out_target->abi = libcs_available[index].abi;
-    out_target->sub_arch = ZigLLVM_NoSubArch;
     out_target->vendor = ZigLLVM_UnknownVendor;
     out_target->is_native = false;
 }
diff --git a/src/target.hpp b/src/target.hpp
index 4344749719..9396eb2623 100644
--- a/src/target.hpp
+++ b/src/target.hpp
@@ -12,15 +12,6 @@
 
 struct Buf;
 
-// Synchronize with target.cpp::subarch_list_list
-enum SubArchList {
-    SubArchListNone,
-    SubArchListArm32,
-    SubArchListArm64,
-    SubArchListKalimba,
-    SubArchListMips,
-};
-
 enum TargetSubsystem {
     TargetSubsystemConsole,
     TargetSubsystemWindows,
@@ -50,9 +41,8 @@ enum CIntType {
     CIntTypeCount,
 };
 
-Error target_parse_triple(ZigTarget *target, const char *triple);
-Error target_parse_archsub(ZigLLVM_ArchType *arch, ZigLLVM_SubArchType *sub,
-        const char *archsub_ptr, size_t archsub_len);
+Error target_parse_triple(ZigTarget *target, const char *triple, const char *mcpu);
+Error target_parse_arch(ZigLLVM_ArchType *arch, const char *arch_ptr, size_t arch_len);
 Error target_parse_os(Os *os, const char *os_ptr, size_t os_len);
 Error target_parse_abi(ZigLLVM_EnvironmentType *abi, const char *abi_ptr, size_t abi_len);
 
@@ -63,15 +53,6 @@ size_t target_arch_count(void);
 ZigLLVM_ArchType target_arch_enum(size_t index);
 const char *target_arch_name(ZigLLVM_ArchType arch);
 
-SubArchList target_subarch_list(ZigLLVM_ArchType arch);
-size_t target_subarch_count(SubArchList sub_arch_list);
-ZigLLVM_SubArchType target_subarch_enum(SubArchList subarch_list, size_t index);
-const char *target_subarch_name(ZigLLVM_SubArchType subarch);
-
-size_t target_subarch_list_count(void);
-SubArchList target_subarch_list_enum(size_t index);
-const char *target_subarch_list_name(SubArchList sub_arch_list);
-
 const char *arch_stack_pointer_register_name(ZigLLVM_ArchType arch);
 
 size_t target_vendor_count(void);
diff --git a/src/zig_llvm.cpp b/src/zig_llvm.cpp
index 64706500d5..aed2944f62 100644
--- a/src/zig_llvm.cpp
+++ b/src/zig_llvm.cpp
@@ -806,7 +806,7 @@ const char *ZigLLVMGetEnvironmentTypeName(ZigLLVM_EnvironmentType env_type) {
     return (const char*)Triple::getEnvironmentTypeName((Triple::EnvironmentType)env_type).bytes_begin();
 }
 
-void ZigLLVMGetNativeTarget(ZigLLVM_ArchType *arch_type, ZigLLVM_SubArchType *sub_arch_type,
+void ZigLLVMGetNativeTarget(ZigLLVM_ArchType *arch_type,
         ZigLLVM_VendorType *vendor_type, ZigLLVM_OSType *os_type, ZigLLVM_EnvironmentType *environ_type,
         ZigLLVM_ObjectFormatType *oformat)
 {
@@ -814,7 +814,6 @@ void ZigLLVMGetNativeTarget(ZigLLVM_ArchType *arch_type, ZigLLVM_SubArchType *su
     Triple triple(Triple::normalize(native_triple));
 
     *arch_type = (ZigLLVM_ArchType)triple.getArch();
-    *sub_arch_type = (ZigLLVM_SubArchType)triple.getSubArch();
     *vendor_type = (ZigLLVM_VendorType)triple.getVendor();
     *os_type = (ZigLLVM_OSType)triple.getOS();
     *environ_type = (ZigLLVM_EnvironmentType)triple.getEnvironment();
@@ -823,68 +822,6 @@ void ZigLLVMGetNativeTarget(ZigLLVM_ArchType *arch_type, ZigLLVM_SubArchType *su
     free(native_triple);
 }
 
-const char *ZigLLVMGetSubArchTypeName(ZigLLVM_SubArchType sub_arch) {
-    switch (sub_arch) {
-        case ZigLLVM_NoSubArch:
-            return "";
-        case ZigLLVM_ARMSubArch_v8_5a:
-            return "v8.5a";
-        case ZigLLVM_ARMSubArch_v8_4a:
-            return "v8.4a";
-        case ZigLLVM_ARMSubArch_v8_3a:
-            return "v8.3a";
-        case ZigLLVM_ARMSubArch_v8_2a:
-            return "v8.2a";
-        case ZigLLVM_ARMSubArch_v8_1a:
-            return "v8.1a";
-        case ZigLLVM_ARMSubArch_v8:
-            return "v8a";
-        case ZigLLVM_ARMSubArch_v8r:
-            return "v8r";
-        case ZigLLVM_ARMSubArch_v8m_baseline:
-            return "v8m.base";
-        case ZigLLVM_ARMSubArch_v8m_mainline:
-            return "v8m.main";
-        case ZigLLVM_ARMSubArch_v8_1m_mainline:
-            return "v8.1m.main";
-        case ZigLLVM_ARMSubArch_v7:
-            return "v7a";
-        case ZigLLVM_ARMSubArch_v7em:
-            return "v7em";
-        case ZigLLVM_ARMSubArch_v7m:
-            return "v7m";
-        case ZigLLVM_ARMSubArch_v7s:
-            return "v7s";
-        case ZigLLVM_ARMSubArch_v7k:
-            return "v7k";
-        case ZigLLVM_ARMSubArch_v7ve:
-            return "v7ve";
-        case ZigLLVM_ARMSubArch_v6:
-            return "v6";
-        case ZigLLVM_ARMSubArch_v6m:
-            return "v6m";
-        case ZigLLVM_ARMSubArch_v6k:
-            return "v6k";
-        case ZigLLVM_ARMSubArch_v6t2:
-            return "v6t2";
-        case ZigLLVM_ARMSubArch_v5:
-            return "v5";
-        case ZigLLVM_ARMSubArch_v5te:
-            return "v5te";
-        case ZigLLVM_ARMSubArch_v4t:
-            return "v4t";
-        case ZigLLVM_KalimbaSubArch_v3:
-            return "v3";
-        case ZigLLVM_KalimbaSubArch_v4:
-            return "v4";
-        case ZigLLVM_KalimbaSubArch_v5:
-            return "v5";
-        case ZigLLVM_MipsSubArch_r6:
-            return "r6";
-    }
-    abort();
-}
-
 void ZigLLVMAddModuleDebugInfoFlag(LLVMModuleRef module) {
     unwrap(module)->addModuleFlag(Module::Warning, "Debug Info Version", DEBUG_METADATA_VERSION);
     unwrap(module)->addModuleFlag(Module::Warning, "Dwarf Version", 4);
@@ -1218,35 +1155,6 @@ static_assert((Triple::ArchType)ZigLLVM_renderscript32 == Triple::renderscript32
 static_assert((Triple::ArchType)ZigLLVM_renderscript64 == Triple::renderscript64, "");
 static_assert((Triple::ArchType)ZigLLVM_LastArchType == Triple::LastArchType, "");
 
-static_assert((Triple::SubArchType)ZigLLVM_NoSubArch == Triple::NoSubArch, "");
-static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v8_4a == Triple::ARMSubArch_v8_4a, "");
-static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v8_3a == Triple::ARMSubArch_v8_3a, "");
-static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v8_2a == Triple::ARMSubArch_v8_2a, "");
-static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v8_1a == Triple::ARMSubArch_v8_1a, "");
-static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v8 == Triple::ARMSubArch_v8, "");
-static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v8r == Triple::ARMSubArch_v8r, "");
-static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v8m_baseline == Triple::ARMSubArch_v8m_baseline, "");
-static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v8m_mainline == Triple::ARMSubArch_v8m_mainline, "");
-static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v8_1m_mainline == Triple::ARMSubArch_v8_1m_mainline, "");
-static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v7 == Triple::ARMSubArch_v7, "");
-static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v7em == Triple::ARMSubArch_v7em, "");
-static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v7m == Triple::ARMSubArch_v7m, "");
-static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v7s == Triple::ARMSubArch_v7s, "");
-static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v7k == Triple::ARMSubArch_v7k, "");
-static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v7ve == Triple::ARMSubArch_v7ve, "");
-static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v6 == Triple::ARMSubArch_v6, "");
-static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v6m == Triple::ARMSubArch_v6m, "");
-static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v6k == Triple::ARMSubArch_v6k, "");
-static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v6t2 == Triple::ARMSubArch_v6t2, "");
-static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v5 == Triple::ARMSubArch_v5, "");
-static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v5te == Triple::ARMSubArch_v5te, "");
-static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v4t == Triple::ARMSubArch_v4t, "");
-static_assert((Triple::SubArchType)ZigLLVM_KalimbaSubArch_v3 == Triple::KalimbaSubArch_v3, "");
-static_assert((Triple::SubArchType)ZigLLVM_KalimbaSubArch_v4 == Triple::KalimbaSubArch_v4, "");
-static_assert((Triple::SubArchType)ZigLLVM_KalimbaSubArch_v5 == Triple::KalimbaSubArch_v5, "");
-static_assert((Triple::SubArchType)ZigLLVM_KalimbaSubArch_v5 == Triple::KalimbaSubArch_v5, "");
-static_assert((Triple::SubArchType)ZigLLVM_MipsSubArch_r6 == Triple::MipsSubArch_r6, "");
-
 static_assert((Triple::VendorType)ZigLLVM_UnknownVendor == Triple::UnknownVendor, "");
 static_assert((Triple::VendorType)ZigLLVM_Apple == Triple::Apple, "");
 static_assert((Triple::VendorType)ZigLLVM_PC == Triple::PC, "");
diff --git a/src/zig_llvm.h b/src/zig_llvm.h
index 95751cd08a..95f5926ec7 100644
--- a/src/zig_llvm.h
+++ b/src/zig_llvm.h
@@ -324,41 +324,6 @@ enum ZigLLVM_ArchType {
     ZigLLVM_LastArchType = ZigLLVM_renderscript64
 };
 
-// synchronize with lists in target.cpp
-enum ZigLLVM_SubArchType {
-    ZigLLVM_NoSubArch,
-
-    ZigLLVM_ARMSubArch_v8_5a,
-    ZigLLVM_ARMSubArch_v8_4a,
-    ZigLLVM_ARMSubArch_v8_3a,
-    ZigLLVM_ARMSubArch_v8_2a,
-    ZigLLVM_ARMSubArch_v8_1a,
-    ZigLLVM_ARMSubArch_v8,
-    ZigLLVM_ARMSubArch_v8r,
-    ZigLLVM_ARMSubArch_v8m_baseline,
-    ZigLLVM_ARMSubArch_v8m_mainline,
-    ZigLLVM_ARMSubArch_v8_1m_mainline,
-    ZigLLVM_ARMSubArch_v7,
-    ZigLLVM_ARMSubArch_v7em,
-    ZigLLVM_ARMSubArch_v7m,
-    ZigLLVM_ARMSubArch_v7s,
-    ZigLLVM_ARMSubArch_v7k,
-    ZigLLVM_ARMSubArch_v7ve,
-    ZigLLVM_ARMSubArch_v6,
-    ZigLLVM_ARMSubArch_v6m,
-    ZigLLVM_ARMSubArch_v6k,
-    ZigLLVM_ARMSubArch_v6t2,
-    ZigLLVM_ARMSubArch_v5,
-    ZigLLVM_ARMSubArch_v5te,
-    ZigLLVM_ARMSubArch_v4t,
-
-    ZigLLVM_KalimbaSubArch_v3,
-    ZigLLVM_KalimbaSubArch_v4,
-    ZigLLVM_KalimbaSubArch_v5,
-
-    ZigLLVM_MipsSubArch_r6,
-};
-
 enum ZigLLVM_VendorType {
     ZigLLVM_UnknownVendor,
 
@@ -518,7 +483,6 @@ LLVMValueRef ZigLLVMBuildAtomicRMW(LLVMBuilderRef B, enum ZigLLVM_AtomicRMWBinOp
 #define ZigLLVM_DIFlags_AllCallsDescribed (1U << 29)
 
 ZIG_EXTERN_C const char *ZigLLVMGetArchTypeName(enum ZigLLVM_ArchType arch);
-ZIG_EXTERN_C const char *ZigLLVMGetSubArchTypeName(enum ZigLLVM_SubArchType sub_arch);
 ZIG_EXTERN_C const char *ZigLLVMGetVendorTypeName(enum ZigLLVM_VendorType vendor);
 ZIG_EXTERN_C const char *ZigLLVMGetOSTypeName(enum ZigLLVM_OSType os);
 ZIG_EXTERN_C const char *ZigLLVMGetEnvironmentTypeName(enum ZigLLVM_EnvironmentType abi);
@@ -532,7 +496,7 @@ ZIG_EXTERN_C bool ZigLLVMWriteArchive(const char *archive_name, const char **fil
 bool ZigLLVMWriteImportLibrary(const char *def_path, const enum ZigLLVM_ArchType arch,
                                const char *output_lib_path, const bool kill_at);
 
-ZIG_EXTERN_C void ZigLLVMGetNativeTarget(enum ZigLLVM_ArchType *arch_type, enum ZigLLVM_SubArchType *sub_arch_type,
+ZIG_EXTERN_C void ZigLLVMGetNativeTarget(enum ZigLLVM_ArchType *arch_type,
         enum ZigLLVM_VendorType *vendor_type, enum ZigLLVM_OSType *os_type, enum ZigLLVM_EnvironmentType *environ_type,
         enum ZigLLVM_ObjectFormatType *oformat);