1 /* Internal interfaces for the Windows code
2 Copyright (C) 1995-2020 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 #include "gdbsupport/common-defs.h"
20 #include "nat/windows-nat.h"
21 #include "gdbsupport/common-debug.h"
23 #define STATUS_WX86_BREAKPOINT 0x4000001F
24 #define STATUS_WX86_SINGLE_STEP 0x4000001E
29 HANDLE current_process_handle
;
30 DWORD current_process_id
;
32 enum gdb_signal last_sig
= GDB_SIGNAL_0
;
33 DEBUG_EVENT current_event
;
35 /* The most recent event from WaitForDebugEvent. Unlike
36 current_event, this is guaranteed never to come from a pending
37 stop. This is important because only data from the most recent
38 event from WaitForDebugEvent can be used when calling
39 ContinueDebugEvent. */
40 static DEBUG_EVENT last_wait_event
;
42 windows_thread_info
*current_windows_thread
;
43 DWORD desired_stop_thread_id
= -1;
44 std::vector
<pending_stop
> pending_stops
;
45 EXCEPTION_RECORD siginfo_er
;
47 /* Note that 'debug_events' must be locally defined in the relevant
49 #define DEBUG_EVENTS(x) if (debug_events) debug_printf x
51 windows_thread_info::~windows_thread_info ()
57 windows_thread_info::suspend ()
62 if (SuspendThread (h
) == (DWORD
) -1)
64 DWORD err
= GetLastError ();
66 /* We get Access Denied (5) when trying to suspend
67 threads that Windows started on behalf of the
68 debuggee, usually when those threads are just
70 We can get Invalid Handle (6) if the main thread
72 if (err
!= ERROR_INVALID_HANDLE
&& err
!= ERROR_ACCESS_DENIED
)
73 warning (_("SuspendThread (tid=0x%x) failed. (winerr %u)"),
74 (unsigned) tid
, (unsigned) err
);
82 windows_thread_info::resume ()
86 stopped_at_software_breakpoint
= false;
88 if (ResumeThread (h
) == (DWORD
) -1)
90 DWORD err
= GetLastError ();
91 warning (_("warning: ResumeThread (tid=0x%x) failed. (winerr %u)"),
92 (unsigned) tid
, (unsigned) err
);
99 get_image_name (HANDLE h
, void *address
, int unicode
)
102 static char buf
[MAX_PATH
];
104 static char buf
[(2 * MAX_PATH
) + 1];
106 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
112 /* Attempt to read the name of the dll that was detected.
113 This is documented to work only when actively debugging
114 a program. It will not work for attached processes. */
119 /* Windows CE reports the address of the image name,
120 instead of an address of a pointer into the image name. */
121 address_ptr
= address
;
123 /* See if we could read the address of a string, and that the
124 address isn't null. */
125 if (!ReadProcessMemory (h
, address
, &address_ptr
,
126 sizeof (address_ptr
), &done
)
127 || done
!= sizeof (address_ptr
)
132 /* Find the length of the string. */
133 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
134 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
138 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
141 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
142 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
145 wcstombs (buf
, unicode_address
, MAX_PATH
);
147 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, sizeof buf
,
155 /* The exception thrown by a program to tell the debugger the name of
156 a thread. The exception record contains an ID of a thread and a
157 name to give it. This exception has no documented name, but MSDN
158 dubs it "MS_VC_EXCEPTION" in one code example. */
159 #define MS_VC_EXCEPTION 0x406d1388
161 handle_exception_result
162 handle_exception (struct target_waitstatus
*ourstatus
, bool debug_exceptions
)
164 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
165 debug_printf ("gdb: Target exception %s at %s\n", x, \
166 host_address_to_string (\
167 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
169 EXCEPTION_RECORD
*rec
= ¤t_event
.u
.Exception
.ExceptionRecord
;
170 DWORD code
= rec
->ExceptionCode
;
171 handle_exception_result result
= HANDLE_EXCEPTION_HANDLED
;
173 memcpy (&siginfo_er
, rec
, sizeof siginfo_er
);
175 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
177 /* Record the context of the current thread. */
178 thread_rec (ptid_t (current_event
.dwProcessId
, current_event
.dwThreadId
, 0),
183 case EXCEPTION_ACCESS_VIOLATION
:
184 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
185 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
188 /* See if the access violation happened within the cygwin DLL
189 itself. Cygwin uses a kind of exception handling to deal
190 with passed-in invalid addresses. gdb should not treat
191 these as real SEGVs since they will be silently handled by
192 cygwin. A real SEGV will (theoretically) be caught by
193 cygwin later in the process and will be sent as a
194 cygwin-specific-signal. So, ignore SEGVs if they show up
195 within the text segment of the DLL itself. */
197 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) rec
->ExceptionAddress
;
199 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
200 && addr
< cygwin_load_end
))
201 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
202 && startswith (fn
, "KERNEL32!IsBad")))
203 return HANDLE_EXCEPTION_UNHANDLED
;
207 case STATUS_STACK_OVERFLOW
:
208 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
209 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
211 case STATUS_FLOAT_DENORMAL_OPERAND
:
212 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
213 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
215 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
216 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
217 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
219 case STATUS_FLOAT_INEXACT_RESULT
:
220 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
221 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
223 case STATUS_FLOAT_INVALID_OPERATION
:
224 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
225 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
227 case STATUS_FLOAT_OVERFLOW
:
228 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
229 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
231 case STATUS_FLOAT_STACK_CHECK
:
232 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
233 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
235 case STATUS_FLOAT_UNDERFLOW
:
236 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
237 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
239 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
240 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
241 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
243 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
244 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
245 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
247 case STATUS_INTEGER_OVERFLOW
:
248 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
249 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
251 case EXCEPTION_BREAKPOINT
:
253 if (ignore_first_breakpoint
)
255 /* For WOW64 processes, there are always 2 breakpoint exceptions
256 on startup, first a BREAKPOINT for the 64bit ntdll.dll,
257 then a WX86_BREAKPOINT for the 32bit ntdll.dll.
258 Here we only care about the WX86_BREAKPOINT's. */
259 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
260 ignore_first_breakpoint
= false;
264 case STATUS_WX86_BREAKPOINT
:
265 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
266 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
268 /* Remove the initial breakpoint. */
269 check_breakpoints ((CORE_ADDR
) (long) current_event
270 .u
.Exception
.ExceptionRecord
.ExceptionAddress
);
274 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
275 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
277 case DBG_CONTROL_BREAK
:
278 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
279 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
281 case EXCEPTION_SINGLE_STEP
:
282 case STATUS_WX86_SINGLE_STEP
:
283 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
284 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
286 case EXCEPTION_ILLEGAL_INSTRUCTION
:
287 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
288 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
290 case EXCEPTION_PRIV_INSTRUCTION
:
291 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
292 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
294 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
295 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
296 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
298 case MS_VC_EXCEPTION
:
299 DEBUG_EXCEPTION_SIMPLE ("MS_VC_EXCEPTION");
300 if (handle_ms_vc_exception (rec
))
302 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
303 result
= HANDLE_EXCEPTION_IGNORED
;
306 /* treat improperly formed exception as unknown */
309 /* Treat unhandled first chance exceptions specially. */
310 if (current_event
.u
.Exception
.dwFirstChance
)
311 return HANDLE_EXCEPTION_UNHANDLED
;
312 debug_printf ("gdb: unknown target exception 0x%08x at %s\n",
313 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
314 host_address_to_string (
315 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
316 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
320 last_sig
= ourstatus
->value
.sig
;
323 #undef DEBUG_EXCEPTION_SIMPLE
326 /* See nat/windows-nat.h. */
329 matching_pending_stop (bool debug_events
)
331 /* If there are pending stops, and we might plausibly hit one of
332 them, we don't want to actually continue the inferior -- we just
333 want to report the stop. In this case, we just pretend to
334 continue. See the comment by the definition of "pending_stops"
335 for details on why this is needed. */
336 for (const auto &item
: pending_stops
)
338 if (desired_stop_thread_id
== -1
339 || desired_stop_thread_id
== item
.thread_id
)
341 DEBUG_EVENTS (("windows_continue - pending stop anticipated, "
342 "desired=0x%x, item=0x%x\n",
343 desired_stop_thread_id
, item
.thread_id
));
351 /* See nat/windows-nat.h. */
353 gdb::optional
<pending_stop
>
354 fetch_pending_stop (bool debug_events
)
356 gdb::optional
<pending_stop
> result
;
357 for (auto iter
= pending_stops
.begin ();
358 iter
!= pending_stops
.end ();
361 if (desired_stop_thread_id
== -1
362 || desired_stop_thread_id
== iter
->thread_id
)
365 current_event
= iter
->event
;
367 DEBUG_EVENTS (("get_windows_debug_event - "
368 "pending stop found in 0x%x (desired=0x%x)\n",
369 iter
->thread_id
, desired_stop_thread_id
));
371 pending_stops
.erase (iter
);
379 /* See nat/windows-nat.h. */
382 continue_last_debug_event (DWORD continue_status
, bool debug_events
)
384 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
385 (unsigned) last_wait_event
.dwProcessId
,
386 (unsigned) last_wait_event
.dwThreadId
,
387 continue_status
== DBG_CONTINUE
?
388 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
390 return ContinueDebugEvent (last_wait_event
.dwProcessId
,
391 last_wait_event
.dwThreadId
,
395 /* See nat/windows-nat.h. */
398 wait_for_debug_event (DEBUG_EVENT
*event
, DWORD timeout
)
400 BOOL result
= WaitForDebugEvent (event
, timeout
);
402 last_wait_event
= *event
;