SanitizerCommon: fixes for unwinding & backtrace on SPARC

[ebotcazou]

Summary

This patch contains various fixes for the unwinding and backtrace machinery on the SPARC, which doesn't work correctly in various cases. It was tested with GCC on SPARC/Solaris and SPARC/Linux.

Patch by Eric Botcazou.

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_sparc.cc

35

I am not sure that we need to compensate here
usually it's from GetStackTrace which pass the current PC or PC from signal

compiler-rt/lib/sanitizer_common/sanitizer_unwind_linux_libcdep.cc

139

that's strange
is this know issue?

[ebotcazou]

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_sparc.cc

35

Yes, we do, the backtrace does GetPreviousInstructionPc in every case so, if you don' t do it there too, then the backtrace is wrong.

compiler-rt/lib/sanitizer_common/sanitizer_unwind_linux_libcdep.cc

139

Yes, it's a known historical quirk on the SPARC. The root cause is probably that, in 32-bit mode, the return address is either %o7+8 or %o7+12 depending on the return type and the correct case isn't always easy to spot. That's not the case in 64-bit mode, but the usage was preserved, for the sake of consistency I presume.

[ebotcazou]

Any objection to accepting this? We need it alongside D58433 to fix the Sanitizer failures in the GCC testsuite on the SPARC platforms and I'd rather not maintain it separately in the GCC tree.

[ebotcazou]

Conflict in sanitizer_common/sanitizer_stacktrace_sparc.cc fixed.

Sorry for bothering you again, but yln's recent changes are in the way now.

[ebotcazou]

Conflict in sanitizer_common/sanitizer_stacktrace_sparc.cc fixed.

Sorry for bothering you again, but yln's recent changes are in the way now.

[ebotcazou]

Can anyone with write access install D5831, D5832, D5833 and D5834? Arcanist says that I don't have permission to push to the repository on GitHub. Thanks in advance.

[ebotcazou]

Can anyone with write access install D58431, D58432, D58433 and D58434? Arcanist says that I don't have permission to push to the repository on GitHub. Thanks in advance.

compiler-rt/lib/sanitizer_common/sanitizer_linux.cc

#elif defined(__arm__)
   static const uptr FSR_WRITE = 1U << 11;
   uptr fsr = ucontext->uc_mcontext.error_code;
   return fsr & FSR_WRITE ? WRITE : READ;
 #elif defined(__aarch64__)
   static const u64 ESR_ELx_WNR = 1U << 6;
   u64 esr;
   if (!Aarch64GetESR(ucontext, &esr)) return UNKNOWN;
   return esr & ESR_ELx_WNR ? WRITE : READ;
-#elif SANITIZER_SOLARIS && defined(__sparc__)
+#elif defined(__sparc__)
   // Decode the instruction to determine the access type.
   // From OpenSolaris $SRC/uts/sun4/os/trap.c (get_accesstype).
+# if SANITIZER_SOLARIS
   uptr pc = ucontext->uc_mcontext.gregs[REG_PC];
+# else
+  // Historical BSDism here.
+  struct sigcontext *scontext = (struct sigcontext *)context;
+#  if defined(__arch64__)
+  uptr pc = scontext->sigc_regs.tpc;
+#  else
+  uptr pc = scontext->si_regs.pc;
+#  endif
+# endif
   u32 instr = *(u32 *)pc;
   return (instr >> 21) & 1 ? WRITE: READ;
 #else
   (void)ucontext;
   return UNKNOWN;  // FIXME: Implement.
 #endif
 }
 

 #elif defined(__powerpc__) || defined(__powerpc64__)
   ucontext_t *ucontext = (ucontext_t*)context;
   *pc = ucontext->uc_mcontext.regs->nip;
   *sp = ucontext->uc_mcontext.regs->gpr[PT_R1];
   // The powerpc{,64}-linux ABIs do not specify r31 as the frame
   // pointer, but GCC always uses r31 when we need a frame pointer.
   *bp = ucontext->uc_mcontext.regs->gpr[PT_R31];
 #elif defined(__sparc__)
