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