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 // Implemention 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
UnwindFast(uptr pc,uptr bp,uptr stack_top,uptr stack_bottom,u32 max_depth)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 #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