Stack space not reused

[jrmuizel]

Given this code:

struct Obj([u8; 8]);

extern "C" { fn f(o: &Obj); }

pub unsafe fn main()
{
    let s = Obj([1,2,3,4,5,6,7,8]);
    f(&s);
    std::mem::drop(s);
    
    let r = Obj([11,12,13,14,15,16,17,18]);
    f(&r);
    std::mem::drop(r);
}

It compiles to:

example::main:
        push    rbx
        sub     rsp, 16
        movabs  rax, 578437695752307201
        mov     qword ptr [rsp], rax
        mov     rbx, qword ptr [rip + f@GOTPCREL]
        mov     rdi, rsp
        call    rbx
        movabs  rax, 1301839424133073931
        mov     qword ptr [rsp + 8], rax
        lea     rdi, [rsp + 8]
        call    rbx
        add     rsp, 16
        pop     rbx
        ret

The first value is stored at [rsp] and the second value at [rsp + 8]

The LLVM IR looks like:

; example::main
; Function Attrs: nounwind nonlazybind uwtable
define void @_ZN7example4main17h377fad6dc64462c1E() unnamed_addr #0 !dbg !6 {
start:
  %r = alloca %Obj, align 1
  %s = alloca %Obj, align 1
  %0 = getelementptr inbounds %Obj, %Obj* %s, i64 0, i32 0, i64 0, !dbg !10
  call void @llvm.lifetime.start.p0i8(i64 8, i8* nonnull %0), !dbg !10
  store i8 1, i8* %0, align 1, !dbg !11
  %1 = getelementptr inbounds %Obj, %Obj* %s, i64 0, i32 1, i64 1, !dbg !11
  store i8 2, i8* %1, align 1, !dbg !11
  %2 = getelementptr inbounds %Obj, %Obj* %s, i64 0, i32 1, i64 2, !dbg !11
  store i8 3, i8* %2, align 1, !dbg !11
  %3 = getelementptr inbounds %Obj, %Obj* %s, i64 0, i32 1, i64 3, !dbg !11
  store i8 4, i8* %3, align 1, !dbg !11
  %4 = getelementptr inbounds %Obj, %Obj* %s, i64 0, i32 1, i64 4, !dbg !11
  store i8 5, i8* %4, align 1, !dbg !11
  %5 = getelementptr inbounds %Obj, %Obj* %s, i64 0, i32 1, i64 5, !dbg !11
  store i8 6, i8* %5, align 1, !dbg !11
  %6 = getelementptr inbounds %Obj, %Obj* %s, i64 0, i32 1, i64 6, !dbg !11
  store i8 7, i8* %6, align 1, !dbg !11
  %7 = getelementptr inbounds %Obj, %Obj* %s, i64 0, i32 1, i64 7, !dbg !11
  store i8 8, i8* %7, align 1, !dbg !11
  call void @f(%Obj* noalias nonnull readonly align 1 dereferenceable(8) %s), !dbg !12
  %8 = getelementptr inbounds %Obj, %Obj* %r, i64 0, i32 0, i64 0, !dbg !13
  call void @llvm.lifetime.start.p0i8(i64 8, i8* nonnull %8), !dbg !13
  store i8 11, i8* %8, align 1, !dbg !14
  %9 = getelementptr inbounds %Obj, %Obj* %r, i64 0, i32 1, i64 1, !dbg !14
  store i8 12, i8* %9, align 1, !dbg !14
  %10 = getelementptr inbounds %Obj, %Obj* %r, i64 0, i32 1, i64 2, !dbg !14
  store i8 13, i8* %10, align 1, !dbg !14
  %11 = getelementptr inbounds %Obj, %Obj* %r, i64 0, i32 1, i64 3, !dbg !14
  store i8 14, i8* %11, align 1, !dbg !14
  %12 = getelementptr inbounds %Obj, %Obj* %r, i64 0, i32 1, i64 4, !dbg !14
  store i8 15, i8* %12, align 1, !dbg !14
  %13 = getelementptr inbounds %Obj, %Obj* %r, i64 0, i32 1, i64 5, !dbg !14
  store i8 16, i8* %13, align 1, !dbg !14
  %14 = getelementptr inbounds %Obj, %Obj* %r, i64 0, i32 1, i64 6, !dbg !14
  store i8 17, i8* %14, align 1, !dbg !14
  %15 = getelementptr inbounds %Obj, %Obj* %r, i64 0, i32 1, i64 7, !dbg !14
  store i8 18, i8* %15, align 1, !dbg !14
  call void @f(%Obj* noalias nonnull readonly align 1 dereferenceable(8) %r), !dbg !15
  call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %8), !dbg !16
  call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %0), !dbg !16
  ret void, !dbg !17
}

The llvm.lifetime.end intrinsic for the first value shows up at the end instead of after the call to drop. If I move it earlier then LLVM does reuse the stack slot.

[peacess]

i think the fn drop do not free the memory of S, just call the fn drop. s still use the stack memory, stack memory can not be reused.

[jrmuizel]

Why can't the stack memory be reused?

[Acciente717]

I see a relevant paragraph in The Rust Reference.
https://doc.rust-lang.org/reference/expressions.html#moved-and-copied-types

Moving out of a place expression that evaluates to a local variable, the location is deinitialized and cannot be read from again until it is reinitialized.

As an example,

let mut s = String::from("hello");
drop(s); // deinitialized s
/* cannot read from s here */
s = String::from("world"); // reinitialized

The question is whether "the location" in the quoted reference refers to the hardware level memory address storing the variable, in which case the reinitialized s must be placed at the same memory address as before; or "the location" refers to a more abstract notion such as an identifier of the symbol s, in which case we can put reinitialized s at another memory address?

[jrmuizel]

@nikic do you know if things are working as intended here?

[Boddlnagg]

The question is whether "the location" in the quoted reference refers to the hardware level memory address storing the variable, in which case the reinitialized s must be placed at the same memory address as before; or "the location" refers to a more abstract notion such as an identifier of the symbol s, in which case we can put reinitialized s at another memory address?

I don't think this makes a difference for the example stated above, because no variable is reinitialized there. It would be different if s was indeed reused after the drop, but if it isn't, then I see no reason why r could not reuse the stack space of s.