ARM: 8900/1: UNWINDER_FRAME_POINTER implementation for Clang
[muen/linux.git] / arch / arm / lib / backtrace-clang.S
1 /* SPDX-License-Identifier: GPL-2.0-only */
2 /*
3  *  linux/arch/arm/lib/backtrace-clang.S
4  *
5  *  Copyright (C) 2019 Nathan Huckleberry
6  *
7  */
8 #include <linux/kern_levels.h>
9 #include <linux/linkage.h>
10 #include <asm/assembler.h>
11                 .text
12
13 /* fp is 0 or stack frame */
14
15 #define frame   r4
16 #define sv_fp   r5
17 #define sv_pc   r6
18 #define mask    r7
19 #define sv_lr   r8
20
21 ENTRY(c_backtrace)
22
23 #if !defined(CONFIG_FRAME_POINTER) || !defined(CONFIG_PRINTK)
24                 ret     lr
25 ENDPROC(c_backtrace)
26 #else
27
28
29 /*
30  * Clang does not store pc or sp in function prologues so we don't know exactly
31  * where the function starts.
32  *
33  * We can treat the current frame's lr as the saved pc and the preceding
34  * frame's lr as the current frame's lr, but we can't trace the most recent
35  * call.  Inserting a false stack frame allows us to reference the function
36  * called last in the stacktrace.
37  *
38  * If the call instruction was a bl we can look at the callers branch
39  * instruction to calculate the saved pc.  We can recover the pc in most cases,
40  * but in cases such as calling function pointers we cannot. In this case,
41  * default to using the lr. This will be some address in the function, but will
42  * not be the function start.
43  *
44  * Unfortunately due to the stack frame layout we can't dump r0 - r3, but these
45  * are less frequently saved.
46  *
47  * Stack frame layout:
48  *              <larger addresses>
49  *              saved lr
50  *      frame=> saved fp
51  *              optionally saved caller registers (r4 - r10)
52  *              optionally saved arguments (r0 - r3)
53  *              <top of stack frame>
54  *              <smaller addresses>
55  *
56  * Functions start with the following code sequence:
57  * corrected pc =>  stmfd sp!, {..., fp, lr}
58  *              add fp, sp, #x
59  *              stmfd sp!, {r0 - r3} (optional)
60  *
61  *
62  *
63  *
64  *
65  *
66  * The diagram below shows an example stack setup for dump_stack.
67  *
68  * The frame for c_backtrace has pointers to the code of dump_stack. This is
69  * why the frame of c_backtrace is used to for the pc calculation of
70  * dump_stack. This is why we must move back a frame to print dump_stack.
71  *
72  * The stored locals for dump_stack are in dump_stack's frame. This means that
73  * to fully print dump_stack's frame we need both the frame for dump_stack (for
74  * locals) and the frame that was called by dump_stack (for pc).
75  *
76  * To print locals we must know where the function start is. If we read the
77  * function prologue opcodes we can determine which variables are stored in the
78  * stack frame.
79  *
80  * To find the function start of dump_stack we can look at the stored LR of
81  * show_stack. It points at the instruction directly after the bl dump_stack.
82  * We can then read the offset from the bl opcode to determine where the branch
83  * takes us.  The address calculated must be the start of dump_stack.
84  *
85  * c_backtrace frame           dump_stack:
86  * {[LR]    }  ============|   ...
87  * {[FP]    }  =======|    |   bl c_backtrace
88  *                    |    |=> ...
89  * {[R4-R10]}         |
90  * {[R0-R3] }         |        show_stack:
91  * dump_stack frame   |        ...
92  * {[LR]    } =============|   bl dump_stack
93  * {[FP]    } <=======|    |=> ...
94  * {[R4-R10]}
95  * {[R0-R3] }
96  */
97
98                 stmfd   sp!, {r4 - r9, fp, lr}  @ Save an extra register
99                                                 @ to ensure 8 byte alignment
100                 movs    frame, r0               @ if frame pointer is zero
101                 beq     no_frame                @ we have no stack frames
102                 tst     r1, #0x10               @ 26 or 32-bit mode?
103                 moveq   mask, #0xfc000003
104                 movne   mask, #0                @ mask for 32-bit
105
106 /*
107  * Switches the current frame to be the frame for dump_stack.
108  */
109                 add     frame, sp, #24          @ switch to false frame
110 for_each_frame: tst     frame, mask             @ Check for address exceptions
111                 bne     no_frame
112
113 /*
114  * sv_fp is the stack frame with the locals for the current considered
115  * function.
116  *
117  * sv_pc is the saved lr frame the frame above. This is a pointer to a code
118  * address within the current considered function, but it is not the function
119  * start. This value gets updated to be the function start later if it is
120  * possible.
121  */
122 1001:           ldr     sv_pc, [frame, #4]      @ get saved 'pc'
123 1002:           ldr     sv_fp, [frame, #0]      @ get saved fp
124
125                 teq     sv_fp, mask             @ make sure next frame exists
126                 beq     no_frame
127
128 /*
129  * sv_lr is the lr from the function that called the current function. This is
130  * a pointer to a code address in the current function's caller.  sv_lr-4 is
131  * the instruction used to call the current function.
132  *
133  * This sv_lr can be used to calculate the function start if the function was
134  * called using a bl instruction. If the function start can be recovered sv_pc
135  * is overwritten with the function start.
136  *
137  * If the current function was called using a function pointer we cannot
138  * recover the function start and instead continue with sv_pc as an arbitrary
139  * value within the current function. If this is the case we cannot print
140  * registers for the current function, but the stacktrace is still printed
141  * properly.
142  */
143 1003:           ldr     sv_lr, [sv_fp, #4]      @ get saved lr from next frame
144
145                 ldr     r0, [sv_lr, #-4]        @ get call instruction
146                 ldr     r3, .Lopcode+4
147                 and     r2, r3, r0              @ is this a bl call
148                 teq     r2, r3
149                 bne     finished_setup          @ give up if it's not
150                 and     r0, #0xffffff           @ get call offset 24-bit int
151                 lsl     r0, r0, #8              @ sign extend offset
152                 asr     r0, r0, #8
153                 ldr     sv_pc, [sv_fp, #4]      @ get lr address
154                 add     sv_pc, sv_pc, #-4       @ get call instruction address
155                 add     sv_pc, sv_pc, #8        @ take care of prefetch
156                 add     sv_pc, sv_pc, r0, lsl #2@ find function start
157
158 finished_setup:
159
160                 bic     sv_pc, sv_pc, mask      @ mask PC/LR for the mode
161
162 /*
163  * Print the function (sv_pc) and where it was called from (sv_lr).
164  */
165 1004:           mov     r0, sv_pc
166
167                 mov     r1, sv_lr
168                 mov     r2, frame
169                 bic     r1, r1, mask            @ mask PC/LR for the mode
170                 bl      dump_backtrace_entry
171
172 /*
173  * Test if the function start is a stmfd instruction to determine which
174  * registers were stored in the function prologue.
175  *
176  * If we could not recover the sv_pc because we were called through a function
177  * pointer the comparison will fail and no registers will print. Unwinding will
178  * continue as if there had been no registers stored in this frame.
179  */
180 1005:           ldr     r1, [sv_pc, #0]         @ if stmfd sp!, {..., fp, lr}
181                 ldr     r3, .Lopcode            @ instruction exists,
182                 teq     r3, r1, lsr #11
183                 ldr     r0, [frame]             @ locals are stored in
184                                                 @ the preceding frame
185                 subeq   r0, r0, #4
186                 bleq    dump_backtrace_stm      @ dump saved registers
187
188 /*
189  * If we are out of frames or if the next frame is invalid.
190  */
191                 teq     sv_fp, #0               @ zero saved fp means
192                 beq     no_frame                @ no further frames
193
194                 cmp     sv_fp, frame            @ next frame must be
195                 mov     frame, sv_fp            @ above the current frame
196                 bhi     for_each_frame
197
198 1006:           adr     r0, .Lbad
199                 mov     r1, frame
200                 bl      printk
201 no_frame:       ldmfd   sp!, {r4 - r9, fp, pc}
202 ENDPROC(c_backtrace)
203                 .pushsection __ex_table,"a"
204                 .align  3
205                 .long   1001b, 1006b
206                 .long   1002b, 1006b
207                 .long   1003b, 1006b
208                 .long   1004b, 1006b
209                 .long   1005b, 1006b
210                 .popsection
211
212 .Lbad:          .asciz  "Backtrace aborted due to bad frame pointer <%p>\n"
213                 .align
214 .Lopcode:       .word   0xe92d4800 >> 11        @ stmfd sp!, {... fp, lr}
215                 .word   0x0b000000              @ bl if these bits are set
216
217 #endif