Home | History | Annotate | Line # | Download | only in sanitizer_common 
      1 //===-- sanitizer_stacktrace_sparc.cpp ------------------------------------===//
      2 //
      3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
      4 // See https://llvm.org/LICENSE.txt for license information.
      5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
      6 //
      7 //===----------------------------------------------------------------------===//
      8 //
      9 // This file is shared between AddressSanitizer and ThreadSanitizer
     10 // run-time libraries.
     11 //
     12 // Implementation of fast stack unwinding for Sparc.
     13 //===----------------------------------------------------------------------===//
     14 
     15 #if defined(__sparc__)
     16 
     17 #if defined(__arch64__) || defined(__sparcv9)
     18 #define STACK_BIAS 2047
     19 #else
     20 #define STACK_BIAS 0
     21 #endif
     22 
     23 #include "sanitizer_common.h"
     24 #include "sanitizer_stacktrace.h"
     25 
     26 namespace __sanitizer {
     27 
     28 void BufferedStackTrace::UnwindFast(uptr pc, uptr bp, uptr stack_top,
     29                                     uptr stack_bottom, u32 max_depth) {
     30   // TODO(yln): add arg sanity check for stack_top/stack_bottom
     31   CHECK_GE(max_depth, 2);
     32   const uptr kPageSize = GetPageSizeCached();
     33   trace_buffer[0] = pc;
     34   size = 1;
     35   if (stack_top < 4096) return;  // Sanity check for stack top.
     36   // Flush register windows to memory
     37 #if defined(__sparc_v9__) || defined(__sparcv9__) || defined(__sparcv9)
     38   asm volatile("flushw" ::: "memory");
     39 #else
     40   asm volatile("ta 3" ::: "memory");
     41 #endif
     42   // On the SPARC, the return address is not in the frame, it is in a
     43   // register.  There is no way to access it off of the current frame
     44   // pointer, but it can be accessed off the previous frame pointer by
     45   // reading the value from the register window save area.
     46   uptr prev_bp = GET_CURRENT_FRAME();
     47   uptr next_bp = prev_bp;
     48   unsigned int i = 0;
     49   while (next_bp != bp && IsAligned(next_bp, sizeof(uhwptr)) && i++ < 8) {
     50     prev_bp = next_bp;
     51     next_bp = (uptr)((uhwptr *)next_bp)[14] + STACK_BIAS;
     52   }
     53   if (next_bp == bp)
     54     bp = prev_bp;
     55   // Lowest possible address that makes sense as the next frame pointer.
     56   // Goes up as we walk the stack.
     57   uptr bottom = stack_bottom;
     58   // Avoid infinite loop when frame == frame[0] by using frame > prev_frame.
     59   while (IsValidFrame(bp, stack_top, bottom) && IsAligned(bp, sizeof(uhwptr)) &&
     60          size < max_depth) {
     61     uhwptr pc1 = ((uhwptr *)bp)[15];
     62     // Let's assume that any pointer in the 0th page is invalid and
     63     // stop unwinding here.  If we're adding support for a platform
     64     // where this isn't true, we need to reconsider this check.
     65     if (pc1 < kPageSize)
     66       break;
     67     if (pc1 != pc) {
     68       // %o7 contains the address of the call instruction and not the
     69       // return address, so we need to compensate.
     70       trace_buffer[size++] = GetNextInstructionPc((uptr)pc1);
     71     }
     72     bottom = bp;
     73     bp = (uptr)((uhwptr *)bp)[14] + STACK_BIAS;
     74   }
     75 }
     76 
     77 }  // namespace __sanitizer
     78 
     79 #endif  // !defined(__sparc__)
     80