[Sanitizer][RISCV] Fix FastUnwindTest

[luismarques]

Summary

Fixes the FastUnwindTest unit test for RISC-V.
These changes reflect the different stack organization commonly used for that architecture.

[vitalybuka]

Please clang-format the patch

compiler-rt/lib/sanitizer_common/tests/sanitizer_stacktrace_test.cpp

19–72

131–136

[luismarques]

Address review feedback.

compiler-rt/lib/sanitizer_common/tests/sanitizer_stacktrace_test.cpp

 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_stacktrace.h"
 #include "gtest/gtest.h"
 
 namespace __sanitizer {
 
 class FastUnwindTest : public ::testing::Test {
  protected:
   virtual void SetUp();
   virtual void TearDown();
 
   void UnwindFast();
 
   void *mapping;
   uhwptr *fake_stack;
   const uptr fake_stack_size = 10;
   uhwptr start_pc;
 
   uhwptr fake_bp;
   uhwptr fake_top;
   uhwptr fake_bottom;
   BufferedStackTrace trace;
+
+#if defined(__riscv)
+  const uptr kFpOffset = 4;
+  const uptr kBpOffset = 2;
+#else
+  const uptr kFpOffset = 2;
+  const uptr kBpOffset = 0;
+#endif
 };
 
 static uptr PC(uptr idx) {
   return (1<<20) + idx;
 }
 
 void FastUnwindTest::SetUp() {
   size_t ps = GetPageSize();
   mapping = MmapOrDie(2 * ps, "FastUnwindTest");
   MprotectNoAccess((uptr)mapping, ps);
 
   // Unwinder may peek 1 word down from the starting FP.
   fake_stack = (uhwptr *)((uptr)mapping + ps + sizeof(uhwptr));
 
   // Fill an array of pointers with fake fp+retaddr pairs.  Frame pointers have
   // even indices.
   for (uptr i = 0; i + 1 < fake_stack_size; i += 2) {
-    fake_stack[i] = (uptr)&fake_stack[i+2];  // fp
+    fake_stack[i] = (uptr)&fake_stack[i + kFpOffset];  // fp
     fake_stack[i+1] = PC(i + 1); // retaddr
   }
   // Mark the last fp point back up to terminate the stack trace.
   fake_stack[RoundDownTo(fake_stack_size - 1, 2)] = (uhwptr)&fake_stack[0];
 
   // Top is two slots past the end because UnwindFast subtracts two.
-  fake_top = (uhwptr)&fake_stack[fake_stack_size + 2];
+  fake_top = (uhwptr)&fake_stack[fake_stack_size + kFpOffset];
   // Bottom is one slot before the start because UnwindFast uses >.
   fake_bottom = (uhwptr)mapping;
-  fake_bp = (uptr)&fake_stack[0];
+  fake_bp = (uptr)&fake_stack[kBpOffset];
   start_pc = PC(0);
 }


 
 void FastUnwindTest::TearDown() {
   size_t ps = GetPageSize();
   UnmapOrDie(mapping, 2 * ps);
 }
 
 #if SANITIZER_CAN_FAST_UNWIND
 
for (uptr i = 1; i < 4U; i++) {
     EXPECT_EQ(PC(i*2 - 1), trace.trace[i]);
   }
 }
 
 TEST_F(FastUnwindTest, OneFrameStackTrace) {
   trace.Unwind(start_pc, fake_bp, nullptr, true, 1);
   EXPECT_EQ(1U, trace.size);
   EXPECT_EQ(start_pc, trace.trace[0]);
-  EXPECT_EQ((uhwptr)&fake_stack[0], trace.top_frame_bp);
+  EXPECT_EQ((uhwptr)&fake_stack[kBpOffset], trace.top_frame_bp);
 }
 
 TEST_F(FastUnwindTest, ZeroFramesStackTrace) {
   trace.Unwind(start_pc, fake_bp, nullptr, true, 0);
   EXPECT_EQ(0U, trace.size);
   EXPECT_EQ(0U, trace.top_frame_bp);
 }
 
 TEST_F(FastUnwindTest, SKIP_ON_SPARC(FPBelowPrevFP)) {
   // The next FP points to unreadable memory inside the stack limits, but below
   // current FP.
   fake_stack[0] = (uhwptr)&fake_stack[-50];
   fake_stack[1] = PC(1);