| ... | @@ -858,69 +858,34 @@ pub const Object = struct { | ... | @@ -858,69 +858,34 @@ pub const Object = struct { |
| 858 | try args.append(aggregate); | 858 | try args.append(aggregate); |
| 859 | }, | 859 | }, |
| 860 | .multiple_llvm_ints => { | 860 | .multiple_llvm_ints => { |
| 861 | const param_ty = fn_info.param_types[it.zig_index - 1]; | | |
| 862 | const llvm_ints = it.llvm_types_buffer[0..it.llvm_types_len]; | 861 | const llvm_ints = it.llvm_types_buffer[0..it.llvm_types_len]; |
| 863 | const is_by_ref = isByRef(param_ty); | 862 | const param_ty = fn_info.param_types[it.zig_index - 1]; |
| 864 | switch (param_ty.zigTypeTag()) { | 863 | const param_llvm_ty = try dg.lowerType(param_ty); |
| 865 | .Struct => { | 864 | const param_alignment = param_ty.abiAlignment(target); |
| 866 | const fields = param_ty.structFields().values(); | 865 | const arg_ptr = buildAllocaInner(builder, llvm_func, false, param_llvm_ty); |
| 867 | if (is_by_ref) { | 866 | arg_ptr.setAlignment(param_alignment); |
| 868 | const param_llvm_ty = try dg.lowerType(param_ty); | 867 | var field_types_buf: [8]*const llvm.Type = undefined; |
| 869 | const arg_ptr = buildAllocaInner(builder, llvm_func, false, param_llvm_ty); | 868 | const field_types = field_types_buf[0..llvm_ints.len]; |
| 870 | arg_ptr.setAlignment(param_ty.abiAlignment(target)); | 869 | for (llvm_ints) |int_bits, i| { |
| 871 | | 870 | field_types[i] = dg.context.intType(int_bits); |
| 872 | var field_i: u32 = 0; | | |
| 873 | var field_offset: u32 = 0; | | |
| 874 | for (llvm_ints) |int_bits| { | | |
| 875 | const param = llvm_func.getParam(llvm_arg_i); | | |
| 876 | llvm_arg_i += 1; | | |
| 877 | | | |
| 878 | const big_int_ty = dg.context.intType(int_bits); | | |
| 879 | var bits_used: u32 = 0; | | |
| 880 | while (bits_used < int_bits) { | | |
| 881 | const field = fields[field_i]; | | |
| 882 | const field_alignment = field.normalAlignment(target); | | |
| 883 | const prev_offset = field_offset; | | |
| 884 | field_offset = std.mem.alignForwardGeneric(u32, field_offset, field_alignment); | | |
| 885 | if (field_offset > prev_offset) { | | |
| 886 | // Padding counts as bits used. | | |
| 887 | bits_used += (field_offset - prev_offset) * 8; | | |
| 888 | if (bits_used >= int_bits) break; | | |
| 889 | } | | |
| 890 | const field_size = @intCast(u16, field.ty.abiSize(target)); | | |
| 891 | const field_abi_bits = field_size * 8; | | |
| 892 | const field_int_ty = dg.context.intType(field_abi_bits); | | |
| 893 | const shifted = if (bits_used == 0) param else s: { | | |
| 894 | const shift_amt = big_int_ty.constInt(bits_used, .False); | | |
| 895 | break :s builder.buildLShr(param, shift_amt, ""); | | |
| 896 | }; | | |
| 897 | const field_as_int = builder.buildTrunc(shifted, field_int_ty, ""); | | |
| 898 | var ty_buf: Type.Payload.Pointer = undefined; | | |
| 899 | const llvm_i = llvmFieldIndex(param_ty, field_i, target, &ty_buf).?; | | |
| 900 | const field_ptr = builder.buildStructGEP(arg_ptr, llvm_i, ""); | | |
| 901 | const casted_ptr = builder.buildBitCast(field_ptr, field_int_ty.pointerType(0), ""); | | |
| 902 | const store_inst = builder.buildStore(field_as_int, casted_ptr); | | |
| 903 | store_inst.setAlignment(field_alignment); | | |
| 904 | | | |
| 905 | field_i += 1; | | |
| 906 | if (field_i >= fields.len) break; | | |
| 907 | | | |
| 908 | bits_used += field_abi_bits; | | |
| 909 | field_offset += field_size; | | |
| 910 | } | | |
| 911 | if (field_i >= fields.len) break; | | |
| 912 | } | | |
| 913 | | | |
| 914 | try args.append(arg_ptr); | | |
| 915 | } else { | | |
| 916 | @panic("TODO: LLVM backend: implement C calling convention on x86_64 with byval struct parameter"); | | |
| 917 | } | | |
| 918 | }, | | |
| 919 | .Union => { | | |
| 920 | @panic("TODO: LLVM backend: implement C calling convention on x86_64 with union parameter"); | | |
| 921 | }, | | |
| 922 | else => unreachable, | | |
| 923 | } | 871 | } |
| | 872 | const ints_llvm_ty = dg.context.structType(field_types.ptr, @intCast(c_uint, field_types.len), .False); |
| | 873 | const casted_ptr = builder.buildBitCast(arg_ptr, ints_llvm_ty.pointerType(0), ""); |
| | 874 | for (llvm_ints) |_, i_usize| { |
| | 875 | const i = @intCast(c_uint, i_usize); |
| | 876 | const param = llvm_func.getParam(i); |
| | 877 | const field_ptr = builder.buildStructGEP(casted_ptr, i, ""); |
| | 878 | const store_inst = builder.buildStore(param, field_ptr); |
| | 879 | store_inst.setAlignment(target.cpu.arch.ptrBitWidth() / 8); |
| | 880 | } |
| | 881 | |
| | 882 | const is_by_ref = isByRef(param_ty); |
| | 883 | const loaded = if (is_by_ref) arg_ptr else l: { |
| | 884 | const load_inst = builder.buildLoad(arg_ptr, ""); |
| | 885 | load_inst.setAlignment(param_alignment); |
| | 886 | break :l load_inst; |
| | 887 | }; |
| | 888 | try args.append(loaded); |
| 924 | }, | 889 | }, |
| 925 | }; | 890 | }; |
| 926 | } | 891 | } |
| ... | @@ -2822,65 +2787,11 @@ pub const DeclGen = struct { | ... | @@ -2822,65 +2787,11 @@ pub const DeclGen = struct { |
| 2822 | llvm_params.appendAssumeCapacity(len_llvm_ty); | 2787 | llvm_params.appendAssumeCapacity(len_llvm_ty); |
| 2823 | }, | 2788 | }, |
| 2824 | .multiple_llvm_ints => { | 2789 | .multiple_llvm_ints => { |
| 2825 | const param_ty = fn_info.param_types[it.zig_index - 1]; | | |
| 2826 | const llvm_ints = it.llvm_types_buffer[0..it.llvm_types_len]; | 2790 | const llvm_ints = it.llvm_types_buffer[0..it.llvm_types_len]; |
| 2827 | try llvm_params.ensureUnusedCapacity(it.llvm_types_len); | 2791 | try llvm_params.ensureUnusedCapacity(it.llvm_types_len); |
| 2828 | | 2792 | for (llvm_ints) |int_bits| { |
| 2829 | // The reason we have all this logic instead of simply appending | 2793 | const big_int_ty = dg.context.intType(int_bits); |
| 2830 | // big_int_ty is for the special case of a pointer type; | 2794 | llvm_params.appendAssumeCapacity(big_int_ty); |
| 2831 | // we want to use a pointer type instead of inttoptr at the callsites, | | |
| 2832 | // which may prevent optimization. | | |
| 2833 | switch (param_ty.zigTypeTag()) { | | |
| 2834 | .Struct => { | | |
| 2835 | const fields = param_ty.structFields().values(); | | |
| 2836 | var field_i: u32 = 0; | | |
| 2837 | var field_offset: u32 = 0; | | |
| 2838 | llvm_arg: for (llvm_ints) |int_bits| { | | |
| 2839 | const big_int_ty = dg.context.intType(int_bits); | | |
| 2840 | var bits_used: u32 = 0; | | |
| 2841 | while (bits_used < int_bits) { | | |
| 2842 | const field = fields[field_i]; | | |
| 2843 | const field_alignment = field.normalAlignment(target); | | |
| 2844 | const prev_offset = field_offset; | | |
| 2845 | field_offset = std.mem.alignForwardGeneric(u32, field_offset, field_alignment); | | |
| 2846 | if (field_offset > prev_offset) { | | |
| 2847 | // Padding counts as bits used. | | |
| 2848 | bits_used += (field_offset - prev_offset) * 8; | | |
| 2849 | if (bits_used >= int_bits) break; | | |
| 2850 | } | | |
| 2851 | const field_size = @intCast(u16, field.ty.abiSize(target)); | | |
| 2852 | const field_abi_bits = field_size * 8; | | |
| 2853 | | | |
| 2854 | // Special case for when the entire LLVM integer represents | | |
| 2855 | // one field; in this case keep the type information | | |
| 2856 | // to avoid the potentially costly ptrtoint/bitcast. | | |
| 2857 | if (bits_used == 0 and field_abi_bits == int_bits) { | | |
| 2858 | const llvm_field_ty = try dg.lowerType(field.ty); | | |
| 2859 | llvm_params.appendAssumeCapacity(llvm_field_ty); | | |
| 2860 | field_i += 1; | | |
| 2861 | if (field_i >= fields.len) { | | |
| 2862 | break :llvm_arg; | | |
| 2863 | } else { | | |
| 2864 | continue :llvm_arg; | | |
| 2865 | } | | |
| 2866 | } | | |
| 2867 | | | |
| 2868 | field_i += 1; | | |
| 2869 | if (field_i >= fields.len) break; | | |
| 2870 | | | |
| 2871 | bits_used += field_abi_bits; | | |
| 2872 | field_offset += field_size; | | |
| 2873 | } | | |
| 2874 | llvm_params.appendAssumeCapacity(big_int_ty); | | |
| 2875 | if (field_i >= fields.len) break; | | |
| 2876 | } | | |
| 2877 | }, | | |
| 2878 | else => { | | |
| 2879 | for (llvm_ints) |int_bits| { | | |
| 2880 | const big_int_ty = dg.context.intType(int_bits); | | |
| 2881 | llvm_params.appendAssumeCapacity(big_int_ty); | | |
| 2882 | } | | |
| 2883 | }, | | |
| 2884 | } | 2795 | } |
| 2885 | }, | 2796 | }, |
| 2886 | }; | 2797 | }; |
| ... | @@ -4300,80 +4211,27 @@ pub const FuncGen = struct { | ... | @@ -4300,80 +4211,27 @@ pub const FuncGen = struct { |
| 4300 | const llvm_ints = it.llvm_types_buffer[0..it.llvm_types_len]; | 4211 | const llvm_ints = it.llvm_types_buffer[0..it.llvm_types_len]; |
| 4301 | const llvm_arg = try self.resolveInst(arg); | 4212 | const llvm_arg = try self.resolveInst(arg); |
| 4302 | const is_by_ref = isByRef(param_ty); | 4213 | const is_by_ref = isByRef(param_ty); |
| 4303 | try llvm_args.ensureUnusedCapacity(it.llvm_types_len); | 4214 | const arg_ptr = if (is_by_ref) llvm_arg else p: { |
| 4304 | switch (param_ty.zigTypeTag()) { | 4215 | const p = self.buildAlloca(llvm_arg.typeOf()); |
| 4305 | .Struct => { | 4216 | const store_inst = self.builder.buildStore(llvm_arg, p); |
| 4306 | const fields = param_ty.structFields().values(); | 4217 | store_inst.setAlignment(param_ty.abiAlignment(target)); |
| 4307 | var field_i: u32 = 0; | 4218 | break :p p; |
| 4308 | var field_offset: u32 = 0; | 4219 | }; |
| 4309 | for (llvm_ints) |int_bits| { | | |
| 4310 | const big_int_ty = self.dg.context.intType(int_bits); | | |
| 4311 | var int_arg: *const llvm.Value = undefined; | | |
| 4312 | var bits_used: u32 = 0; | | |
| 4313 | while (bits_used < int_bits) { | | |
| 4314 | const field = fields[field_i]; | | |
| 4315 | const field_alignment = field.normalAlignment(target); | | |
| 4316 | const prev_offset = field_offset; | | |
| 4317 | field_offset = std.mem.alignForwardGeneric(u32, field_offset, field_alignment); | | |
| 4318 | if (field_offset > prev_offset) { | | |
| 4319 | // Padding counts as bits used. | | |
| 4320 | bits_used += (field_offset - prev_offset) * 8; | | |
| 4321 | if (bits_used >= int_bits) break; | | |
| 4322 | } | | |
| 4323 | var ty_buf: Type.Payload.Pointer = undefined; | | |
| 4324 | const llvm_i = llvmFieldIndex(param_ty, field_i, target, &ty_buf).?; | | |
| 4325 | const field_size = @intCast(u16, field.ty.abiSize(target)); | | |
| 4326 | const field_abi_bits = field_size * 8; | | |
| 4327 | | | |
| 4328 | // Special case for when the entire LLVM integer represents | | |
| 4329 | // one field; in this case keep the type information | | |
| 4330 | // to avoid the potentially costly ptrtoint/bitcast. | | |
| 4331 | if (bits_used == 0 and field_abi_bits == int_bits) { | | |
| 4332 | int_arg = if (is_by_ref) f: { | | |
| 4333 | const field_ptr = self.builder.buildStructGEP(llvm_arg, llvm_i, ""); | | |
| 4334 | const load_inst = self.builder.buildLoad(field_ptr, ""); | | |
| 4335 | load_inst.setAlignment(field_alignment); | | |
| 4336 | break :f load_inst; | | |
| 4337 | } else self.builder.buildExtractValue(llvm_arg, llvm_i, ""); | | |
| 4338 | field_i += 1; | | |
| 4339 | break; | | |
| 4340 | } | | |
| 4341 | | | |
| 4342 | const field_int_ty = self.dg.context.intType(field_abi_bits); | | |
| 4343 | const llvm_field = if (is_by_ref) f: { | | |
| 4344 | const field_ptr = self.builder.buildStructGEP(llvm_arg, llvm_i, ""); | | |
| 4345 | const casted_ptr = self.builder.buildBitCast(field_ptr, field_int_ty.pointerType(0), ""); | | |
| 4346 | const load_inst = self.builder.buildLoad(casted_ptr, ""); | | |
| 4347 | load_inst.setAlignment(field_alignment); | | |
| 4348 | break :f load_inst; | | |
| 4349 | } else f: { | | |
| 4350 | const llvm_field = self.builder.buildExtractValue(llvm_arg, llvm_i, ""); | | |
| 4351 | break :f self.builder.buildBitCast(llvm_field, field_int_ty, ""); | | |
| 4352 | }; | | |
| 4353 | | | |
| 4354 | const extended = self.builder.buildZExt(llvm_field, big_int_ty, ""); | | |
| 4355 | if (bits_used == 0) { | | |
| 4356 | int_arg = extended; | | |
| 4357 | } else { | | |
| 4358 | const shift_amt = big_int_ty.constInt(bits_used, .False); | | |
| 4359 | const shifted = self.builder.buildShl(extended, shift_amt, ""); | | |
| 4360 | int_arg = self.builder.buildOr(int_arg, shifted, ""); | | |
| 4361 | } | | |
| 4362 | | | |
| 4363 | field_i += 1; | | |
| 4364 | if (field_i >= fields.len) break; | | |
| 4365 | | 4220 | |
| 4366 | bits_used += field_abi_bits; | 4221 | var field_types_buf: [8]*const llvm.Type = undefined; |
| 4367 | field_offset += field_size; | 4222 | const field_types = field_types_buf[0..llvm_ints.len]; |
| 4368 | } | 4223 | for (llvm_ints) |int_bits, i| { |
| 4369 | llvm_args.appendAssumeCapacity(int_arg); | 4224 | field_types[i] = self.dg.context.intType(int_bits); |
| 4370 | if (field_i >= fields.len) break; | 4225 | } |
| 4371 | } | 4226 | const ints_llvm_ty = self.dg.context.structType(field_types.ptr, @intCast(c_uint, field_types.len), .False); |
| 4372 | }, | 4227 | const casted_ptr = self.builder.buildBitCast(arg_ptr, ints_llvm_ty.pointerType(0), ""); |
| 4373 | .Union => { | 4228 | try llvm_args.ensureUnusedCapacity(it.llvm_types_len); |
| 4374 | return self.todo("airCall C calling convention on x86_64 with union argument ", .{}); | 4229 | for (llvm_ints) |_, i_usize| { |
| 4375 | }, | 4230 | const i = @intCast(c_uint, i_usize); |
| 4376 | else => unreachable, | 4231 | const field_ptr = self.builder.buildStructGEP(casted_ptr, i, ""); |
| | 4232 | const load_inst = self.builder.buildLoad(field_ptr, ""); |
| | 4233 | load_inst.setAlignment(target.cpu.arch.ptrBitWidth() / 8); |
| | 4234 | llvm_args.appendAssumeCapacity(load_inst); |
| 4377 | } | 4235 | } |
| 4378 | }, | 4236 | }, |
| 4379 | }; | 4237 | }; |
Andrew Kelley <andrew@ziglang.org> 2022-07-07 18:25:01-07:00
lib