-  ucontext_t *ucontext = (ucontext_t*)context;
-  uptr *stk_ptr;
-# if defined(__sparcv9) || defined (__arch64__)
-# ifndef MC_PC
-#  define MC_PC REG_PC
-# endif
-# ifndef MC_O6
-#  define MC_O6 REG_O6
+# if defined(__arch64__) || defined(__sparcv9)
+#  define STACK_BIAS 2047
+# else
+#  define STACK_BIAS 0
 # endif
 # if SANITIZER_SOLARIS
-#  define mc_gregs gregs
-# endif
-  *pc = ucontext->uc_mcontext.mc_gregs[MC_PC];
-  *sp = ucontext->uc_mcontext.mc_gregs[MC_O6];
-  stk_ptr = (uptr *) (*sp + 2047);
-  *bp = stk_ptr[15];
-# else
+  ucontext_t *ucontext = (ucontext_t*)context;
   *pc = ucontext->uc_mcontext.gregs[REG_PC];
-  *sp = ucontext->uc_mcontext.gregs[REG_O6];
-  stk_ptr = (uptr *) *sp;
-  *bp = stk_ptr[15];
+  *sp = ucontext->uc_mcontext.gregs[REG_O6] + STACK_BIAS;
+# else
+  // Historical BSDism here.
+  struct sigcontext *scontext = (struct sigcontext *)context;
+#  if defined(__arch64__)
+  *pc = scontext->sigc_regs.tpc;
+  *sp = scontext->sigc_regs.u_regs[14] + STACK_BIAS;
+#  else
+  *pc = scontext->si_regs.pc;
+  *sp = scontext->si_regs.u_regs[14];
+#  endif
 # endif
