Align stack and instruction pointers

Author: tkf

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

test/backtrace.jl

@@ -258,3 +258,58 @@ 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(f, nbytes)
+    function wrapper(int)
+        f(Ptr{Cvoid}(int))
+        nothing
+    end
+    closure = @cfunction($wrapper, Cvoid, (UInt64,))
+    GC.@preserve closure begin
+        Base.llvmcall(
+            (
+                """
+                define void @entry(i64 %0, i64 %1) {
+                top:
+                    %aptr = alloca i64, i64 %1
+                    %aint = ptrtoint i64* %aptr to i64
+                    %fptr = inttoptr i64 %0 to void (i64)*
+                    call void %fptr(i64 %aint)
+                    ret void
+                }
+                """,
+                "entry",
+            ),
+            Cvoid,
+            Tuple{Ptr{Cvoid},Int64},
+            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
+    ptr1, ptr2, bt_data = sandwiched_backtrace()
+    sp = Base._reformat_sp(bt_data...)
+    @test ptr2 < sp[1] < ptr1
+    @test all(diff(Int128.(UInt.(sp))) .> 0)
+end