1 /*
2 * File cpu_arm.c
3 *
4 * Copyright (C) 2009 Eric Pouech
5 * Copyright (C) 2010, 2011 André Hentschel
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include <assert.h>
23
24 #include "ntstatus.h"
25 #define WIN32_NO_STATUS
26 #include "dbghelp_private.h"
27 #include "winternl.h"
28 #include "wine/debug.h"
29
30 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp);
31
arm_get_addr(HANDLE hThread,const CONTEXT * ctx,enum cpu_addr ca,ADDRESS64 * addr)32 static BOOL arm_get_addr(HANDLE hThread, const CONTEXT* ctx,
33 enum cpu_addr ca, ADDRESS64* addr)
34 {
35 addr->Mode = AddrModeFlat;
36 addr->Segment = 0; /* don't need segment */
37 switch (ca)
38 {
39 #ifdef __arm__
40 case cpu_addr_pc: addr->Offset = ctx->Pc; return TRUE;
41 case cpu_addr_stack: addr->Offset = ctx->Sp; return TRUE;
42 #ifdef __REACTOS__
43 case cpu_addr_frame: addr->Offset = ctx->R11; return TRUE;
44 #else
45 case cpu_addr_frame: addr->Offset = ctx->Fp; return TRUE;
46 #endif
47 #endif
48 default: addr->Mode = -1;
49 return FALSE;
50 }
51 }
52
53 #ifdef __arm__
54 enum st_mode {stm_start, stm_arm, stm_done};
55
56 /* indexes in Reserved array */
57 #define __CurrentModeCount 0
58
59 #define curr_mode (frame->Reserved[__CurrentModeCount] & 0x0F)
60 #define curr_count (frame->Reserved[__CurrentModeCount] >> 4)
61
62 #define set_curr_mode(m) {frame->Reserved[__CurrentModeCount] &= ~0x0F; frame->Reserved[__CurrentModeCount] |= (m & 0x0F);}
63 #define inc_curr_count() (frame->Reserved[__CurrentModeCount] += 0x10)
64
65 /* fetch_next_frame()
66 *
67 * modify (at least) context.Pc using unwind information
68 * either out of debug info (dwarf), or simple Lr trace
69 */
fetch_next_frame(struct cpu_stack_walk * csw,union ctx * pcontext,DWORD_PTR curr_pc)70 static BOOL fetch_next_frame(struct cpu_stack_walk* csw, union ctx *pcontext,
71 DWORD_PTR curr_pc)
72 {
73 DWORD64 xframe;
74 CONTEXT *context = &pcontext->ctx;
75 DWORD oldReturn = context->Lr;
76
77 if (dwarf2_virtual_unwind(csw, curr_pc, pcontext, &xframe))
78 {
79 context->Sp = xframe;
80 context->Pc = oldReturn;
81 return TRUE;
82 }
83
84 if (context->Pc == context->Lr) return FALSE;
85 context->Pc = oldReturn;
86
87 return TRUE;
88 }
89
arm_stack_walk(struct cpu_stack_walk * csw,STACKFRAME64 * frame,union ctx * context)90 static BOOL arm_stack_walk(struct cpu_stack_walk *csw, STACKFRAME64 *frame,
91 union ctx *context)
92 {
93 unsigned deltapc = curr_count <= 1 ? 0 : 4;
94
95 /* sanity check */
96 if (curr_mode >= stm_done) return FALSE;
97
98 TRACE("Enter: PC=%s Frame=%s Return=%s Stack=%s Mode=%s Count=%s\n",
99 wine_dbgstr_addr(&frame->AddrPC),
100 wine_dbgstr_addr(&frame->AddrFrame),
101 wine_dbgstr_addr(&frame->AddrReturn),
102 wine_dbgstr_addr(&frame->AddrStack),
103 curr_mode == stm_start ? "start" : "ARM",
104 wine_dbgstr_longlong(curr_count));
105
106 if (curr_mode == stm_start)
107 {
108 /* Init done */
109 set_curr_mode(stm_arm);
110 frame->AddrReturn.Mode = frame->AddrStack.Mode = AddrModeFlat;
111 /* don't set up AddrStack on first call. Either the caller has set it up, or
112 * we will get it in the next frame
113 */
114 memset(&frame->AddrBStore, 0, sizeof(frame->AddrBStore));
115 }
116 else
117 {
118 if (context->ctx.Sp != frame->AddrStack.Offset) FIXME("inconsistent Stack Pointer\n");
119 if (context->ctx.Pc != frame->AddrPC.Offset) FIXME("inconsistent Program Counter\n");
120
121 if (frame->AddrReturn.Offset == 0) goto done_err;
122 if (!fetch_next_frame(csw, context, frame->AddrPC.Offset - deltapc))
123 goto done_err;
124 }
125
126 memset(&frame->Params, 0, sizeof(frame->Params));
127
128 /* set frame information */
129 frame->AddrStack.Offset = context->ctx.Sp;
130 frame->AddrReturn.Offset = context->ctx.Lr;
131 #ifdef __REACTOS__
132 frame->AddrFrame.Offset = context->ctx.R11;
133 #else
134 frame->AddrFrame.Offset = context->ctx.Fp;
135 #endif
136 frame->AddrPC.Offset = context->ctx.Pc;
137
138 frame->Far = TRUE;
139 frame->Virtual = TRUE;
140 inc_curr_count();
141
142 TRACE("Leave: PC=%s Frame=%s Return=%s Stack=%s Mode=%s Count=%s FuncTable=%p\n",
143 wine_dbgstr_addr(&frame->AddrPC),
144 wine_dbgstr_addr(&frame->AddrFrame),
145 wine_dbgstr_addr(&frame->AddrReturn),
146 wine_dbgstr_addr(&frame->AddrStack),
147 curr_mode == stm_start ? "start" : "ARM",
148 wine_dbgstr_longlong(curr_count),
149 frame->FuncTableEntry);
150
151 return TRUE;
152 done_err:
153 set_curr_mode(stm_done);
154 return FALSE;
155 }
156 #else
arm_stack_walk(struct cpu_stack_walk * csw,STACKFRAME64 * frame,union ctx * context)157 static BOOL arm_stack_walk(struct cpu_stack_walk *csw, STACKFRAME64 *frame,
158 union ctx *context)
159 {
160 return FALSE;
161 }
162 #endif
163
arm_map_dwarf_register(unsigned regno,const struct module * module,BOOL eh_frame)164 static unsigned arm_map_dwarf_register(unsigned regno, const struct module* module, BOOL eh_frame)
165 {
166 if (regno <= 15) return CV_ARM_R0 + regno;
167 if (regno == 128) return CV_ARM_CPSR;
168
169 FIXME("Don't know how to map register %d\n", regno);
170 return CV_ARM_NOREG;
171 }
172
arm_fetch_context_reg(union ctx * pctx,unsigned regno,unsigned * size)173 static void *arm_fetch_context_reg(union ctx *pctx, unsigned regno, unsigned *size)
174 {
175 #ifdef __arm__
176 CONTEXT *ctx = &pctx->ctx;
177
178 switch (regno)
179 {
180 case CV_ARM_R0 + 0: *size = sizeof(ctx->R0); return &ctx->R0;
181 case CV_ARM_R0 + 1: *size = sizeof(ctx->R1); return &ctx->R1;
182 case CV_ARM_R0 + 2: *size = sizeof(ctx->R2); return &ctx->R2;
183 case CV_ARM_R0 + 3: *size = sizeof(ctx->R3); return &ctx->R3;
184 case CV_ARM_R0 + 4: *size = sizeof(ctx->R4); return &ctx->R4;
185 case CV_ARM_R0 + 5: *size = sizeof(ctx->R5); return &ctx->R5;
186 case CV_ARM_R0 + 6: *size = sizeof(ctx->R6); return &ctx->R6;
187 case CV_ARM_R0 + 7: *size = sizeof(ctx->R7); return &ctx->R7;
188 case CV_ARM_R0 + 8: *size = sizeof(ctx->R8); return &ctx->R8;
189 case CV_ARM_R0 + 9: *size = sizeof(ctx->R9); return &ctx->R9;
190 case CV_ARM_R0 + 10: *size = sizeof(ctx->R10); return &ctx->R10;
191 #ifdef __REACTOS__
192 case CV_ARM_R0 + 11: *size = sizeof(ctx->R11); return &ctx->R11;
193 case CV_ARM_R0 + 12: *size = sizeof(ctx->R12); return &ctx->R12;
194 #else
195 case CV_ARM_R0 + 11: *size = sizeof(ctx->Fp); return &ctx->Fp;
196 case CV_ARM_R0 + 12: *size = sizeof(ctx->Ip); return &ctx->Ip;
197 #endif
198
199 case CV_ARM_SP: *size = sizeof(ctx->Sp); return &ctx->Sp;
200 case CV_ARM_LR: *size = sizeof(ctx->Lr); return &ctx->Lr;
201 case CV_ARM_PC: *size = sizeof(ctx->Pc); return &ctx->Pc;
202 case CV_ARM_CPSR: *size = sizeof(ctx->Cpsr); return &ctx->Cpsr;
203 }
204 #endif
205 FIXME("Unknown register %x\n", regno);
206 return NULL;
207 }
208
arm_fetch_regname(unsigned regno)209 static const char* arm_fetch_regname(unsigned regno)
210 {
211 switch (regno)
212 {
213 case CV_ARM_R0 + 0: return "r0";
214 case CV_ARM_R0 + 1: return "r1";
215 case CV_ARM_R0 + 2: return "r2";
216 case CV_ARM_R0 + 3: return "r3";
217 case CV_ARM_R0 + 4: return "r4";
218 case CV_ARM_R0 + 5: return "r5";
219 case CV_ARM_R0 + 6: return "r6";
220 case CV_ARM_R0 + 7: return "r7";
221 case CV_ARM_R0 + 8: return "r8";
222 case CV_ARM_R0 + 9: return "r9";
223 case CV_ARM_R0 + 10: return "r10";
224 case CV_ARM_R0 + 11: return "r11";
225 case CV_ARM_R0 + 12: return "r12";
226
227 case CV_ARM_SP: return "sp";
228 case CV_ARM_LR: return "lr";
229 case CV_ARM_PC: return "pc";
230 case CV_ARM_CPSR: return "cpsr";
231 }
232 FIXME("Unknown register %x\n", regno);
233 return NULL;
234 }
235
arm_fetch_minidump_thread(struct dump_context * dc,unsigned index,unsigned flags,const CONTEXT * ctx)236 static BOOL arm_fetch_minidump_thread(struct dump_context* dc, unsigned index, unsigned flags, const CONTEXT* ctx)
237 {
238 if (ctx->ContextFlags && (flags & ThreadWriteInstructionWindow))
239 {
240 /* FIXME: crop values across module boundaries, */
241 #ifdef __arm__
242 ULONG base = ctx->Pc <= 0x80 ? 0 : ctx->Pc - 0x80;
243 minidump_add_memory_block(dc, base, ctx->Pc + 0x80 - base, 0);
244 #endif
245 }
246
247 return TRUE;
248 }
249
arm_fetch_minidump_module(struct dump_context * dc,unsigned index,unsigned flags)250 static BOOL arm_fetch_minidump_module(struct dump_context* dc, unsigned index, unsigned flags)
251 {
252 /* FIXME: actually, we should probably take care of FPO data, unless it's stored in
253 * function table minidump stream
254 */
255 return FALSE;
256 }
257
258 DECLSPEC_HIDDEN struct cpu cpu_arm = {
259 IMAGE_FILE_MACHINE_ARMNT,
260 4,
261 CV_ARM_R0 + 11,
262 arm_get_addr,
263 arm_stack_walk,
264 NULL,
265 arm_map_dwarf_register,
266 arm_fetch_context_reg,
267 arm_fetch_regname,
268 arm_fetch_minidump_thread,
269 arm_fetch_minidump_module,
270 };
271