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
26namespace __sanitizer {
27
28void 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#if defined(__GNUC__)
34  // __builtin_return_address returns the address of the call instruction
35  // on the SPARC and not the return address, so we need to compensate.
36  trace_buffer[0] = GetNextInstructionPc(pc);
37#else
38  trace_buffer[0] = pc;
39#endif
40  size = 1;
41  if (stack_top < 4096) return;  // Sanity check for stack top.
42  // Flush register windows to memory
43#if defined(__sparc_v9__) || defined(__sparcv9__) || defined(__sparcv9)
44  asm volatile("flushw" ::: "memory");
45#else
46  asm volatile("ta 3" ::: "memory");
47#endif
48  // On the SPARC, the return address is not in the frame, it is in a
49  // register.  There is no way to access it off of the current frame
50  // pointer, but it can be accessed off the previous frame pointer by
51  // reading the value from the register window save area.
52  uptr prev_bp = GET_CURRENT_FRAME();
53  uptr next_bp = prev_bp;
54  unsigned int i = 0;
55  while (next_bp != bp && IsAligned(next_bp, sizeof(uhwptr)) && 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) && IsAligned(bp, sizeof(uhwptr)) &&
66         size < max_depth) {
67    uhwptr pc1 = ((uhwptr *)bp)[15];
68    // Let's assume that any pointer in the 0th page is invalid and
69    // stop unwinding here.  If we're adding support for a platform
70    // where this isn't true, we need to reconsider this check.
71    if (pc1 < kPageSize)
72      break;
73    if (pc1 != pc) {
74      // %o7 contains the address of the call instruction and not the
75      // return address, so we need to compensate.
76      trace_buffer[size++] = GetNextInstructionPc((uptr)pc1);
77    }
78    bottom = bp;
79    bp = (uptr)((uhwptr *)bp)[14] + STACK_BIAS;
80  }
81}
82
83}  // namespace __sanitizer
84
85#endif  // !defined(__sparc__)
86