+  *bp = (uptr) ((uhwptr *) *sp)[14] + STACK_BIAS;
 #elif defined(__mips__)
   ucontext_t *ucontext = (ucontext_t*)context;
   *pc = ucontext->uc_mcontext.pc;
   *bp = ucontext->uc_mcontext.gregs[30];
   *sp = ucontext->uc_mcontext.gregs[29];
 #elif defined(__s390__)
   ucontext_t *ucontext = (ucontext_t*)context;
 # if defined(__s390x__)

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace.h

 #define SANITIZER_STACKTRACE_H
 
 #include "sanitizer_internal_defs.h"
 
 namespace __sanitizer {
 
 static const u32 kStackTraceMax = 256;
 
-#if defined(__sparc__) || (SANITIZER_LINUX && defined(__mips__))
+#if SANITIZER_LINUX && defined(__mips__)
 # define SANITIZER_CAN_FAST_UNWIND 0
 #elif SANITIZER_WINDOWS
 # define SANITIZER_CAN_FAST_UNWIND 0
 #elif SANITIZER_OPENBSD
 # define SANITIZER_CAN_FAST_UNWIND 0
 #else
 # define SANITIZER_CAN_FAST_UNWIND 1
 #endif

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace.cc

 
 #include "sanitizer_common.h"
 #include "sanitizer_flags.h"
 #include "sanitizer_stacktrace.h"
 
 namespace __sanitizer {
 
 uptr StackTrace::GetNextInstructionPc(uptr pc) {
-#if defined(__mips__)
+#if defined(__sparc__) || defined(__mips__)
   return pc + 8;
-#elif defined(__powerpc__) || defined(__sparc__) || defined(__arm__) || \
-    defined(__aarch64__)
+#elif defined(__powerpc__) || defined(__arm__) || defined(__aarch64__)
   return pc + 4;
 #else
   return pc + 1;
 #endif
 }
 
 uptr StackTrace::GetCurrentPc() {
   return GET_CALLER_PC();

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_sparc.cc

 //===-- sanitizer_stacktrace_sparc.cc -------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is shared between AddressSanitizer and ThreadSanitizer
 // run-time libraries.
 //
 // Implemention of fast stack unwinding for Sparc.
 //===----------------------------------------------------------------------===//
 
-// This file is ported to Sparc v8, but it should be easy to port to
-// Sparc v9.
-#if defined(__sparcv8__) || defined(__sparcv8) || defined(__sparc_v8__)
+#if defined(__sparc__)
+
+#if defined(__arch64__) || defined(__sparcv9)
+#define STACK_BIAS 2047
+#else
+#define STACK_BIAS 0
+#endif
 
 #include "sanitizer_common.h"
 #include "sanitizer_stacktrace.h"
 
 namespace __sanitizer {
 
 void BufferedStackTrace::UnwindFast(uptr pc, uptr bp, uptr stack_top,
                                     uptr stack_bottom, u32 max_depth) {
   // TODO(yln): add arg sanity check for stack_top/stack_bottom
   CHECK_GE(max_depth, 2);
   const uptr kPageSize = GetPageSizeCached();
+#if defined(__GNUC__)
+  // __builtin_return_address returns the address of the call instruction
+  // on the SPARC and not the return address, so we need to compensate.
+  trace_buffer[0] = GetNextInstructionPc(pc);
+#else
   trace_buffer[0] = pc;
+#endif
   size = 1;
   if (stack_top < 4096) return;  // Sanity check for stack top.
   // Flush register windows to memory
+#if defined(__sparc_v9__) || defined(__sparcv9__) || defined(__sparcv9)
+  asm volatile("flushw" ::: "memory");
+#else
   asm volatile("ta 3" ::: "memory");
-  uhwptr *frame = (uhwptr*)bp;
+#endif
+  // On the SPARC, the return address is not in the frame, it is in a
+  // register.  There is no way to access it off of the current frame
+  // pointer, but it can be accessed off the previous frame pointer by
+  // reading the value from the register window save area.
+  uptr prev_bp = GET_CURRENT_FRAME();
+  uptr next_bp = prev_bp;
+  unsigned int i = 0;
+  while (next_bp != bp &&
+   IsAligned(next_bp, sizeof(uhwptr)) &&
+   i++ < 8) {
+    prev_bp = next_bp;
+    next_bp = (uptr) ((uhwptr *) next_bp)[14] + STACK_BIAS;
+  }
+  if (next_bp == bp)
+    bp = prev_bp;
   // Lowest possible address that makes sense as the next frame pointer.
   // Goes up as we walk the stack.
   uptr bottom = stack_bottom;
   // Avoid infinite loop when frame == frame[0] by using frame > prev_frame.
-  while (IsValidFrame((uptr)frame, stack_top, bottom) &&
-         IsAligned((uptr)frame, sizeof(*frame)) &&
+  while (IsValidFrame(bp, stack_top, bottom) &&
+         IsAligned(bp, sizeof(uhwptr)) &&
          size < max_depth) {
-    uhwptr pc1 = frame[15];
+    uhwptr pc1 = ((uhwptr *)bp)[15];
     // Let's assume that any pointer in the 0th page is invalid and
     // stop unwinding here.  If we're adding support for a platform
     // where this isn't true, we need to reconsider this check.
     if (pc1 < kPageSize)
       break;
     if (pc1 != pc) {
-      trace_buffer[size++] = (uptr) pc1;
+      // %o7 contains the address of the call instruction and not the
+      // return address, so we need to compensate.
+      trace_buffer[size++] = GetNextInstructionPc((uptr) pc1);
     }
-    bottom = (uptr)frame;
-    frame = (uhwptr*)frame[14];
+    bottom = bp;
+    bp = (uptr) ((uhwptr *) bp)[14] + STACK_BIAS;
   }
 }
 
 }  // namespace __sanitizer
 
-#endif  // !defined(__sparcv8__) && !defined(__sparcv8) &&
-        // !defined(__sparc_v8__)
+#endif  // !defined(__sparc__)

compiler-rt/lib/sanitizer_common/sanitizer_unwind_linux_libcdep.cc

void BufferedStackTrace::UnwindSlow(uptr pc, u32 max_depth) {
   // unless there is only 1 frame in the stack trace (1 frame is always better
   // than 0!).
   // 1-frame stacks don't normally happen, but this depends on the actual
   // unwinder implementation (libgcc, libunwind, etc) which is outside of our
   // control.
   if (to_pop == 0 && size > 1)
     to_pop = 1;
   PopStackFrames(to_pop);
+#if defined(__GNUC__) && defined(__sparc__)
+  // __builtin_return_address returns the address of the call instruction
+  // on the SPARC and not the return address, so we need to compensate.
+  trace_buffer[0] = GetNextInstructionPc(pc);
+#else
   trace_buffer[0] = pc;
+#endif
 }
 
 void BufferedStackTrace::UnwindSlow(uptr pc, void *context, u32 max_depth) {
   CHECK(context);
   CHECK_GE(max_depth, 2);
   if (!unwind_backtrace_signal_arch) {
     UnwindSlow(pc, max_depth);
     return;