@frameSize gives incorrect result

[Sahnvour]

const std = @import("std");

fn foo(a: u32, b: u32) u32 {
 return a + b;
}

fn bar() void {
 std.debug.warn("bar\n");
}

pub fn main() void {
 std.debug.warn("{}, {}\n", @frameSize(foo), @as(usize, @sizeOf(@Frame(foo))));
 std.debug.warn("{}, {}\n", @frameSize(bar), @as(usize, @sizeOf(@Frame(bar))));
}

gives an output similar to

$ zig run framesize.zig
10416984888683040912, 48
10416984888683040912, 32

tested on windows and linux, x64.

LLVM-IR:

; Function Attrs: nobuiltin noinline noreturn nounwind uwtable alignstack(16)
define void @WinMainCRTStartup() local_unnamed_addr #3 !dbg !858 {
Entry:
 %0 = load i64, i64* getelementptr (i64, i64* bitcast (i32 (i32, i32)* @foo to i64*), i64 -1), align 8, !dbg !863
 tail call fastcc void @std.debug.warn(i64 %0, i64 48) #5, !dbg !878
 %1 = load i64, i64* getelementptr (i64, i64* bitcast (void ()* @bar to i64*), i64 -1), align 8, !dbg !879
 tail call fastcc void @std.debug.warn(i64 %1, i64 32) #5, !dbg !880
 tail call void @ExitProcess(i32 0), !dbg !881
 unreachable, !dbg !883
}

Reading the documentation, they should be equal.
Also the doc is not up-to-date as it says @frameSize takes no parameter.

[LemonBoy]

The async functions store the frame size in the prefix-data section, @frameSize blindly returns the content of the usize value before the function start and returns hot garbage if used on anything else but an async function.

Since it's supposed to work for runtime-known values too you can fix this by:

• Always storing the frame size in the prefix header
• Return a constant value if the function is not async and ir_resolve_fn lets you access the frame type
• Reject any function whose CC is not async

[andrewrk]

I think we can make them equal. The code that emits the prefix data lookup can see if the function is async. If it's runtime, it can check the CC, as @LemonBoy notes. In this case, if the CC is non-async, it is possible to calculate the size without knowing which function it is.

Here's where the @Frame(func) for non-async functions is made:

zig/src/analyze.cpp

Lines 5956 to 5986 in cd5c9c8

	if (!fn_is_async(fn)) {
	ZigType *fn_type = fn->type_entry;
	FnTypeId *fn_type_id = &fn_type->data.fn.fn_type_id;
	ZigType *ptr_return_type = get_pointer_to_type(g, fn_type_id->return_type, false);
	// label (grep this): [fn_frame_struct_layout]
	ZigList<SrcField> fields = {};
	fields.append({"@fn_ptr", g->builtin_types.entry_usize, 0});
	fields.append({"@resume_index", g->builtin_types.entry_usize, 0});
	fields.append({"@awaiter", g->builtin_types.entry_usize, 0});
	fields.append({"@result_ptr_callee", ptr_return_type, 0});
	fields.append({"@result_ptr_awaiter", ptr_return_type, 0});
	fields.append({"@result", fn_type_id->return_type, 0});
	if (codegen_fn_has_err_ret_tracing_arg(g, fn_type_id->return_type)) {
	ZigType *ptr_to_stack_trace_type = get_pointer_to_type(g, get_stack_trace_type(g), false);
	fields.append({"@ptr_stack_trace_callee", ptr_to_stack_trace_type, 0});
	fields.append({"@ptr_stack_trace_awaiter", ptr_to_stack_trace_type, 0});
	fields.append({"@stack_trace", get_stack_trace_type(g), 0});
	fields.append({"@instruction_addresses",
	get_array_type(g, g->builtin_types.entry_usize, stack_trace_ptr_count), 0});
	}
	frame_type->data.frame.locals_struct = get_struct_type(g, buf_ptr(&frame_type->name),
	fields.items, fields.length, target_fn_align(g->zig_target));
	frame_type->abi_size = frame_type->data.frame.locals_struct->abi_size;
	frame_type->abi_align = frame_type->data.frame.locals_struct->abi_align;
	frame_type->size_in_bits = frame_type->data.frame.locals_struct->size_in_bits;

You can see the size of this only depends on the return type, which is available in the function pointer type.