4 * Copyright (C) 2009 Eric Pouech
5 * Copyright (C) 2010, 2011 André Hentschel
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.
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.
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
22 #include "dbghelp_private.h"
24 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp
);
26 static BOOL
arm_get_addr(HANDLE hThread
, const CONTEXT
* ctx
,
27 enum cpu_addr ca
, ADDRESS64
* addr
)
29 addr
->Mode
= AddrModeFlat
;
30 addr
->Segment
= 0; /* don't need segment */
34 case cpu_addr_pc
: addr
->Offset
= ctx
->Pc
; return TRUE
;
35 case cpu_addr_stack
: addr
->Offset
= ctx
->Sp
; return TRUE
;
37 case cpu_addr_frame
: addr
->Offset
= ctx
->R11
; return TRUE
;
39 case cpu_addr_frame
: addr
->Offset
= ctx
->Fp
; return TRUE
;
42 default: addr
->Mode
= -1;
48 enum st_mode
{stm_start
, stm_arm
, stm_done
};
50 /* indexes in Reserved array */
51 #define __CurrentModeCount 0
53 #define curr_mode (frame->Reserved[__CurrentModeCount] & 0x0F)
54 #define curr_count (frame->Reserved[__CurrentModeCount] >> 4)
56 #define set_curr_mode(m) {frame->Reserved[__CurrentModeCount] &= ~0x0F; frame->Reserved[__CurrentModeCount] |= (m & 0x0F);}
57 #define inc_curr_count() (frame->Reserved[__CurrentModeCount] += 0x10)
61 * modify (at least) context.Pc using unwind information
62 * either out of debug info (dwarf), or simple Lr trace
64 static BOOL
fetch_next_frame(struct cpu_stack_walk
* csw
,
65 CONTEXT
* context
, DWORD_PTR curr_pc
)
68 DWORD oldReturn
= context
->Lr
;
70 if (dwarf2_virtual_unwind(csw
, curr_pc
, context
, &xframe
))
73 context
->Pc
= oldReturn
;
77 if (context
->Pc
== context
->Lr
) return FALSE
;
78 context
->Pc
= oldReturn
;
83 static BOOL
arm_stack_walk(struct cpu_stack_walk
* csw
, LPSTACKFRAME64 frame
, CONTEXT
* context
)
85 unsigned deltapc
= curr_count
<= 1 ? 0 : 4;
88 if (curr_mode
>= stm_done
) return FALSE
;
90 TRACE("Enter: PC=%s Frame=%s Return=%s Stack=%s Mode=%s Count=%s\n",
91 wine_dbgstr_addr(&frame
->AddrPC
),
92 wine_dbgstr_addr(&frame
->AddrFrame
),
93 wine_dbgstr_addr(&frame
->AddrReturn
),
94 wine_dbgstr_addr(&frame
->AddrStack
),
95 curr_mode
== stm_start
? "start" : "ARM",
96 wine_dbgstr_longlong(curr_count
));
98 if (curr_mode
== stm_start
)
101 set_curr_mode(stm_arm
);
102 frame
->AddrReturn
.Mode
= frame
->AddrStack
.Mode
= AddrModeFlat
;
103 /* don't set up AddrStack on first call. Either the caller has set it up, or
104 * we will get it in the next frame
106 memset(&frame
->AddrBStore
, 0, sizeof(frame
->AddrBStore
));
110 if (context
->Sp
!= frame
->AddrStack
.Offset
) FIXME("inconsistent Stack Pointer\n");
111 if (context
->Pc
!= frame
->AddrPC
.Offset
) FIXME("inconsistent Program Counter\n");
113 if (frame
->AddrReturn
.Offset
== 0) goto done_err
;
114 if (!fetch_next_frame(csw
, context
, frame
->AddrPC
.Offset
- deltapc
))
118 memset(&frame
->Params
, 0, sizeof(frame
->Params
));
120 /* set frame information */
121 frame
->AddrStack
.Offset
= context
->Sp
;
122 frame
->AddrReturn
.Offset
= context
->Lr
;
124 frame
->AddrFrame
.Offset
= context
->R11
;
126 frame
->AddrFrame
.Offset
= context
->Fp
;
128 frame
->AddrPC
.Offset
= context
->Pc
;
131 frame
->Virtual
= TRUE
;
134 TRACE("Leave: PC=%s Frame=%s Return=%s Stack=%s Mode=%s Count=%s FuncTable=%p\n",
135 wine_dbgstr_addr(&frame
->AddrPC
),
136 wine_dbgstr_addr(&frame
->AddrFrame
),
137 wine_dbgstr_addr(&frame
->AddrReturn
),
138 wine_dbgstr_addr(&frame
->AddrStack
),
139 curr_mode
== stm_start
? "start" : "ARM",
140 wine_dbgstr_longlong(curr_count
),
141 frame
->FuncTableEntry
);
145 set_curr_mode(stm_done
);
149 static BOOL
arm_stack_walk(struct cpu_stack_walk
* csw
, LPSTACKFRAME64 frame
, CONTEXT
* context
)
155 static unsigned arm_map_dwarf_register(unsigned regno
, BOOL eh_frame
)
157 if (regno
<= 15) return CV_ARM_R0
+ regno
;
158 if (regno
== 128) return CV_ARM_CPSR
;
160 FIXME("Don't know how to map register %d\n", regno
);
164 static void* arm_fetch_context_reg(CONTEXT
* ctx
, unsigned regno
, unsigned* size
)
169 case CV_ARM_R0
+ 0: *size
= sizeof(ctx
->R0
); return &ctx
->R0
;
170 case CV_ARM_R0
+ 1: *size
= sizeof(ctx
->R1
); return &ctx
->R1
;
171 case CV_ARM_R0
+ 2: *size
= sizeof(ctx
->R2
); return &ctx
->R2
;
172 case CV_ARM_R0
+ 3: *size
= sizeof(ctx
->R3
); return &ctx
->R3
;
173 case CV_ARM_R0
+ 4: *size
= sizeof(ctx
->R4
); return &ctx
->R4
;
174 case CV_ARM_R0
+ 5: *size
= sizeof(ctx
->R5
); return &ctx
->R5
;
175 case CV_ARM_R0
+ 6: *size
= sizeof(ctx
->R6
); return &ctx
->R6
;
176 case CV_ARM_R0
+ 7: *size
= sizeof(ctx
->R7
); return &ctx
->R7
;
177 case CV_ARM_R0
+ 8: *size
= sizeof(ctx
->R8
); return &ctx
->R8
;
178 case CV_ARM_R0
+ 9: *size
= sizeof(ctx
->R9
); return &ctx
->R9
;
179 case CV_ARM_R0
+ 10: *size
= sizeof(ctx
->R10
); return &ctx
->R10
;
181 case CV_ARM_R0
+ 11: *size
= sizeof(ctx
->R11
); return &ctx
->R11
;
182 case CV_ARM_R0
+ 12: *size
= sizeof(ctx
->R12
); return &ctx
->R12
;
184 case CV_ARM_R0
+ 11: *size
= sizeof(ctx
->Fp
); return &ctx
->Fp
;
185 case CV_ARM_R0
+ 12: *size
= sizeof(ctx
->Ip
); return &ctx
->Ip
;
188 case CV_ARM_SP
: *size
= sizeof(ctx
->Sp
); return &ctx
->Sp
;
189 case CV_ARM_LR
: *size
= sizeof(ctx
->Lr
); return &ctx
->Lr
;
190 case CV_ARM_PC
: *size
= sizeof(ctx
->Pc
); return &ctx
->Pc
;
191 case CV_ARM_CPSR
: *size
= sizeof(ctx
->Cpsr
); return &ctx
->Cpsr
;
194 FIXME("Unknown register %x\n", regno
);
198 static const char* arm_fetch_regname(unsigned regno
)
202 case CV_ARM_R0
+ 0: return "r0";
203 case CV_ARM_R0
+ 1: return "r1";
204 case CV_ARM_R0
+ 2: return "r2";
205 case CV_ARM_R0
+ 3: return "r3";
206 case CV_ARM_R0
+ 4: return "r4";
207 case CV_ARM_R0
+ 5: return "r5";
208 case CV_ARM_R0
+ 6: return "r6";
209 case CV_ARM_R0
+ 7: return "r7";
210 case CV_ARM_R0
+ 8: return "r8";
211 case CV_ARM_R0
+ 9: return "r9";
212 case CV_ARM_R0
+ 10: return "r10";
213 case CV_ARM_R0
+ 11: return "r11";
214 case CV_ARM_R0
+ 12: return "r12";
216 case CV_ARM_SP
: return "sp";
217 case CV_ARM_LR
: return "lr";
218 case CV_ARM_PC
: return "pc";
219 case CV_ARM_CPSR
: return "cpsr";
221 FIXME("Unknown register %x\n", regno
);
225 static BOOL
arm_fetch_minidump_thread(struct dump_context
* dc
, unsigned index
, unsigned flags
, const CONTEXT
* ctx
)
227 if (ctx
->ContextFlags
&& (flags
& ThreadWriteInstructionWindow
))
229 /* FIXME: crop values across module boundaries, */
231 ULONG base
= ctx
->Pc
<= 0x80 ? 0 : ctx
->Pc
- 0x80;
232 minidump_add_memory_block(dc
, base
, ctx
->Pc
+ 0x80 - base
, 0);
239 static BOOL
arm_fetch_minidump_module(struct dump_context
* dc
, unsigned index
, unsigned flags
)
241 /* FIXME: actually, we should probably take care of FPO data, unless it's stored in
242 * function table minidump stream
247 DECLSPEC_HIDDEN
struct cpu cpu_arm
= {
248 IMAGE_FILE_MACHINE_ARMNT
,
254 arm_map_dwarf_register
,
255 arm_fetch_context_reg
,
257 arm_fetch_minidump_thread
,
258 arm_fetch_minidump_module
,