Merge pull request #17262 from jacobly0/x86_64

x86_64: support operations that are implemented in compiler_rt

Author: jacobly0

lib/compiler_rt/common.zig

@@ -82,7 +82,7 @@ pub fn panic(msg: []const u8, error_return_trace: ?*std.builtin.StackTrace, _: ?
 /// need for extending them to wider fp types.
 /// TODO remove this; do this type selection in the language rather than
 /// here in compiler-rt.
-pub fn F16T(comptime other_type: type) type {
+pub fn F16T(comptime OtherType: type) type {
     return switch (builtin.cpu.arch) {
         .arm, .armeb, .thumb, .thumbeb => if (std.Target.arm.featureSetHas(builtin.cpu.features, .has_v8))
             switch (builtin.abi.floatAbi()) {
@@ -93,7 +93,7 @@ pub fn F16T(comptime other_type: type) type {
             u16,
         .aarch64, .aarch64_be, .aarch64_32 => f16,
         .riscv64 => if (builtin.zig_backend == .stage1) u16 else f16,
-        .x86, .x86_64 => if (builtin.target.isDarwin()) switch (other_type) {
+        .x86, .x86_64 => if (builtin.target.isDarwin()) switch (OtherType) {
             // Starting with LLVM 16, Darwin uses different abi for f16
             // depending on the type of the other return/argument..???
             f32, f64 => u16,

src/Compilation.zig

@@ -1871,8 +1871,7 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
                 comp.job_queued_compiler_rt_lib = true;
             } else if (options.output_mode != .Obj) {
                 log.debug("queuing a job to build compiler_rt_obj", .{});
-                // If build-obj with -fcompiler-rt is requested, that is handled specially
-                // elsewhere. In this case we are making a static library, so we ask
+                // In this case we are making a static library, so we ask
                 // for a compiler-rt object to put in it.
                 comp.job_queued_compiler_rt_obj = true;
             }

src/InternPool.zig

@@ -5407,19 +5407,19 @@ pub fn getAnonStructType(ip: *InternPool, gpa: Allocator, ini: AnonStructTypeIni
 
 /// This is equivalent to `Key.FuncType` but adjusted to have a slice for `param_types`.
 pub const GetFuncTypeKey = struct {
-    param_types: []Index,
+    param_types: []const Index,
     return_type: Index,
-    comptime_bits: u32,
-    noalias_bits: u32,
+    comptime_bits: u32 = 0,
+    noalias_bits: u32 = 0,
     /// `null` means generic.
-    alignment: ?Alignment,
+    alignment: ?Alignment = .none,
     /// `null` means generic.
-    cc: ?std.builtin.CallingConvention,
-    is_var_args: bool,
-    is_generic: bool,
-    is_noinline: bool,
-    section_is_generic: bool,
-    addrspace_is_generic: bool,
+    cc: ?std.builtin.CallingConvention = .Unspecified,
+    is_var_args: bool = false,
+    is_generic: bool = false,
+    is_noinline: bool = false,
+    section_is_generic: bool = false,
+    addrspace_is_generic: bool = false,
 };
 
 pub fn getFuncType(ip: *InternPool, gpa: Allocator, key: GetFuncTypeKey) Allocator.Error!Index {
@@ -5754,15 +5754,10 @@ pub fn getFuncInstance(ip: *InternPool, gpa: Allocator, arg: GetFuncInstanceKey)
     const func_ty = try ip.getFuncType(gpa, .{
         .param_types = arg.param_types,
         .return_type = arg.bare_return_type,
-        .comptime_bits = 0,
         .noalias_bits = arg.noalias_bits,
         .alignment = arg.alignment,
         .cc = arg.cc,
-        .is_var_args = false,
-        .is_generic = false,
         .is_noinline = arg.is_noinline,
-        .section_is_generic = false,
-        .addrspace_is_generic = false,
     });
 
     const generic_owner = unwrapCoercedFunc(ip, arg.generic_owner);

src/Sema.zig

@@ -7373,10 +7373,10 @@ fn analyzeCall(
         const memoized_arg_values = try sema.arena.alloc(InternPool.Index, func_ty_info.param_types.len);
 
         const owner_info = mod.typeToFunc(fn_owner_decl.ty).?;
+        const new_param_types = try sema.arena.alloc(InternPool.Index, owner_info.param_types.len);
         var new_fn_info: InternPool.GetFuncTypeKey = .{
-            .param_types = try sema.arena.alloc(InternPool.Index, owner_info.param_types.len),
+            .param_types = new_param_types,
             .return_type = owner_info.return_type,
-            .comptime_bits = 0,
             .noalias_bits = owner_info.noalias_bits,
             .alignment = if (owner_info.align_is_generic) null else owner_info.alignment,
             .cc = if (owner_info.cc_is_generic) null else owner_info.cc,
@@ -7403,7 +7403,7 @@ fn analyzeCall(
                 block,
                 &child_block,
                 inst,
-                new_fn_info.param_types,
+                new_param_types,
                 &arg_i,
                 args_info,
                 is_comptime_call,
@@ -21144,16 +21144,11 @@ fn zirReify(
 
             const ty = try mod.funcType(.{
                 .param_types = param_types,
-                .comptime_bits = 0,
                 .noalias_bits = noalias_bits,
                 .return_type = return_type.toIntern(),
                 .alignment = alignment,
                 .cc = cc,
                 .is_var_args = is_var_args,
-                .is_generic = false,
-                .is_noinline = false,
-                .section_is_generic = false,
-                .addrspace_is_generic = false,
             });
             return Air.internedToRef(ty.toIntern());
         },