add -mabi parameter, affects cache, no build.zig support

vole-dev · vole-dev · commit 5924789f5905 · 2021-10-24T19:40:51.000-05:00
diff --git a/lib/std/target.zig b/lib/std/target.zig
@@ -723,6 +723,16 @@ pub const Target = struct {
                 else => return null,
             }
         }
+        fn parseAbi(comptime T: type, abi_string: []const u8) error{InvalidAbi}!T {
+            return std.meta.stringToEnum(T, abi_string) orelse error.InvalidAbi;
+        }
+        pub fn parse(cpu: Cpu, abi_string: []const u8) error{InvalidAbi}!TargetAbi {
+            return switch (cpu.arch) {
+                .riscv32 => .{ .riscv32 = try parseAbi(Riscv32ABI, abi_string) },
+                .riscv64 => .{ .riscv64 = try parseAbi(Riscv64ABI, abi_string) },
+                else => error.InvalidAbi,
+            };
+        }
     };
 
     pub const ObjectFormat = enum {
diff --git a/src/Compilation.zig b/src/Compilation.zig
@@ -749,6 +749,7 @@ pub const InitOptions = struct {
     version: ?std.builtin.Version = null,
     libc_installation: ?*const LibCInstallation = null,
     machine_code_model: std.builtin.CodeModel = .default,
+    target_abi: std.Target.TargetAbi,
     clang_preprocessor_mode: ClangPreprocessorMode = .no,
     /// This is for stage1 and should be deleted upon completion of self-hosting.
     color: @import("main.zig").Color = .auto,
@@ -1146,6 +1147,7 @@ pub fn create(gpa: *Allocator, options: InitOptions) !*Compilation {
         cache.hash.add(options.target.os.getVersionRange());
         cache.hash.add(options.is_native_os);
         cache.hash.add(options.target.abi);
+        cache.hash.addBytes(options.target_abi.string() orelse ".");
         cache.hash.add(ofmt);
         cache.hash.add(pic);
         cache.hash.add(pie);
@@ -1427,6 +1429,7 @@ pub fn create(gpa: *Allocator, options: InitOptions) !*Compilation {
             .single_threaded = single_threaded,
             .verbose_link = options.verbose_link,
             .machine_code_model = options.machine_code_model,
+            .target_abi = options.target_abi,
             .dll_export_fns = dll_export_fns,
             .error_return_tracing = error_return_tracing,
             .llvm_cpu_features = llvm_cpu_features,
@@ -3267,7 +3270,7 @@ pub fn addCCArgs(
                 try argv.append("-mthumb");
             }
 
-            if (std.Target.TargetAbi.default(target.cpu).string()) |mabi| {
+            if (comp.bin_file.options.target_abi.string()) |mabi| {
                 try argv.append(try std.fmt.allocPrint(arena, "-mabi={s}", .{mabi}));
             }
 
@@ -3404,7 +3407,7 @@ pub fn addCCArgs(
                 },
             }
 
-            if (std.Target.TargetAbi.default(target.cpu).string()) |mabi| {
+            if (comp.bin_file.options.target_abi.string()) |mabi| {
                 try argv.append(try std.fmt.allocPrint(arena, "-mabi={s}", .{mabi}));
             }
 
@@ -4136,6 +4139,7 @@ fn buildOutputFromZig(
         .strip = comp.compilerRtStrip(),
         .is_native_os = comp.bin_file.options.is_native_os,
         .is_native_abi = comp.bin_file.options.is_native_abi,
+        .target_abi = comp.bin_file.options.target_abi,
         .self_exe_path = comp.self_exe_path,
         .verbose_cc = comp.verbose_cc,
         .verbose_link = comp.bin_file.options.verbose_link,
@@ -4323,6 +4327,7 @@ fn updateStage1Module(comp: *Compilation, main_progress_node: *std.Progress.Node
         .is_native_cpu = false, // Only true when bootstrapping the compiler.
         .llvm_cpu_name = if (target.cpu.model.llvm_name) |s| s.ptr else null,
         .llvm_cpu_features = comp.bin_file.options.llvm_cpu_features.?,
+        .llvm_target_abi = if (comp.bin_file.options.target_abi.string()) |s| s.ptr else null,
     };
 
     comp.stage1_cache_manifest = &man;
@@ -4572,6 +4577,7 @@ pub fn build_crt_file(
         .strip = comp.compilerRtStrip(),
         .is_native_os = comp.bin_file.options.is_native_os,
         .is_native_abi = comp.bin_file.options.is_native_abi,
+        .target_abi = comp.bin_file.options.target_abi,
         .self_exe_path = comp.self_exe_path,
         .c_source_files = c_source_files,
         .verbose_cc = comp.verbose_cc,
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
@@ -244,8 +244,7 @@ pub const Object = struct {
         // TODO handle float ABI better- it should depend on the ABI portion of std.Target
         const float_abi: llvm.ABIType = .Default;
 
-        // TODO a way to override this as part of std.Target ABI?
-        const abi_name: ?[*:0]const u8 = if (std.Target.TargetAbi.default(options.target.cpu).string()) |mabi|
+        const abi_name: ?[*:0]const u8 = if (options.target_abi.string()) |mabi|
             mabi.ptr
         else
             null;
diff --git a/src/glibc.zig b/src/glibc.zig
@@ -959,6 +959,7 @@ fn buildSharedLib(
         .strip = comp.compilerRtStrip(),
         .is_native_os = false,
         .is_native_abi = false,
+        .target_abi = comp.bin_file.options.target_abi,
         .self_exe_path = comp.self_exe_path,
         .verbose_cc = comp.verbose_cc,
         .verbose_link = comp.bin_file.options.verbose_link,
diff --git a/src/libcxx.zig b/src/libcxx.zig
@@ -199,6 +199,7 @@ pub fn buildLibCXX(comp: *Compilation) !void {
         .strip = comp.compilerRtStrip(),
         .is_native_os = comp.bin_file.options.is_native_os,
         .is_native_abi = comp.bin_file.options.is_native_abi,
+        .target_abi = comp.bin_file.options.target_abi,
         .self_exe_path = comp.self_exe_path,
         .c_source_files = c_source_files.items,
         .verbose_cc = comp.verbose_cc,
@@ -331,6 +332,7 @@ pub fn buildLibCXXABI(comp: *Compilation) !void {
         .strip = comp.compilerRtStrip(),
         .is_native_os = comp.bin_file.options.is_native_os,
         .is_native_abi = comp.bin_file.options.is_native_abi,
+        .target_abi = comp.bin_file.options.target_abi,
         .self_exe_path = comp.self_exe_path,
         .c_source_files = c_source_files.items,
         .verbose_cc = comp.verbose_cc,
diff --git a/src/libtsan.zig b/src/libtsan.zig
@@ -218,6 +218,7 @@ pub fn buildTsan(comp: *Compilation) !void {
         .strip = comp.compilerRtStrip(),
         .is_native_os = comp.bin_file.options.is_native_os,
         .is_native_abi = comp.bin_file.options.is_native_abi,
+        .target_abi = comp.bin_file.options.target_abi,
         .self_exe_path = comp.self_exe_path,
         .c_source_files = c_source_files.items,
         .verbose_cc = comp.verbose_cc,
diff --git a/src/libunwind.zig b/src/libunwind.zig
@@ -123,6 +123,7 @@ pub fn buildStaticLib(comp: *Compilation) !void {
         .strip = comp.compilerRtStrip(),
         .is_native_os = comp.bin_file.options.is_native_os,
         .is_native_abi = comp.bin_file.options.is_native_abi,
+        .target_abi = comp.bin_file.options.target_abi,
         .self_exe_path = comp.self_exe_path,
         .c_source_files = &c_source_files,
         .verbose_cc = comp.verbose_cc,
diff --git a/src/link.zig b/src/link.zig
@@ -109,6 +109,7 @@ pub const Options = struct {
     version_script: ?[]const u8,
     soname: ?[]const u8,
     llvm_cpu_features: ?[*:0]const u8,
+    target_abi: std.Target.TargetAbi,
     /// Extra args passed directly to LLD. Ignored when not linking with LLD.
     extra_lld_args: []const []const u8,
 
diff --git a/src/main.zig b/src/main.zig
@@ -325,6 +325,7 @@ const usage_build_generic =
     \\Compile Options:
     \\  -target [name]            <arch><sub>-<os>-<abi> see the targets command
     \\  -mcpu [cpu]               Specify target CPU and feature set
+    \\  -mabi [target-abi]        Specify processor specific target-abi
     \\  -mcmodel=[default|tiny|   Limit range of code and data virtual addresses
     \\            small|kernel|
     \\            medium|large]
@@ -620,6 +621,7 @@ fn buildOutputType(
     var sysroot: ?[]const u8 = null;
     var libc_paths_file: ?[]const u8 = try optionalStringEnvVar(arena, "ZIG_LIBC");
     var machine_code_model: std.builtin.CodeModel = .default;
+    var target_abi_str: ?[]const u8 = null;
     var runtime_args_start: ?usize = null;
     var test_filter: ?[]const u8 = null;
     var test_name_prefix: ?[]const u8 = null;
@@ -881,6 +883,12 @@ fn buildOutputType(
                         target_mcpu = arg["-mcpu=".len..];
                     } else if (mem.startsWith(u8, arg, "-mcmodel=")) {
                         machine_code_model = parseCodeModel(arg["-mcmodel=".len..]);
+                    } else if (mem.eql(u8, arg, "-mabi")) {
+                        if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
+                        i += 1;
+                        target_abi_str = args[i];
+                    } else if (mem.startsWith(u8, arg, "-mabi=")) {
+                        target_abi_str = arg["-mabi=".len..];
                     } else if (mem.startsWith(u8, arg, "-O")) {
                         optimize_mode_string = arg["-O".len..];
                     } else if (mem.eql(u8, arg, "--dynamic-linker")) {
@@ -1637,6 +1645,10 @@ fn buildOutputType(
     });
 
     const target_info = try detectNativeTargetInfo(gpa, cross_target);
+    const target_abi = if (target_abi_str) |s|
+        std.Target.TargetAbi.parse(target_info.target.cpu, s) catch fatal("unsupported target-abi '{s}' for cpu", .{target_abi_str})
+    else
+        std.Target.TargetAbi.default(target_info.target.cpu);
 
     if (target_info.target.os.tag != .freestanding) {
         if (ensure_libc_on_non_freestanding)
@@ -2127,6 +2139,7 @@ fn buildOutputType(
         .verbose_cimport = verbose_cimport,
         .verbose_llvm_cpu_features = verbose_llvm_cpu_features,
         .machine_code_model = machine_code_model,
+        .target_abi = target_abi,
         .color = color,
         .time_report = time_report,
         .stack_report = stack_report,
@@ -3038,6 +3051,7 @@ pub fn cmdBuild(gpa: *Allocator, arena: *Allocator, args: []const []const u8) !v
             .target = target_info.target,
             .is_native_os = cross_target.isNativeOs(),
             .is_native_abi = cross_target.isNativeAbi(),
+            .target_abi = std.Target.TargetAbi.default(target_info.target.cpu),
             .dynamic_linker = target_info.dynamic_linker.get(),
             .output_mode = .Exe,
             .main_pkg = &main_pkg,
diff --git a/src/musl.zig b/src/musl.zig
@@ -213,6 +213,7 @@ pub fn buildCRTFile(comp: *Compilation, crt_file: CRTFile) !void {
                 .strip = comp.compilerRtStrip(),
                 .is_native_os = false,
                 .is_native_abi = false,
+                .target_abi = comp.bin_file.options.target_abi,
                 .self_exe_path = comp.self_exe_path,
                 .verbose_cc = comp.verbose_cc,
                 .verbose_link = comp.bin_file.options.verbose_link,
diff --git a/src/stage1.zig b/src/stage1.zig
@@ -363,6 +363,7 @@ pub const Stage2Target = extern struct {
 
     llvm_cpu_name: ?[*:0]const u8,
     llvm_cpu_features: ?[*:0]const u8,
+    llvm_target_abi: ?[*:0]const u8,
 };
 
 // ABI warning
diff --git a/src/stage1/codegen.cpp b/src/stage1/codegen.cpp
@@ -9509,55 +9509,13 @@ static void init(CodeGen *g) {
     // TODO handle float ABI better- it should depend on the ABI portion of std.Target
     ZigLLVMABIType float_abi = ZigLLVMABITypeDefault;
 
-    // TODO a way to override this as part of std.Target ABI?
-    const char *abi_name = nullptr;
-    if (target_is_riscv(g->zig_target)) {
-        bool feature_e = false;
-        bool feature_d = false;
-        const char *feature_iter = target_specific_features;
-        const char *single_feature;
-        int feature_search_state = 0;
-        while (feature_search_state >= 0) {
-            switch (feature_search_state) {
-                case 0: // expecting next char to be the start of a new feature, specifically + or -
-                    if (*feature_iter == '-' || *feature_iter == '+') {
-                        single_feature = feature_iter;
-                        feature_search_state = 1;
-                    } else {
-                        feature_search_state = -1; // end of string or invalid char
-                    }
-                    break;
-                case 1: // capture feature
-                    if (*feature_iter == 0 || *feature_iter == ',') {
-                        // found feature
-                        size_t feature_len = feature_iter - single_feature;
-                        if (feature_len == 2 && single_feature[0] == '+' && single_feature[1] == 'e') {
-                            feature_e = true;
-                        } else if (feature_len == 2 && single_feature[0] == '+' && single_feature[1] == 'd') {
-                            feature_d = true;
-                        }
-                        feature_search_state = *feature_iter == 0 ? -1 : 0;
-                    } else {
-                        feature_search_state = 1;
-                    }
-                    break;
-            }
-            feature_iter++;
-        }
-        if (g->zig_target->arch == ZigLLVM_riscv32) {
-            if (feature_d) {
-                abi_name = "ilp32d";
-            } else if (feature_e) {
-                abi_name = "ilp32e";
-            } else {
-                abi_name = "ilp32";
-            }
+    const char *abi_name = g->zig_target->llvm_target_abi;
+    if (abi_name == nullptr && target_is_riscv(g->zig_target)) {
+        // RISC-V Linux defaults to ilp32d/lp64d
+        if (g->zig_target->os == OsLinux) {
+            abi_name = (g->zig_target->arch == ZigLLVM_riscv32) ? "ilp32d" : "lp64d";
         } else {
-            if (feature_d) {
-                abi_name = "lp64d";
-            } else {
-                abi_name = "lp64";
-            }
+            abi_name = (g->zig_target->arch == ZigLLVM_riscv32) ? "ilp32" : "lp64";
         }
     }
 
diff --git a/src/stage1/stage1.h b/src/stage1/stage1.h
@@ -112,6 +112,7 @@ struct ZigTarget {
 
     const char *llvm_cpu_name;
     const char *llvm_cpu_features;
+    const char *llvm_target_abi;
 };
 
 // ABI warning
