From 200b2e4ee108d388e0db2120aee38f83d1c7abdb Mon Sep 17 00:00:00 2001 From: Luuk de Gram Date: Sun, 17 Jul 2022 15:10:56 +0200 Subject: llvm: correctly lower c-abi for Wasm target When lowering the return type for Wasm if the calling convention is `C`, it now correctly lower it according to what clang does as specified in: https://github.com/WebAssembly/tool-conventions/blob/main/BasicCABI.md This makes use of the same logic as the Wasm backend, ensuring the generated code does not diverge in function signatures. When passing arguments accross the C-ABI for the Wasm target, we want slightly different behavior than x86_64. For instance: a struct with multiple fields must always be passed by reference, even if its ABI size fits in a single integer. However, we do pass larger integers such as 128bit by value, which LLVM will correctly lower to use double arguments instead. --- src/codegen/llvm.zig | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) (limited to 'src/codegen') diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig index c80ef3adc0..8dbb9cae31 100644 --- a/src/codegen/llvm.zig +++ b/src/codegen/llvm.zig @@ -22,6 +22,7 @@ const Type = @import("../type.zig").Type; const LazySrcLoc = Module.LazySrcLoc; const CType = @import("../type.zig").CType; const x86_64_abi = @import("../arch/x86_64/abi.zig"); +const wasm_c_abi = @import("../arch/wasm/abi.zig"); const Error = error{ OutOfMemory, CodegenFail }; @@ -9093,6 +9094,10 @@ fn firstParamSRet(fn_info: Type.Payload.Function.Data, target: std.Target) bool .windows => return x86_64_abi.classifyWindows(fn_info.return_type, target) == .memory, else => return x86_64_abi.classifySystemV(fn_info.return_type, target)[0] == .memory, }, + .wasm32 => { + const classes = wasm_c_abi.classifyType(fn_info.return_type, target); + return classes[0] == .indirect; + }, else => return false, // TODO investigate C ABI for other architectures }, else => return false, @@ -9197,6 +9202,20 @@ fn lowerFnRetTy(dg: *DeclGen, fn_info: Type.Payload.Function.Data) !*const llvm. return dg.context.structType(&llvm_types_buffer, llvm_types_index, .False); }, }, + .wasm32 => { + if (is_scalar) { + return dg.lowerType(fn_info.return_type); + } + const classes = wasm_c_abi.classifyType(fn_info.return_type, target); + if (classes[0] == .indirect or classes[0] == .none) { + return dg.context.voidType(); + } + + assert(classes[0] == .direct and classes[1] == .none); + const scalar_type = wasm_c_abi.scalarType(fn_info.return_type, target); + const abi_size = scalar_type.abiSize(target); + return dg.context.intType(@intCast(c_uint, abi_size * 8)); + }, // TODO investigate C ABI for other architectures else => return dg.lowerType(fn_info.return_type), } @@ -9372,6 +9391,18 @@ const ParamTypeIterator = struct { return .multiple_llvm_ints; }, }, + .wasm32 => { + it.zig_index += 1; + it.llvm_index += 1; + if (is_scalar) { + return .byval; + } + const classes = wasm_c_abi.classifyType(ty, it.target); + if (classes[0] == .indirect) { + return .byref; + } + return .abi_sized_int; + }, // TODO investigate C ABI for other architectures else => { it.zig_index += 1; -- cgit v1.2.3