Fix stack pointer retrieval in jl_backtrace_from_here

base/error.jl

@@ -99,6 +99,50 @@ function _reformat_bt(bt::Array{Ptr{Cvoid},1}, bt2::Array{Any,1})
     ret
 end
 
+"""
+    _reformat_sp(bt_data...) -> sp::Vector{Ptr{Cvoid}}
+
+Convert the output `bt_data` of `jl_backtrace_from_here` with `returnsp` flag set to a
+vector of valid stack pointers `sp`; i.e., `sp` is a subset of `bt_data[3]`.
+
+This function is used only in test.
+"""
+function _reformat_sp(
+    bt_raw::Array{Ptr{Cvoid},1},
+    bt2::Array{Any,1},
+    sp_raw::Array{Ptr{Cvoid},1},
+)
+    bt = _reformat_bt(bt_raw, bt2)
+    sp = empty!(similar(sp_raw))
+    i = j = 0
+    while true
+        # Advacne `i` such that `bt[i] isa Ptr{Cvoid}` (native poitner).
+        local ip
+        while true
+            if i == lastindex(bt)
+                return sp
+            end
+            i += 1
+            x = bt[i]
+            if x isa Ptr{Cvoid}
+                ip = x
+                break
+            end
+        end
+        # Advance `j` such that `bt_raw[j] == bt[i]` to find a valid stack pointer.
+        while true
+            if j == lastindex(bt_raw)
+                return sp
+            end
+            j += 1
+            if bt_raw[j] == ip
+                push!(sp, sp_raw[j])
+                break
+            end
+        end
+    end
+end
+
 """
     backtrace()
 

src/stackwalk.c

@@ -114,8 +114,6 @@ static int jl_unw_stepn(bt_cursor_t *cursor, jl_bt_element_t *bt_data, size_t *b
                 from_signal_handler = 0;
                 continue;
             }
-            if (sp)
-                sp[n] = thesp;
             // For the purposes of looking up debug info for functions, we want
             // to harvest addresses for the *call* instruction `call_ip` during
             // stack walking.  However, this information isn't directly
@@ -168,6 +166,8 @@ static int jl_unw_stepn(bt_cursor_t *cursor, jl_bt_element_t *bt_data, size_t *b
                 }
             }
             bt_entry->uintptr = call_ip;
+            if (sp)
+                sp[n] = thesp;
             n++;
         }
         // NOTE: if we have some pgcstack entries remaining (because the
@@ -259,8 +259,8 @@ JL_DLLEXPORT jl_value_t *jl_backtrace_from_here(int returnsp, int skip)
             jl_array_grow_end(ip, maxincr);
             uintptr_t *sp_ptr = NULL;
             if (returnsp) {
-                sp_ptr = (uintptr_t*)jl_array_data(sp) + offset;
                 jl_array_grow_end(sp, maxincr);
+                sp_ptr = (uintptr_t*)jl_array_data(sp) + offset;
             }
             size_t size_incr = 0;
             have_more_frames = jl_unw_stepn(&cursor, (jl_bt_element_t*)jl_array_data(ip) + offset,

test/backtrace.jl

@@ -258,3 +258,72 @@ let code = """
     @test occursin("InterpreterIP in top-level CodeInfo for Main.A", bt_str)
 end
 
+"""
+    withalloca(f, nbytes)
+
+Call function `f` with a `ptr::Ptr{Cvoid}` pointing to `nbytes` bytes of a
+stack-allocated memory region.
+
+NOTE: `f` and all functions reachable from `f` must not contain a yield point.
+"""
+function withalloca end
+@eval function withalloca(f, nbytes)
+    function wrapper(int)
+        f(Ptr{Cvoid}(int))
+        nothing
+    end
+    closure = @cfunction($(Expr(:$, :wrapper)), Cvoid, (UInt,))
+    GC.@preserve closure begin
+        Base.llvmcall(
+            (
+                $"""
+                define void @entry(i$(Sys.WORD_SIZE) %0, i$(Sys.WORD_SIZE) %1) {
+                top:
+                    %aptr = alloca i8, i$(Sys.WORD_SIZE) %1
+                    %aint = ptrtoint i8* %aptr to i$(Sys.WORD_SIZE)
+                    %fptr = inttoptr i$(Sys.WORD_SIZE) %0 to void (i$(Sys.WORD_SIZE))*
+                    call void %fptr(i$(Sys.WORD_SIZE) %aint)
+                    ret void
+                }
+                """,
+                "entry",
+            ),
+            Cvoid,
+            Tuple{Ptr{Cvoid},Int},
+            Base.unsafe_convert(Ptr{Cvoid}, closure),
+            nbytes,
+        )
+    end
+end
+
+function sandwiched_backtrace()
+    local ptr1, ptr2, bt
+    withalloca(16) do p1
+        ptr1 = p1
+        bt = ccall(:jl_backtrace_from_here, Ref{Base.SimpleVector}, (Cint, Cint), true, 0)
+        withalloca(16) do p2
+            ptr2 = p2
+        end
+    end
+    return ptr1, ptr2, bt
+end
+
+@testset "stack pointers" begin
+    y = try
+        sandwiched_backtrace()
+    catch err
+        err
+    end
+    if y isa Exception
+        msg = sprint(showerror, y)
+        @assert occursin("cfunction: closures are not supported on this platform", msg)
+        bt_data =
+            ccall(:jl_backtrace_from_here, Ref{Base.SimpleVector}, (Cint, Cint), true, 0)
+        sp = Base._reformat_sp(bt_data...)
+    else
+        ptr1, ptr2, bt_data = y
+        sp = Base._reformat_sp(bt_data...)
+        @test ptr2 < sp[1] < ptr1
+    end
+    @test all(diff(Int128.(UInt.(sp))) .> 0)
+end