diff --git a/src/tests/stacktrace_unittest.cc b/src/tests/stacktrace_unittest.cc
index 3c9f735..e55a632 100644
--- a/src/tests/stacktrace_unittest.cc
+++ b/src/tests/stacktrace_unittest.cc
@@ -1,10 +1,11 @@
+// -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*-
 // Copyright (c) 2005, Google Inc.
 // All rights reserved.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
-// 
+//
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ -14,7 +15,7 @@
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
-// 
+//
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
@@ -33,9 +34,18 @@
 #endif
 #include <stdio.h>
 #include <stdlib.h>
+
+// On those architectures we can and should test if backtracing with
+// ucontext and from signal handler works
+#if __GNUC__ && __linux__ && (__x86_64__ || __aarch64__ || __riscv)
+#include <signal.h>
+#define TEST_UCONTEXT_BITS 1
+#endif
+
 #include "base/commandlineflags.h"
 #include "base/logging.h"
 #include <gperftools/stacktrace.h>
+#include "tests/testutil.h"
 
 namespace {
 
@@ -96,6 +106,7 @@
 #define ADJUST_ADDRESS_RANGE_FROM_RA(prange) do { } while (0)
 #endif  // __GNUC__
 
+
 //-----------------------------------------------------------------------//
 
 void CheckRetAddrIsInFunction(void *ret_addr, const AddressRange &range)
@@ -106,24 +117,105 @@
 
 //-----------------------------------------------------------------------//
 
+#if TEST_UCONTEXT_BITS
+
+struct get_stack_trace_args {
+	int *size_ptr;
+	void **result;
+	int max_depth;
+	uintptr_t where;
+} gst_args;
+
+static
+void SignalHandler(int dummy, siginfo_t *si, void* ucv) {
+	auto uc = static_cast<ucontext_t*>(ucv);
+
+#ifdef __riscv
+	uc->uc_mcontext.__gregs[REG_PC] = gst_args.where;
+#elif __aarch64__
+	uc->uc_mcontext.pc = gst_args.where;
+#else
+	uc->uc_mcontext.gregs[REG_RIP] = gst_args.where;
+#endif
+
+	*gst_args.size_ptr = GetStackTraceWithContext(
+		gst_args.result,
+		gst_args.max_depth,
+		2,
+		uc);
+}
+
+int ATTRIBUTE_NOINLINE CaptureLeafUContext(void **stack, int stack_len) {
+  INIT_ADDRESS_RANGE(CheckStackTraceLeaf, start, end, &expected_range[0]);
+  DECLARE_ADDRESS_LABEL(start);
+
+  int size;
+
+  printf("Capturing stack trace from signal's ucontext\n");
+  struct sigaction sa;
+  memset(&sa, 0, sizeof(sa));
+  sa.sa_sigaction = SignalHandler;
+  sa.sa_flags = SA_SIGINFO | SA_RESETHAND;
+  int rv = sigaction(SIGSEGV, &sa, nullptr);
+  CHECK(rv == 0);
+
+  gst_args.size_ptr = &size;
+  gst_args.result = stack;
+  gst_args.max_depth = stack_len;
+  gst_args.where = reinterpret_cast<uintptr_t>(noopt(&&after));
+
+  // now, "write" to null pointer and trigger sigsegv to run signal
+  // handler. It'll then change PC to after, as if we jumped one line
+  // below.
+  *noopt(reinterpret_cast<void**>(0)) = 0;
+  // this is not reached, but gcc gets really odd if we don't actually
+  // use computed goto.
+  static void* jump_target = &&after;
+  goto *noopt(&jump_target);
+
+after:
+  printf("Obtained %d stack frames.\n", size);
+  CHECK_GE(size, 1);
+  CHECK_LE(size, stack_len);
+
+  DECLARE_ADDRESS_LABEL(end);
+
+  return size;
+}
+
+#endif  // TEST_UCONTEXT_BITS
+
+int ATTRIBUTE_NOINLINE CaptureLeafPlain(void **stack, int stack_len) {
+  INIT_ADDRESS_RANGE(CheckStackTraceLeaf, start, end, &expected_range[0]);
+  DECLARE_ADDRESS_LABEL(start);
+
+  int size = GetStackTrace(stack, stack_len, 0);
+
+  printf("Obtained %d stack frames.\n", size);
+  CHECK_GE(size, 1);
+  CHECK_LE(size, stack_len);
+
+  DECLARE_ADDRESS_LABEL(end);
+
+  return size;
+}
+
 void ATTRIBUTE_NOINLINE CheckStackTrace(int);
-void ATTRIBUTE_NOINLINE CheckStackTraceLeaf(void) {
-  const int STACK_LEN = 10;
+
+int (*leaf_capture_fn)(void**, int) = CaptureLeafPlain;
+
+void ATTRIBUTE_NOINLINE CheckStackTraceLeaf(int i) {
+  const int STACK_LEN = 20;
   void *stack[STACK_LEN];
   int size;
 
   ADJUST_ADDRESS_RANGE_FROM_RA(&expected_range[1]);
-  INIT_ADDRESS_RANGE(CheckStackTraceLeaf, start, end, &expected_range[0]);
-  DECLARE_ADDRESS_LABEL(start);
-  size = GetStackTrace(stack, STACK_LEN, 0);
-  printf("Obtained %d stack frames.\n", size);
-  CHECK_GE(size, 1);
-  CHECK_LE(size, STACK_LEN);
+
+  size = leaf_capture_fn(stack, STACK_LEN);
 
 #ifdef HAVE_EXECINFO_H
   {
     char **strings = backtrace_symbols(stack, size);
-    printf("Obtained %d stack frames.\n", size);
     for (int i = 0; i < size; i++)
       printf("%s %p\n", strings[i], stack[i]);
     printf("CheckStackTrace() addr: %p\n", &CheckStackTrace);
@@ -131,14 +223,18 @@
   }
 #endif
 
-  for (int i = 0; i < BACKTRACE_STEPS; i++) {
+  for (int i = 0, j = 0; i < BACKTRACE_STEPS; i++, j++) {
+    if (i == 1 && j == 1) {
+      // this is expected to be our function for which we don't
+      // establish bounds. So skip.
+      j++;
+    }
     printf("Backtrace %d: expected: %p..%p  actual: %p ... ",
-           i, expected_range[i].start, expected_range[i].end, stack[i]);
+           i, expected_range[i].start, expected_range[i].end, stack[j]);
     fflush(stdout);
-    CheckRetAddrIsInFunction(stack[i], expected_range[i]);
+    CheckRetAddrIsInFunction(stack[j], expected_range[i]);
     printf("OK\n");
   }
-  DECLARE_ADDRESS_LABEL(end);
 }
 
 //-----------------------------------------------------------------------//
@@ -149,7 +245,7 @@
   INIT_ADDRESS_RANGE(CheckStackTrace4, start, end, &expected_range[1]);
   DECLARE_ADDRESS_LABEL(start);
   for (int j = i; j >= 0; j--)
-    CheckStackTraceLeaf();
+    CheckStackTraceLeaf(j);
   DECLARE_ADDRESS_LABEL(end);
 }
 void ATTRIBUTE_NOINLINE CheckStackTrace3(int i) {
@@ -179,8 +275,9 @@
 void ATTRIBUTE_NOINLINE CheckStackTrace(int i) {
   INIT_ADDRESS_RANGE(CheckStackTrace, start, end, &expected_range[5]);
   DECLARE_ADDRESS_LABEL(start);
-  for (int j = i; j >= 0; j--)
+  for (int j = i; j >= 0; j--) {
     CheckStackTrace1(j);
+  }
   DECLARE_ADDRESS_LABEL(end);
 }
 
@@ -190,5 +287,12 @@
 int main(int argc, char ** argv) {
   CheckStackTrace(0);
   printf("PASS\n");
+
+#if TEST_UCONTEXT_BITS
+  leaf_capture_fn = CaptureLeafUContext;
+  CheckStackTrace(0);
+  printf("PASS\n");
+#endif  // TEST_UCONTEXT_BITS
+
   return 0;
 }