]>
git.ipfire.org Git - thirdparty/gcc.git/blob - libsanitizer/sanitizer_common/sanitizer_stacktrace.cpp
1 //===-- sanitizer_stacktrace.cpp ------------------------------------------===//
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
7 //===----------------------------------------------------------------------===//
9 // This file is shared between AddressSanitizer and ThreadSanitizer
10 // run-time libraries.
11 //===----------------------------------------------------------------------===//
13 #include "sanitizer_stacktrace.h"
15 #include "sanitizer_common.h"
16 #include "sanitizer_flags.h"
17 #include "sanitizer_platform.h"
18 #include "sanitizer_ptrauth.h"
20 namespace __sanitizer
{
22 uptr
StackTrace::GetNextInstructionPc(uptr pc
) {
23 #if defined(__sparc__) || defined(__mips__)
25 #elif defined(__powerpc__) || defined(__arm__) || defined(__aarch64__)
27 #elif SANITIZER_RISCV64
28 // Current check order is 4 -> 2 -> 6 -> 8
29 u8 InsnByte
= *(u8
*)(pc
);
30 if (((InsnByte
& 0x3) == 0x3) && ((InsnByte
& 0x1c) != 0x1c)) {
31 // xxxxxxxxxxxbbb11 | 32 bit | bbb != 111
34 if ((InsnByte
& 0x3) != 0x3) {
35 // xxxxxxxxxxxxxxaa | 16 bit | aa != 11
38 // RISC-V encoding allows instructions to be up to 8 bytes long
39 if ((InsnByte
& 0x3f) == 0x1f) {
40 // xxxxxxxxxx011111 | 48 bit |
43 if ((InsnByte
& 0x7f) == 0x3f) {
44 // xxxxxxxxx0111111 | 64 bit |
47 // bail-out if could not figure out the instruction size
54 uptr
StackTrace::GetCurrentPc() {
55 return GET_CALLER_PC();
58 void BufferedStackTrace::Init(const uptr
*pcs
, uptr cnt
, uptr extra_top_pc
) {
59 size
= cnt
+ !!extra_top_pc
;
60 CHECK_LE(size
, kStackTraceMax
);
61 internal_memcpy(trace_buffer
, pcs
, cnt
* sizeof(trace_buffer
[0]));
63 trace_buffer
[cnt
] = extra_top_pc
;
67 // Sparc implemention is in its own file.
68 #if !defined(__sparc__)
70 // In GCC on ARM bp points to saved lr, not fp, so we should check the next
71 // cell in stack to be a saved frame pointer. GetCanonicFrame returns the
72 // pointer to saved frame pointer in any case.
73 static inline uhwptr
*GetCanonicFrame(uptr bp
,
76 CHECK_GT(stack_top
, stack_bottom
);
78 if (!IsValidFrame(bp
, stack_top
, stack_bottom
)) return 0;
79 uhwptr
*bp_prev
= (uhwptr
*)bp
;
80 if (IsValidFrame((uptr
)bp_prev
[0], stack_top
, stack_bottom
)) return bp_prev
;
81 // The next frame pointer does not look right. This could be a GCC frame, step
82 // back by 1 word and try again.
83 if (IsValidFrame((uptr
)bp_prev
[-1], stack_top
, stack_bottom
))
85 // Nope, this does not look right either. This means the frame after next does
86 // not have a valid frame pointer, but we can still extract the caller PC.
87 // Unfortunately, there is no way to decide between GCC and LLVM frame
88 // layouts. Assume GCC.
95 void BufferedStackTrace::UnwindFast(uptr pc
, uptr bp
, uptr stack_top
,
96 uptr stack_bottom
, u32 max_depth
) {
97 // TODO(yln): add arg sanity check for stack_top/stack_bottom
98 CHECK_GE(max_depth
, 2);
99 const uptr kPageSize
= GetPageSizeCached();
100 trace_buffer
[0] = pc
;
102 if (stack_top
< 4096) return; // Sanity check for stack top.
103 uhwptr
*frame
= GetCanonicFrame(bp
, stack_top
, stack_bottom
);
104 // Lowest possible address that makes sense as the next frame pointer.
105 // Goes up as we walk the stack.
106 uptr bottom
= stack_bottom
;
107 // Avoid infinite loop when frame == frame[0] by using frame > prev_frame.
108 while (IsValidFrame((uptr
)frame
, stack_top
, bottom
) &&
109 IsAligned((uptr
)frame
, sizeof(*frame
)) &&
112 // PowerPC ABIs specify that the return address is saved on the
113 // *caller's* stack frame. Thus we must dereference the back chain
114 // to find the caller frame before extracting it.
115 uhwptr
*caller_frame
= (uhwptr
*)frame
[0];
116 if (!IsValidFrame((uptr
)caller_frame
, stack_top
, bottom
) ||
117 !IsAligned((uptr
)caller_frame
, sizeof(uhwptr
)))
119 // For most ABIs the offset where the return address is saved is two
120 // register sizes. The exception is the SVR4 ABI, which uses an
121 // offset of only one register size.
123 uhwptr pc1
= caller_frame
[1];
125 uhwptr pc1
= caller_frame
[2];
127 #elif defined(__s390__)
128 uhwptr pc1
= frame
[14];
129 #elif defined(__riscv)
130 // frame[-1] contains the return address
131 uhwptr pc1
= frame
[-1];
133 uhwptr pc1
= STRIP_PAC_PC((void *)frame
[1]);
135 // Let's assume that any pointer in the 0th page (i.e. <0x1000 on i386 and
136 // x86_64) is invalid and stop unwinding here. If we're adding support for
137 // a platform where this isn't true, we need to reconsider this check.
141 trace_buffer
[size
++] = (uptr
) pc1
;
143 bottom
= (uptr
)frame
;
145 // frame[-2] contain fp of the previous frame
146 uptr new_bp
= (uptr
)frame
[-2];
148 uptr new_bp
= (uptr
)frame
[0];
150 frame
= GetCanonicFrame(new_bp
, stack_top
, bottom
);
154 #endif // !defined(__sparc__)
156 void BufferedStackTrace::PopStackFrames(uptr count
) {
157 CHECK_LT(count
, size
);
159 for (uptr i
= 0; i
< size
; ++i
) {
160 trace_buffer
[i
] = trace_buffer
[i
+ count
];
164 static uptr
Distance(uptr a
, uptr b
) { return a
< b
? b
- a
: a
- b
; }
166 uptr
BufferedStackTrace::LocatePcInTrace(uptr pc
) {
168 for (uptr i
= 1; i
< size
; ++i
) {
169 if (Distance(trace
[i
], pc
) < Distance(trace
[best
], pc
)) best
= i
;
174 } // namespace __sanitizer