projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Keep reserved bits in CPSR on write
[deliverable/binutils-gdb.git] / gdb / windows-nat.c
CommitLineData
dc05df57 1/* Target-vector operations for controlling windows child processes, for GDB.
0a65a603 2
618f726f 3 Copyright (C) 1995-2016 Free Software Foundation, Inc.
0a65a603 4
e6433c28 5 Contributed by Cygnus Solutions, A Red Hat Company.
e88c49c3 6
24e60978
SC		 7 This file is part of GDB.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
a9762ec7 11 the Free Software Foundation; either version 3 of the License, or
24e60978
SC		 12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
a9762ec7 15 but WITHOUT ANY WARRANTY; without even the implied warranty of
24e60978
SC		 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
a9762ec7 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24e60978 21
dfe7f3ac 22/* Originally by Steve Chamberlain, sac@cygnus.com */
24e60978
SC		 23
24#include "defs.h"
25#include "frame.h" /* required by inferior.h */
26#include "inferior.h"
45741a9c 27#include "infrun.h"
24e60978 28#include "target.h"
24e60978
SC		 29#include "gdbcore.h"
30#include "command.h"
fa58ee11 31#include "completer.h"
4e052eda 32#include "regcache.h"
2a3d5645 33#include "top.h"
403d9909
CF		 34#include <signal.h>
35#include <sys/types.h>
36#include <fcntl.h>
403d9909
CF		 37#include <windows.h>
38#include <imagehlp.h>
2b008701 39#include <psapi.h>
10325bc5 40#ifdef __CYGWIN__
b7ff339d 41#include <wchar.h>
403d9909 42#include <sys/cygwin.h>
b7ff339d 43#include <cygwin/version.h>
10325bc5 44#endif
cad9cd60 45
24e60978 46#include "buildsym.h"
0ba1096a 47#include "filenames.h"
1ef980b9
SC		 48#include "symfile.h"
49#include "objfiles.h"
92107356 50#include "gdb_bfd.h"
de1b3c3d 51#include "gdb_obstack.h"
fdfa3315 52#include "gdbthread.h"
24e60978 53#include "gdbcmd.h"
1e37c281 54#include <unistd.h>
4646aa9d 55#include "exec.h"
3ee6f623 56#include "solist.h"
3cb8e7f6 57#include "solib.h"
de1b3c3d 58#include "xml-support.h"
463888ab 59#include "inttypes.h"
24e60978 60
6c7de422
MK		 61#include "i386-tdep.h"
62#include "i387-tdep.h"
63
31b060a2
CF		 64#include "windows-tdep.h"
65#include "windows-nat.h"
df7e5265 66#include "x86-nat.h"
ecc13e53 67#include "complaints.h"
51a9c8c5 68#include "inf-child.h"
de1b3c3d 69
418c6cb3 70#define AdjustTokenPrivileges dyn_AdjustTokenPrivileges
2b008701
CF		 71#define DebugActiveProcessStop dyn_DebugActiveProcessStop
72#define DebugBreakProcess dyn_DebugBreakProcess
73#define DebugSetProcessKillOnExit dyn_DebugSetProcessKillOnExit
74#define EnumProcessModules dyn_EnumProcessModules
2b008701 75#define GetModuleInformation dyn_GetModuleInformation
418c6cb3
CF		 76#define LookupPrivilegeValueA dyn_LookupPrivilegeValueA
77#define OpenProcessToken dyn_OpenProcessToken
cd44747c
PM		 78#define GetConsoleFontSize dyn_GetConsoleFontSize
79#define GetCurrentConsoleFont dyn_GetCurrentConsoleFont
2b008701 80
43499ea3
PA		 81typedef BOOL WINAPI (AdjustTokenPrivileges_ftype) (HANDLE, BOOL,
82 PTOKEN_PRIVILEGES,
83 DWORD, PTOKEN_PRIVILEGES,
84 PDWORD);
85static AdjustTokenPrivileges_ftype *AdjustTokenPrivileges;
86
87typedef BOOL WINAPI (DebugActiveProcessStop_ftype) (DWORD);
88static DebugActiveProcessStop_ftype *DebugActiveProcessStop;
89
90typedef BOOL WINAPI (DebugBreakProcess_ftype) (HANDLE);
91static DebugBreakProcess_ftype *DebugBreakProcess;
92
93typedef BOOL WINAPI (DebugSetProcessKillOnExit_ftype) (BOOL);
94static DebugSetProcessKillOnExit_ftype *DebugSetProcessKillOnExit;
95
96typedef BOOL WINAPI (EnumProcessModules_ftype) (HANDLE, HMODULE *, DWORD,
97 LPDWORD);
98static EnumProcessModules_ftype *EnumProcessModules;
99
100typedef BOOL WINAPI (GetModuleInformation_ftype) (HANDLE, HMODULE,
101 LPMODULEINFO, DWORD);
102static GetModuleInformation_ftype *GetModuleInformation;
103
104typedef BOOL WINAPI (LookupPrivilegeValueA_ftype) (LPCSTR, LPCSTR, PLUID);
105static LookupPrivilegeValueA_ftype *LookupPrivilegeValueA;
106
107typedef BOOL WINAPI (OpenProcessToken_ftype) (HANDLE, DWORD, PHANDLE);
108static OpenProcessToken_ftype *OpenProcessToken;
109
110typedef BOOL WINAPI (GetCurrentConsoleFont_ftype) (HANDLE, BOOL,
111 CONSOLE_FONT_INFO *);
112static GetCurrentConsoleFont_ftype *GetCurrentConsoleFont;
113
114typedef COORD WINAPI (GetConsoleFontSize_ftype) (HANDLE, DWORD);
115static GetConsoleFontSize_ftype *GetConsoleFontSize;
2b008701 116
b3c613f2
CF		 117#undef STARTUPINFO
118#undef CreateProcess
119#undef GetModuleFileNameEx
120
121#ifndef __CYGWIN__
122# define __PMAX (MAX_PATH + 1)
43499ea3
PA		 123 typedef DWORD WINAPI (GetModuleFileNameEx_ftype) (HANDLE, HMODULE, LPSTR, DWORD);
124 static GetModuleFileNameEx_ftype *GetModuleFileNameEx;
b3c613f2
CF		 125# define STARTUPINFO STARTUPINFOA
126# define CreateProcess CreateProcessA
127# define GetModuleFileNameEx_name "GetModuleFileNameExA"
128# define bad_GetModuleFileNameEx bad_GetModuleFileNameExA
129#else
130# define __PMAX PATH_MAX
581e13c1 131/* The starting and ending address of the cygwin1.dll text segment. */
b3c613f2
CF		 132 static CORE_ADDR cygwin_load_start;
133 static CORE_ADDR cygwin_load_end;
b3c613f2
CF		 134# define __USEWIDE
135 typedef wchar_t cygwin_buf_t;
43499ea3
PA		 136 typedef DWORD WINAPI (GetModuleFileNameEx_ftype) (HANDLE, HMODULE,
137 LPWSTR, DWORD);
138 static GetModuleFileNameEx_ftype *GetModuleFileNameEx;
b3c613f2
CF		 139# define STARTUPINFO STARTUPINFOW
140# define CreateProcess CreateProcessW
141# define GetModuleFileNameEx_name "GetModuleFileNameExW"
142# define bad_GetModuleFileNameEx bad_GetModuleFileNameExW
10325bc5 143#endif
a244bdca 144
581e13c1
MS		 145static int have_saved_context; /* True if we've saved context from a
146 cygwin signal. */
147static CONTEXT saved_context; /* Containes the saved context from a
148 cygwin signal. */
a244bdca 149
0714f9bf
SS		 150/* If we're not using the old Cygwin header file set, define the
151 following which never should have been in the generic Win32 API
581e13c1 152 headers in the first place since they were our own invention... */
0714f9bf 153#ifndef _GNU_H_WINDOWS_H
9d3789f7 154enum
8e860359
CF		 155 {
156 FLAG_TRACE_BIT = 0x100,
8e860359 157 };
0714f9bf
SS		 158#endif
159
5851ab76
JB		 160#ifndef CONTEXT_EXTENDED_REGISTERS
161/* This macro is only defined on ia32. It only makes sense on this target,
162 so define it as zero if not already defined. */
163#define CONTEXT_EXTENDED_REGISTERS 0
164#endif
165
f0666312
JT		 166#define CONTEXT_DEBUGGER_DR CONTEXT_FULL | CONTEXT_FLOATING_POINT \
167 | CONTEXT_SEGMENTS | CONTEXT_DEBUG_REGISTERS \
168 | CONTEXT_EXTENDED_REGISTERS
97da3b20 169
41b4aadc 170static uintptr_t dr[8];
87a45c96
CF		 171static int debug_registers_changed;
172static int debug_registers_used;
16d905e2
CF		 173
174static int windows_initialization_done;
6537bb24 175#define DR6_CLEAR_VALUE 0xffff0ff0
97da3b20 176
24cdb46e
РИ		 177/* The exception thrown by a program to tell the debugger the name of
178 a thread. The exception record contains an ID of a thread and a
179 name to give it. This exception has no documented name, but MSDN
180 dubs it "MS_VC_EXCEPTION" in one code example. */
181#define MS_VC_EXCEPTION 0x406d1388
182
183typedef enum
184{
185 HANDLE_EXCEPTION_UNHANDLED = 0,
186 HANDLE_EXCEPTION_HANDLED,
187 HANDLE_EXCEPTION_IGNORED
188} handle_exception_result;
189
3cee93ac 190/* The string sent by cygwin when it processes a signal.
581e13c1 191 FIXME: This should be in a cygwin include file. */
3929abe9
CF		 192#ifndef _CYGWIN_SIGNAL_STRING
193#define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
194#endif
3cee93ac 195
29fe111d 196#define CHECK(x) check (x, __FILE__,__LINE__)
dfe7f3ac 197#define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
4e52d31c
PM		 198#define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
199#define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
200#define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
24e60978 201
bfedc46a 202static void windows_interrupt (struct target_ops *self, ptid_t);
02529b48 203static int windows_thread_alive (struct target_ops *, ptid_t);
7d85a9c0 204static void windows_kill_inferior (struct target_ops *);
3cee93ac 205
9bb9e8ad
PM		 206static void cygwin_set_dr (int i, CORE_ADDR addr);
207static void cygwin_set_dr7 (unsigned long val);
a961bc18 208static CORE_ADDR cygwin_get_dr (int i);
9bb9e8ad 209static unsigned long cygwin_get_dr6 (void);
a961bc18 210static unsigned long cygwin_get_dr7 (void);
9bb9e8ad 211
a493e3e2 212static enum gdb_signal last_sig = GDB_SIGNAL_0;
581e13c1 213/* Set if a signal was received from the debugged process. */
7393af7c 214
3cee93ac 215/* Thread information structure used to track information that is
6537bb24 216 not available in gdb's thread structure. */
876d1cd7 217typedef struct windows_thread_info_struct
3a4b77d8 218 {
876d1cd7 219 struct windows_thread_info_struct *next;
3a4b77d8
JM		 220 DWORD id;
221 HANDLE h;
711e434b 222 CORE_ADDR thread_local_base;
3a4b77d8 223 char *name;
6537bb24 224 int suspended;
3ade5333 225 int reload_context;
3a4b77d8 226 CONTEXT context;
1e37c281 227 STACKFRAME sf;
8e860359 228 }
876d1cd7 229windows_thread_info;
1e37c281 230
876d1cd7 231static windows_thread_info thread_head;
24e60978 232
581e13c1 233/* The process and thread handles for the above context. */
24e60978 234
3cee93ac
CF		 235static DEBUG_EVENT current_event; /* The current debug event from
236 WaitForDebugEvent */
237static HANDLE current_process_handle; /* Currently executing process */
876d1cd7 238static windows_thread_info *current_thread; /* Info on currently selected thread */
349b409f 239static DWORD main_thread_id; /* Thread ID of the main thread */
24e60978 240
581e13c1 241/* Counts of things. */
24e60978
SC		 242static int exception_count = 0;
243static int event_count = 0;
dfe7f3ac 244static int saw_create;
bf25528d 245static int open_process_used = 0;
24e60978 246
581e13c1 247/* User options. */
24e60978 248static int new_console = 0;
10325bc5 249#ifdef __CYGWIN__
09280ddf 250static int cygwin_exceptions = 0;
10325bc5 251#endif
1e37c281 252static int new_group = 1;
dfe7f3ac
CF		 253static int debug_exec = 0; /* show execution */
254static int debug_events = 0; /* show events from kernel */
255static int debug_memory = 0; /* show target memory accesses */
1ef980b9 256static int debug_exceptions = 0; /* show target exceptions */
dfe7f3ac
CF		 257static int useshell = 0; /* use shell for subprocesses */
258
7e63b4e4 259/* This vector maps GDB's idea of a register's number into an offset
dc05df57 260 in the windows exception context vector.
24e60978 261
3cee93ac 262 It also contains the bit mask needed to load the register in question.
24e60978 263
7e63b4e4
JB		 264 The contents of this table can only be computed by the units
265 that provide CPU-specific support for Windows native debugging.
266 These units should set the table by calling
dc05df57 267 windows_set_context_register_offsets.
7e63b4e4 268
24e60978
SC		 269 One day we could read a reg, we could inspect the context we
270 already have loaded, if it doesn't have the bit set that we need,
271 we read that set of registers in using GetThreadContext. If the
581e13c1 272 context already contains what we need, we just unpack it. Then to
24e60978
SC		 273 write a register, first we have to ensure that the context contains
274 the other regs of the group, and then we copy the info in and set
581e13c1 275 out bit. */
24e60978 276
7e63b4e4 277static const int *mappings;
d3a09475 278
d40dc7a8
JB		 279/* The function to use in order to determine whether a register is
280 a segment register or not. */
281static segment_register_p_ftype *segment_register_p;
282
24e60978 283/* This vector maps the target's idea of an exception (extracted
581e13c1 284 from the DEBUG_EVENT structure) to GDB's idea. */
24e60978
SC		 285
286struct xlate_exception
287 {
288 int them;
2ea28649 289 enum gdb_signal us;
24e60978
SC		 290 };
291
24e60978
SC		 292static const struct xlate_exception
293 xlate[] =
294{
a493e3e2
PA		 295 {EXCEPTION_ACCESS_VIOLATION, GDB_SIGNAL_SEGV},
296 {STATUS_STACK_OVERFLOW, GDB_SIGNAL_SEGV},
297 {EXCEPTION_BREAKPOINT, GDB_SIGNAL_TRAP},
298 {DBG_CONTROL_C, GDB_SIGNAL_INT},
299 {EXCEPTION_SINGLE_STEP, GDB_SIGNAL_TRAP},
300 {STATUS_FLOAT_DIVIDE_BY_ZERO, GDB_SIGNAL_FPE},
56db1d67 301 {-1, GDB_SIGNAL_UNKNOWN}};
24e60978 302
7e63b4e4
JB		 303/* Set the MAPPINGS static global to OFFSETS.
304 See the description of MAPPINGS for more details. */
305
306void
dc05df57 307windows_set_context_register_offsets (const int *offsets)
7e63b4e4
JB		 308{
309 mappings = offsets;
310}
311
d40dc7a8
JB		 312/* See windows-nat.h. */
313
314void
315windows_set_segment_register_p (segment_register_p_ftype *fun)
316{
317 segment_register_p = fun;
318}
319
fa4ba8da
PM		 320static void
321check (BOOL ok, const char *file, int line)
322{
323 if (!ok)
d50a0ce2
CV		 324 printf_filtered ("error return %s:%d was %u\n", file, line,
325 (unsigned) GetLastError ());
fa4ba8da
PM		 326}
327
6537bb24
PA		 328/* Find a thread record given a thread id. If GET_CONTEXT is not 0,
329 then also retrieve the context for this thread. If GET_CONTEXT is
330 negative, then don't suspend the thread. */
876d1cd7 331static windows_thread_info *
3cee93ac 332thread_rec (DWORD id, int get_context)
24e60978 333{
876d1cd7 334 windows_thread_info *th;
3cee93ac 335
3a4b77d8 336 for (th = &thread_head; (th = th->next) != NULL;)
3cee93ac
CF		 337 if (th->id == id)
338 {
6537bb24 339 if (!th->suspended && get_context)
3cee93ac 340 {
8a892701 341 if (get_context > 0 && id != current_event.dwThreadId)
6537bb24
PA		 342 {
343 if (SuspendThread (th->h) == (DWORD) -1)
344 {
345 DWORD err = GetLastError ();
22128028 346
17617f2d
EZ		 347 /* We get Access Denied (5) when trying to suspend
348 threads that Windows started on behalf of the
349 debuggee, usually when those threads are just
5d9c55d3
JT		 350 about to exit.
351 We can get Invalid Handle (6) if the main thread
352 has exited. */
353 if (err != ERROR_INVALID_HANDLE
354 && err != ERROR_ACCESS_DENIED)
17617f2d
EZ		 355 warning (_("SuspendThread (tid=0x%x) failed."
356 " (winerr %u)"),
357 (unsigned) id, (unsigned) err);
358 th->suspended = -1;
6537bb24 359 }
17617f2d
EZ		 360 else
361 th->suspended = 1;
6537bb24 362 }
3cee93ac 363 else if (get_context < 0)
6537bb24 364 th->suspended = -1;
3ade5333 365 th->reload_context = 1;
3cee93ac
CF		 366 }
367 return th;
368 }
369
370 return NULL;
371}
372
2dc38344 373/* Add a thread to the thread list. */
876d1cd7 374static windows_thread_info *
711e434b 375windows_add_thread (ptid_t ptid, HANDLE h, void *tlb)
3cee93ac 376{
876d1cd7 377 windows_thread_info *th;
2dc38344
PA		 378 DWORD id;
379
380 gdb_assert (ptid_get_tid (ptid) != 0);
381
382 id = ptid_get_tid (ptid);
3cee93ac
CF		 383
384 if ((th = thread_rec (id, FALSE)))
385 return th;
386
876d1cd7 387 th = XCNEW (windows_thread_info);
3cee93ac
CF		 388 th->id = id;
389 th->h = h;
711e434b 390 th->thread_local_base = (CORE_ADDR) (uintptr_t) tlb;
3cee93ac
CF		 391 th->next = thread_head.next;
392 thread_head.next = th;
2dc38344
PA		 393 add_thread (ptid);
394 /* Set the debug registers for the new thread if they are used. */
fa4ba8da
PM		 395 if (debug_registers_used)
396 {
397 /* Only change the value of the debug registers. */
398 th->context.ContextFlags = CONTEXT_DEBUG_REGISTERS;
399 CHECK (GetThreadContext (th->h, &th->context));
400 th->context.Dr0 = dr[0];
401 th->context.Dr1 = dr[1];
402 th->context.Dr2 = dr[2];
403 th->context.Dr3 = dr[3];
6537bb24 404 th->context.Dr6 = DR6_CLEAR_VALUE;
fa4ba8da
PM		 405 th->context.Dr7 = dr[7];
406 CHECK (SetThreadContext (th->h, &th->context));
407 th->context.ContextFlags = 0;
408 }
3cee93ac 409 return th;
24e60978
SC		 410}
411
3cee93ac 412/* Clear out any old thread list and reintialize it to a
581e13c1 413 pristine state. */
24e60978 414static void
dc05df57 415windows_init_thread_list (void)
24e60978 416{
876d1cd7 417 windows_thread_info *th = &thread_head;
3cee93ac 418
dc05df57 419 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
3cee93ac
CF		 420 init_thread_list ();
421 while (th->next != NULL)
24e60978 422 {
876d1cd7 423 windows_thread_info *here = th->next;
3cee93ac 424 th->next = here->next;
b8c9b27d 425 xfree (here);
24e60978 426 }
059198c1 427 thread_head.next = NULL;
3cee93ac
CF		 428}
429
581e13c1 430/* Delete a thread from the list of threads. */
3cee93ac 431static void
e0ea48a0 432windows_delete_thread (ptid_t ptid, DWORD exit_code)
3cee93ac 433{
876d1cd7 434 windows_thread_info *th;
2dc38344
PA		 435 DWORD id;
436
437 gdb_assert (ptid_get_tid (ptid) != 0);
438
439 id = ptid_get_tid (ptid);
3cee93ac
CF		 440
441 if (info_verbose)
2dc38344 442 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid));
e0ea48a0
EZ		 443 else if (print_thread_events && id != main_thread_id)
444 printf_unfiltered (_("[%s exited with code %u]\n"),
564eac42 445 target_pid_to_str (ptid), (unsigned) exit_code);
2dc38344 446 delete_thread (ptid);
3cee93ac
CF		 447
448 for (th = &thread_head;
449 th->next != NULL && th->next->id != id;
450 th = th->next)
451 continue;
452
453 if (th->next != NULL)
24e60978 454 {
876d1cd7 455 windows_thread_info *here = th->next;
3cee93ac 456 th->next = here->next;
24cdb46e 457 xfree (here->name);
b8c9b27d 458 xfree (here);
24e60978
SC		 459 }
460}
461
3cee93ac 462static void
dc05df57 463do_windows_fetch_inferior_registers (struct regcache *regcache, int r)
24e60978 464{
1e37c281 465 char *context_offset = ((char *) &current_thread->context) + mappings[r];
20a6ec49
MD		 466 struct gdbarch *gdbarch = get_regcache_arch (regcache);
467 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1e37c281 468 long l;
6c7de422 469
3ade5333 470 if (!current_thread)
d6dc8049 471 return; /* Windows sometimes uses a non-existent thread id in its
581e13c1 472 events. */
3ade5333
CF		 473
474 if (current_thread->reload_context)
475 {
f20c58f5 476#ifdef __CYGWIN__
a244bdca
CF		 477 if (have_saved_context)
478 {
581e13c1
MS		 479 /* Lie about where the program actually is stopped since
480 cygwin has informed us that we should consider the signal
481 to have occurred at another location which is stored in
482 "saved_context. */
483 memcpy (&current_thread->context, &saved_context,
484 __COPY_CONTEXT_SIZE);
a244bdca
CF		 485 have_saved_context = 0;
486 }
487 else
cb832706 488#endif
a244bdca 489 {
876d1cd7 490 windows_thread_info *th = current_thread;
a244bdca 491 th->context.ContextFlags = CONTEXT_DEBUGGER_DR;
17617f2d 492 CHECK (GetThreadContext (th->h, &th->context));
2b008701 493 /* Copy dr values from that thread.
581e13c1
MS		 494 But only if there were not modified since last stop.
495 PR gdb/2388 */
88616312
PM		 496 if (!debug_registers_changed)
497 {
498 dr[0] = th->context.Dr0;
499 dr[1] = th->context.Dr1;
500 dr[2] = th->context.Dr2;
501 dr[3] = th->context.Dr3;
502 dr[6] = th->context.Dr6;
503 dr[7] = th->context.Dr7;
504 }
a244bdca 505 }
3ade5333
CF		 506 current_thread->reload_context = 0;
507 }
508
20a6ec49 509 if (r == I387_FISEG_REGNUM (tdep))
1e37c281 510 {
8e860359 511 l = *((long *) context_offset) & 0xffff;
56be3814 512 regcache_raw_supply (regcache, r, (char *) &l);
1e37c281 513 }
20a6ec49 514 else if (r == I387_FOP_REGNUM (tdep))
1e37c281 515 {
8e860359 516 l = (*((long *) context_offset) >> 16) & ((1 << 11) - 1);
56be3814 517 regcache_raw_supply (regcache, r, (char *) &l);
1e37c281 518 }
d40dc7a8
JB		 519 else if (segment_register_p (r))
520 {
521 /* GDB treats segment registers as 32bit registers, but they are
522 in fact only 16 bits long. Make sure we do not read extra
523 bits from our source buffer. */
524 l = *((long *) context_offset) & 0xffff;
525 regcache_raw_supply (regcache, r, (char *) &l);
526 }
1e37c281 527 else if (r >= 0)
56be3814 528 regcache_raw_supply (regcache, r, context_offset);
3cee93ac 529 else
24e60978 530 {
20a6ec49 531 for (r = 0; r < gdbarch_num_regs (gdbarch); r++)
dc05df57 532 do_windows_fetch_inferior_registers (regcache, r);
24e60978 533 }
3cee93ac
CF		 534}
535
536static void
28439f5e
PA		 537windows_fetch_inferior_registers (struct target_ops *ops,
538 struct regcache *regcache, int r)
3cee93ac 539{
2dc38344 540 current_thread = thread_rec (ptid_get_tid (inferior_ptid), TRUE);
d6dc8049 541 /* Check if current_thread exists. Windows sometimes uses a non-existent
581e13c1 542 thread id in its events. */
3ade5333 543 if (current_thread)
dc05df57 544 do_windows_fetch_inferior_registers (regcache, r);
3cee93ac
CF		 545}
546
547static void
dc05df57 548do_windows_store_inferior_registers (const struct regcache *regcache, int r)
3cee93ac 549{
3ade5333 550 if (!current_thread)
581e13c1 551 /* Windows sometimes uses a non-existent thread id in its events. */;
3ade5333 552 else if (r >= 0)
56be3814 553 regcache_raw_collect (regcache, r,
822c9732 554 ((char *) &current_thread->context) + mappings[r]);
24e60978
SC		 555 else
556 {
40a6adc1 557 for (r = 0; r < gdbarch_num_regs (get_regcache_arch (regcache)); r++)
dc05df57 558 do_windows_store_inferior_registers (regcache, r);
24e60978
SC		 559 }
560}
561
581e13c1 562/* Store a new register value into the current thread context. */
3cee93ac 563static void
28439f5e
PA		 564windows_store_inferior_registers (struct target_ops *ops,
565 struct regcache *regcache, int r)
3cee93ac 566{
2dc38344 567 current_thread = thread_rec (ptid_get_tid (inferior_ptid), TRUE);
d6dc8049 568 /* Check if current_thread exists. Windows sometimes uses a non-existent
581e13c1 569 thread id in its events. */
3ade5333 570 if (current_thread)
dc05df57 571 do_windows_store_inferior_registers (regcache, r);
3cee93ac 572}
24e60978 573
450005e7 574/* Encapsulate the information required in a call to
581e13c1 575 symbol_file_add_args. */
8a892701
CF		 576struct safe_symbol_file_add_args
577{
578 char *name;
579 int from_tty;
580 struct section_addr_info *addrs;
581 int mainline;
582 int flags;
7c5c87c0 583 struct ui_file *err, *out;
8a892701
CF		 584 struct objfile *ret;
585};
586
581e13c1 587/* Maintain a linked list of "so" information. */
3ee6f623 588struct lm_info
02e423b9 589{
d3653bf6 590 LPVOID load_addr;
3ee6f623
CF		 591};
592
593static struct so_list solib_start, *solib_end;
02e423b9 594
de1b3c3d 595static struct so_list *
dc05df57 596windows_make_so (const char *name, LPVOID load_addr)
8e860359 597{
3ee6f623 598 struct so_list *so;
d0d0ab16
CV		 599 char *p;
600#ifndef __CYGWIN__
b3c613f2
CF		 601 char buf[__PMAX];
602 char cwd[__PMAX];
3f8ad85b
CF		 603 WIN32_FIND_DATA w32_fd;
604 HANDLE h = FindFirstFile(name, &w32_fd);
3f8ad85b 605
6badb179
CF		 606 if (h == INVALID_HANDLE_VALUE)
607 strcpy (buf, name);
608 else
3f8ad85b 609 {
c914e0cc
CF		 610 FindClose (h);
611 strcpy (buf, name);
612 if (GetCurrentDirectory (MAX_PATH + 1, cwd))
613 {
614 p = strrchr (buf, '\\');
615 if (p)
616 p[1] = '\0';
617 SetCurrentDirectory (buf);
618 GetFullPathName (w32_fd.cFileName, MAX_PATH, buf, &p);
619 SetCurrentDirectory (cwd);
620 }
3f8ad85b 621 }
3ee6f623
CF		 622 if (strcasecmp (buf, "ntdll.dll") == 0)
623 {
624 GetSystemDirectory (buf, sizeof (buf));
625 strcat (buf, "\\ntdll.dll");
626 }
d0d0ab16 627#else
b3c613f2 628 cygwin_buf_t buf[__PMAX];
d0d0ab16 629
b3c613f2 630 buf[0] = 0;
d0d0ab16
CV		 631 if (access (name, F_OK) != 0)
632 {
633 if (strcasecmp (name, "ntdll.dll") == 0)
b3c613f2 634#ifdef __USEWIDE
d0d0ab16
CV		 635 {
636 GetSystemDirectoryW (buf, sizeof (buf) / sizeof (wchar_t));
637 wcscat (buf, L"\\ntdll.dll");
638 }
b3c613f2
CF		 639#else
640 {
641 GetSystemDirectoryA (buf, sizeof (buf) / sizeof (wchar_t));
642 strcat (buf, "\\ntdll.dll");
643 }
644#endif
d0d0ab16
CV		 645 }
646#endif
41bf6aca 647 so = XCNEW (struct so_list);
8d749320 648 so->lm_info = XNEW (struct lm_info);
3ee6f623 649 so->lm_info->load_addr = load_addr;
de1b3c3d 650 strcpy (so->so_original_name, name);
10325bc5
PA		 651#ifndef __CYGWIN__
652 strcpy (so->so_name, buf);
653#else
d0d0ab16
CV		 654 if (buf[0])
655 cygwin_conv_path (CCP_WIN_W_TO_POSIX, buf, so->so_name,
656 SO_NAME_MAX_PATH_SIZE);
657 else
658 {
60c5c021 659 char *rname = realpath (name, NULL);
d0d0ab16
CV		 660 if (rname && strlen (rname) < SO_NAME_MAX_PATH_SIZE)
661 {
662 strcpy (so->so_name, rname);
663 free (rname);
664 }
665 else
666 error (_("dll path too long"));
667 }
de1b3c3d
PA		 668 /* Record cygwin1.dll .text start/end. */
669 p = strchr (so->so_name, '\0') - (sizeof ("/cygwin1.dll") - 1);
670 if (p >= so->so_name && strcasecmp (p, "/cygwin1.dll") == 0)
671 {
672 bfd *abfd;
673 asection *text = NULL;
674 CORE_ADDR text_vma;
8e860359 675
1c00ec6b 676 abfd = gdb_bfd_open (so->so_name, "pei-i386", -1);
a244bdca 677
de1b3c3d
PA		 678 if (!abfd)
679 return so;
680
681 if (bfd_check_format (abfd, bfd_object))
682 text = bfd_get_section_by_name (abfd, ".text");
683
684 if (!text)
685 {
cbb099e8 686 gdb_bfd_unref (abfd);
de1b3c3d
PA		 687 return so;
688 }
689
7a9dd1b2 690 /* The symbols in a dll are offset by 0x1000, which is the
de1b3c3d 691 offset from 0 of the first byte in an image - because of the
581e13c1
MS		 692 file header and the section alignment. */
693 cygwin_load_start = (CORE_ADDR) (uintptr_t) ((char *)
694 load_addr + 0x1000);
dc05df57 695 cygwin_load_end = cygwin_load_start + bfd_section_size (abfd, text);
de1b3c3d 696
cbb099e8 697 gdb_bfd_unref (abfd);
de1b3c3d 698 }
10325bc5 699#endif
de1b3c3d
PA		 700
701 return so;
8e860359
CF		 702}
703
3ee6f623 704static char *
dfe7f3ac
CF		 705get_image_name (HANDLE h, void *address, int unicode)
706{
d0d0ab16 707#ifdef __CYGWIN__
b3c613f2 708 static char buf[__PMAX];
d0d0ab16 709#else
b3c613f2 710 static char buf[(2 * __PMAX) + 1];
d0d0ab16 711#endif
dfe7f3ac
CF		 712 DWORD size = unicode ? sizeof (WCHAR) : sizeof (char);
713 char *address_ptr;
714 int len = 0;
715 char b[2];
5732a500 716 SIZE_T done;
dfe7f3ac
CF		 717
718 /* Attempt to read the name of the dll that was detected.
719 This is documented to work only when actively debugging
581e13c1 720 a program. It will not work for attached processes. */
dfe7f3ac
CF		 721 if (address == NULL)
722 return NULL;
723
dfe7f3ac 724 /* See if we could read the address of a string, and that the
581e13c1
MS		 725 address isn't null. */
726 if (!ReadProcessMemory (h, address, &address_ptr,
727 sizeof (address_ptr), &done)
6f17862b 728 || done != sizeof (address_ptr) || !address_ptr)
dfe7f3ac
CF		 729 return NULL;
730
581e13c1 731 /* Find the length of the string. */
6f17862b
CF		 732 while (ReadProcessMemory (h, address_ptr + len++ * size, &b, size, &done)
733 && (b[0] != 0 || b[size - 1] != 0) && done == size)
734 continue;
dfe7f3ac
CF		 735
736 if (!unicode)
737 ReadProcessMemory (h, address_ptr, buf, len, &done);
738 else
739 {
740 WCHAR *unicode_address = (WCHAR *) alloca (len * sizeof (WCHAR));
741 ReadProcessMemory (h, address_ptr, unicode_address, len * sizeof (WCHAR),
742 &done);
d0d0ab16 743#ifdef __CYGWIN__
b3c613f2 744 wcstombs (buf, unicode_address, __PMAX);
d0d0ab16
CV		 745#else
746 WideCharToMultiByte (CP_ACP, 0, unicode_address, len, buf, sizeof buf,
747 0, 0);
748#endif
dfe7f3ac
CF		 749 }
750
751 return buf;
752}
753
1cd9feab
JB		 754/* Handle a DLL load event, and return 1.
755
756 This function assumes that this event did not occur during inferior
757 initialization, where their event info may be incomplete (see
758 do_initial_windows_stuff and windows_add_all_dlls for more info
759 on how we handle DLL loading during that phase). */
760
1750a5ef 761static int
0a65a603 762handle_load_dll (void *dummy)
24e60978 763{
3a4b77d8 764 LOAD_DLL_DEBUG_INFO *event = &current_event.u.LoadDll;
1cd9feab 765 char *dll_name;
24e60978 766
94481b8c
JB		 767 /* Try getting the DLL name via the lpImageName field of the event.
768 Note that Microsoft documents this fields as strictly optional,
769 in the sense that it might be NULL. And the first DLL event in
770 particular is explicitly documented as "likely not pass[ed]"
771 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
1cd9feab
JB		 772 dll_name = get_image_name (current_process_handle,
773 event->lpImageName, event->fUnicode);
3cee93ac
CF		 774 if (!dll_name)
775 return 1;
776
dc05df57 777 solib_end->next = windows_make_so (dll_name, event->lpBaseOfDll);
de1b3c3d 778 solib_end = solib_end->next;
450005e7 779
a74ce742
PM		 780 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end->so_name,
781 host_address_to_string (solib_end->lm_info->load_addr)));
7488902c 782
450005e7
CF		 783 return 1;
784}
785
3ee6f623 786static void
dc05df57 787windows_free_so (struct so_list *so)
3ee6f623 788{
3ee6f623
CF		 789 if (so->lm_info)
790 xfree (so->lm_info);
de1b3c3d 791 xfree (so);
3cb8e7f6
CF		 792}
793
3be75f87
JB		 794/* Handle a DLL unload event.
795 Return 1 if successful, or zero otherwise.
796
797 This function assumes that this event did not occur during inferior
798 initialization, where their event info may be incomplete (see
799 do_initial_windows_stuff and windows_add_all_dlls for more info
800 on how we handle DLL loading during that phase). */
801
d3ff4a77 802static int
0a65a603 803handle_unload_dll (void *dummy)
d3ff4a77 804{
d3653bf6 805 LPVOID lpBaseOfDll = current_event.u.UnloadDll.lpBaseOfDll;
3ee6f623 806 struct so_list *so;
d3ff4a77
CF		 807
808 for (so = &solib_start; so->next != NULL; so = so->next)
3ee6f623 809 if (so->next->lm_info->load_addr == lpBaseOfDll)
d3ff4a77 810 {
3ee6f623 811 struct so_list *sodel = so->next;
a25cd31f 812
d3ff4a77
CF		 813 so->next = sodel->next;
814 if (!so->next)
815 solib_end = so;
7488902c
PM		 816 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel->so_name));
817
dc05df57 818 windows_free_so (sodel);
d3ff4a77
CF		 819 return 1;
820 }
3929abe9 821
ecc13e53
JB		 822 /* We did not find any DLL that was previously loaded at this address,
823 so register a complaint. We do not report an error, because we have
824 observed that this may be happening under some circumstances. For
825 instance, running 32bit applications on x64 Windows causes us to receive
826 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
827 events are apparently caused by the WOW layer, the interface between
828 32bit and 64bit worlds). */
829 complaint (&symfile_complaints, _("dll starting at %s not found."),
830 host_address_to_string (lpBaseOfDll));
d3ff4a77
CF		 831
832 return 0;
833}
834
581e13c1 835/* Clear list of loaded DLLs. */
3ee6f623 836static void
dc05df57 837windows_clear_solib (void)
450005e7 838{
450005e7
CF		 839 solib_start.next = NULL;
840 solib_end = &solib_start;
450005e7 841}
295732ea 842
463888ab
РИ		 843static void
844signal_event_command (char *args, int from_tty)
845{
846 uintptr_t event_id = 0;
847 char *endargs = NULL;
848
849 if (args == NULL)
850 error (_("signal-event requires an argument (integer event id)"));
851
852 event_id = strtoumax (args, &endargs, 10);
853
854 if ((errno == ERANGE) || (event_id == 0) || (event_id > UINTPTR_MAX) ||
855 ((HANDLE) event_id == INVALID_HANDLE_VALUE))
856 error (_("Failed to convert `%s' to event id"), args);
857
858 SetEvent ((HANDLE) event_id);
859 CloseHandle ((HANDLE) event_id);
860}
861
3cee93ac
CF		 862/* Handle DEBUG_STRING output from child process.
863 Cygwin prepends its messages with a "cygwin:". Interpret this as
581e13c1 864 a Cygwin signal. Otherwise just print the string as a warning. */
3cee93ac
CF		 865static int
866handle_output_debug_string (struct target_waitstatus *ourstatus)
867{
a244bdca
CF		 868 char *s = NULL;
869 int retval = 0;
3cee93ac
CF		 870
871 if (!target_read_string
2c647436
PM		 872 ((CORE_ADDR) (uintptr_t) current_event.u.DebugString.lpDebugStringData,
873 &s, 1024, 0)
3cee93ac 874 || !s || !*s)
a244bdca 875 /* nothing to do */;
61012eef 876 else if (!startswith (s, _CYGWIN_SIGNAL_STRING))
3cee93ac 877 {
10325bc5 878#ifdef __CYGWIN__
61012eef 879 if (!startswith (s, "cYg"))
10325bc5 880#endif
040ea00b
JT		 881 {
882 char *p = strchr (s, '\0');
883
884 if (p > s && *--p == '\n')
885 *p = '\0';
886 warning (("%s"), s);
887 }
3cee93ac 888 }
f20c58f5 889#ifdef __CYGWIN__
d3a09475 890 else
3cee93ac 891 {
581e13c1
MS		 892 /* Got a cygwin signal marker. A cygwin signal is followed by
893 the signal number itself and then optionally followed by the
894 thread id and address to saved context within the DLL. If
895 these are supplied, then the given thread is assumed to have
896 issued the signal and the context from the thread is assumed
897 to be stored at the given address in the inferior. Tell gdb
898 to treat this like a real signal. */
3cee93ac 899 char *p;
3929abe9 900 int sig = strtol (s + sizeof (_CYGWIN_SIGNAL_STRING) - 1, &p, 0);
0ae534d2 901 gdb_signal gotasig = gdb_signal_from_host (sig);
c62fa0e2 902
0714f9bf
SS		 903 ourstatus->value.sig = gotasig;
904 if (gotasig)
a244bdca
CF		 905 {
906 LPCVOID x;
2c15ef43 907 SIZE_T n;
c62fa0e2 908
a244bdca
CF		 909 ourstatus->kind = TARGET_WAITKIND_STOPPED;
910 retval = strtoul (p, &p, 0);
911 if (!retval)
912 retval = main_thread_id;
40653b35 913 else if ((x = (LPCVOID) (uintptr_t) strtoull (p, NULL, 0))
a244bdca 914 && ReadProcessMemory (current_process_handle, x,
581e13c1
MS		 915 &saved_context,
916 __COPY_CONTEXT_SIZE, &n)
a244bdca
CF		 917 && n == __COPY_CONTEXT_SIZE)
918 have_saved_context = 1;
a244bdca 919 }
3cee93ac 920 }
cb832706 921#endif
3cee93ac 922
a244bdca
CF		 923 if (s)
924 xfree (s);
925 return retval;
3cee93ac 926}
24e60978 927
c1748f97
PM		 928static int
929display_selector (HANDLE thread, DWORD sel)
930{
931 LDT_ENTRY info;
932 if (GetThreadSelectorEntry (thread, sel, &info))
933 {
934 int base, limit;
d50a0ce2 935 printf_filtered ("0x%03x: ", (unsigned) sel);
c1748f97 936 if (!info.HighWord.Bits.Pres)
baa93fa6
CF		 937 {
938 puts_filtered ("Segment not present\n");
939 return 0;
940 }
c1748f97
PM		 941 base = (info.HighWord.Bits.BaseHi << 24) +
942 (info.HighWord.Bits.BaseMid << 16)
943 + info.BaseLow;
944 limit = (info.HighWord.Bits.LimitHi << 16) + info.LimitLow;
945 if (info.HighWord.Bits.Granularity)
caad7706 946 limit = (limit << 12) | 0xfff;
c1748f97
PM		 947 printf_filtered ("base=0x%08x limit=0x%08x", base, limit);
948 if (info.HighWord.Bits.Default_Big)
baa93fa6 949 puts_filtered(" 32-bit ");
c1748f97 950 else
baa93fa6 951 puts_filtered(" 16-bit ");
c1748f97
PM		 952 switch ((info.HighWord.Bits.Type & 0xf) >> 1)
953 {
954 case 0:
baa93fa6
CF		 955 puts_filtered ("Data (Read-Only, Exp-up");
956 break;
c1748f97 957 case 1:
baa93fa6
CF		 958 puts_filtered ("Data (Read/Write, Exp-up");
959 break;
c1748f97 960 case 2:
baa93fa6
CF		 961 puts_filtered ("Unused segment (");
962 break;
c1748f97 963 case 3:
baa93fa6
CF		 964 puts_filtered ("Data (Read/Write, Exp-down");
965 break;
c1748f97 966 case 4:
baa93fa6
CF		 967 puts_filtered ("Code (Exec-Only, N.Conf");
968 break;
c1748f97 969 case 5:
baa93fa6 970 puts_filtered ("Code (Exec/Read, N.Conf");
c1748f97
PM		 971 break;
972 case 6:
baa93fa6 973 puts_filtered ("Code (Exec-Only, Conf");
c1748f97
PM		 974 break;
975 case 7:
baa93fa6 976 puts_filtered ("Code (Exec/Read, Conf");
c1748f97
PM		 977 break;
978 default:
979 printf_filtered ("Unknown type 0x%x",info.HighWord.Bits.Type);
980 }
981 if ((info.HighWord.Bits.Type & 0x1) == 0)
baa93fa6 982 puts_filtered(", N.Acc");
c1748f97
PM		 983 puts_filtered (")\n");
984 if ((info.HighWord.Bits.Type & 0x10) == 0)
985 puts_filtered("System selector ");
986 printf_filtered ("Priviledge level = %d. ", info.HighWord.Bits.Dpl);
987 if (info.HighWord.Bits.Granularity)
baa93fa6 988 puts_filtered ("Page granular.\n");
c1748f97
PM		 989 else
990 puts_filtered ("Byte granular.\n");
991 return 1;
992 }
993 else
994 {
5572ce1f
PM		 995 DWORD err = GetLastError ();
996 if (err == ERROR_NOT_SUPPORTED)
997 printf_filtered ("Function not supported\n");
998 else
d50a0ce2 999 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel);
c1748f97
PM		 1000 return 0;
1001 }
1002}
1003
1004static void
1005display_selectors (char * args, int from_tty)
1006{
1007 if (!current_thread)
1008 {
1009 puts_filtered ("Impossible to display selectors now.\n");
1010 return;
1011 }
1012 if (!args)
1013 {
1014
1015 puts_filtered ("Selector $cs\n");
1016 display_selector (current_thread->h,
baa93fa6 1017 current_thread->context.SegCs);
c1748f97
PM		 1018 puts_filtered ("Selector $ds\n");
1019 display_selector (current_thread->h,
baa93fa6 1020 current_thread->context.SegDs);
c1748f97
PM		 1021 puts_filtered ("Selector $es\n");
1022 display_selector (current_thread->h,
baa93fa6 1023 current_thread->context.SegEs);
c1748f97
PM		 1024 puts_filtered ("Selector $ss\n");
1025 display_selector (current_thread->h,
baa93fa6 1026 current_thread->context.SegSs);
c1748f97
PM		 1027 puts_filtered ("Selector $fs\n");
1028 display_selector (current_thread->h,
1029 current_thread->context.SegFs);
1030 puts_filtered ("Selector $gs\n");
1031 display_selector (current_thread->h,
baa93fa6 1032 current_thread->context.SegGs);
c1748f97
PM		 1033 }
1034 else
1035 {
1036 int sel;
1037 sel = parse_and_eval_long (args);
1038 printf_filtered ("Selector \"%s\"\n",args);
1039 display_selector (current_thread->h, sel);
1040 }
1041}
1042
7393af7c 1043#define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
a74ce742
PM		 1044 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1045 host_address_to_string (\
1046 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
7393af7c 1047
24cdb46e 1048static handle_exception_result
450005e7 1049handle_exception (struct target_waitstatus *ourstatus)
24e60978 1050{
24cdb46e
РИ		 1051 EXCEPTION_RECORD *rec = &current_event.u.Exception.ExceptionRecord;
1052 DWORD code = rec->ExceptionCode;
1053 handle_exception_result result = HANDLE_EXCEPTION_HANDLED;
3cee93ac 1054
29fe111d 1055 ourstatus->kind = TARGET_WAITKIND_STOPPED;
8a892701 1056
581e13c1 1057 /* Record the context of the current thread. */
c25b7cce 1058 thread_rec (current_event.dwThreadId, -1);
24e60978 1059
29fe111d 1060 switch (code)
24e60978 1061 {
1ef980b9 1062 case EXCEPTION_ACCESS_VIOLATION:
7393af7c 1063 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
a493e3e2 1064 ourstatus->value.sig = GDB_SIGNAL_SEGV;
10325bc5 1065#ifdef __CYGWIN__
8da8e0b3 1066 {
581e13c1
MS		 1067 /* See if the access violation happened within the cygwin DLL
1068 itself. Cygwin uses a kind of exception handling to deal
1069 with passed-in invalid addresses. gdb should not treat
1070 these as real SEGVs since they will be silently handled by
1071 cygwin. A real SEGV will (theoretically) be caught by
1072 cygwin later in the process and will be sent as a
1073 cygwin-specific-signal. So, ignore SEGVs if they show up
1074 within the text segment of the DLL itself. */
2c02bd72 1075 const char *fn;
24cdb46e 1076 CORE_ADDR addr = (CORE_ADDR) (uintptr_t) rec->ExceptionAddress;
581e13c1
MS		 1077
1078 if ((!cygwin_exceptions && (addr >= cygwin_load_start
1079 && addr < cygwin_load_end))
a244bdca 1080 || (find_pc_partial_function (addr, &fn, NULL, NULL)
61012eef 1081 && startswith (fn, "KERNEL32!IsBad")))
24cdb46e 1082 return HANDLE_EXCEPTION_UNHANDLED;
8da8e0b3 1083 }
10325bc5 1084#endif
7393af7c
PM		 1085 break;
1086 case STATUS_STACK_OVERFLOW:
1087 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
a493e3e2 1088 ourstatus->value.sig = GDB_SIGNAL_SEGV;
7393af7c
PM		 1089 break;
1090 case STATUS_FLOAT_DENORMAL_OPERAND:
1091 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
a493e3e2 1092 ourstatus->value.sig = GDB_SIGNAL_FPE;
7393af7c
PM		 1093 break;
1094 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
1095 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
a493e3e2 1096 ourstatus->value.sig = GDB_SIGNAL_FPE;
7393af7c
PM		 1097 break;
1098 case STATUS_FLOAT_INEXACT_RESULT:
1099 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
a493e3e2 1100 ourstatus->value.sig = GDB_SIGNAL_FPE;
7393af7c
PM		 1101 break;
1102 case STATUS_FLOAT_INVALID_OPERATION:
1103 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
a493e3e2 1104 ourstatus->value.sig = GDB_SIGNAL_FPE;
7393af7c
PM		 1105 break;
1106 case STATUS_FLOAT_OVERFLOW:
1107 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
a493e3e2 1108 ourstatus->value.sig = GDB_SIGNAL_FPE;
7393af7c
PM		 1109 break;
1110 case STATUS_FLOAT_STACK_CHECK:
1111 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
a493e3e2 1112 ourstatus->value.sig = GDB_SIGNAL_FPE;
1ef980b9 1113 break;
3b7c8b74 1114 case STATUS_FLOAT_UNDERFLOW:
7393af7c 1115 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
a493e3e2 1116 ourstatus->value.sig = GDB_SIGNAL_FPE;
7393af7c 1117 break;
3b7c8b74 1118 case STATUS_FLOAT_DIVIDE_BY_ZERO:
7393af7c 1119 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
a493e3e2 1120 ourstatus->value.sig = GDB_SIGNAL_FPE;
7393af7c 1121 break;
3b7c8b74 1122 case STATUS_INTEGER_DIVIDE_BY_ZERO:
7393af7c 1123 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
a493e3e2 1124 ourstatus->value.sig = GDB_SIGNAL_FPE;
3b7c8b74 1125 break;
7393af7c
PM		 1126 case STATUS_INTEGER_OVERFLOW:
1127 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
a493e3e2 1128 ourstatus->value.sig = GDB_SIGNAL_FPE;
1ef980b9
SC		 1129 break;
1130 case EXCEPTION_BREAKPOINT:
7393af7c 1131 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
a493e3e2 1132 ourstatus->value.sig = GDB_SIGNAL_TRAP;
1ef980b9
SC		 1133 break;
1134 case DBG_CONTROL_C:
7393af7c 1135 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
a493e3e2 1136 ourstatus->value.sig = GDB_SIGNAL_INT;
5b421780
PM		 1137 break;
1138 case DBG_CONTROL_BREAK:
7393af7c 1139 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
a493e3e2 1140 ourstatus->value.sig = GDB_SIGNAL_INT;
1ef980b9
SC		 1141 break;
1142 case EXCEPTION_SINGLE_STEP:
7393af7c 1143 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
a493e3e2 1144 ourstatus->value.sig = GDB_SIGNAL_TRAP;
1ef980b9 1145 break;
8227c82d 1146 case EXCEPTION_ILLEGAL_INSTRUCTION:
7393af7c 1147 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
a493e3e2 1148 ourstatus->value.sig = GDB_SIGNAL_ILL;
7393af7c
PM		 1149 break;
1150 case EXCEPTION_PRIV_INSTRUCTION:
1151 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
a493e3e2 1152 ourstatus->value.sig = GDB_SIGNAL_ILL;
7393af7c
PM		 1153 break;
1154 case EXCEPTION_NONCONTINUABLE_EXCEPTION:
1155 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
a493e3e2 1156 ourstatus->value.sig = GDB_SIGNAL_ILL;
8227c82d 1157 break;
24cdb46e
РИ		 1158 case MS_VC_EXCEPTION:
1159 if (rec->NumberParameters >= 3
1160 && (rec->ExceptionInformation[0] & 0xffffffff) == 0x1000)
1161 {
1162 DWORD named_thread_id;
1163 windows_thread_info *named_thread;
1164 CORE_ADDR thread_name_target;
1165
1166 DEBUG_EXCEPTION_SIMPLE ("MS_VC_EXCEPTION");
1167
1168 thread_name_target = rec->ExceptionInformation[1];
1169 named_thread_id = (DWORD) (0xffffffff & rec->ExceptionInformation[2]);
1170
1171 if (named_thread_id == (DWORD) -1)
1172 named_thread_id = current_event.dwThreadId;
1173
1174 named_thread = thread_rec (named_thread_id, 0);
1175 if (named_thread != NULL)
1176 {
1177 int thread_name_len;
1178 char *thread_name;
1179
1180 thread_name_len = target_read_string (thread_name_target,
1181 &thread_name, 1025, NULL);
1182 if (thread_name_len > 0)
1183 {
1184 thread_name[thread_name_len - 1] = '\0';
1185 xfree (named_thread->name);
1186 named_thread->name = thread_name;
1187 }
1188 else
1189 xfree (thread_name);
1190 }
1191 ourstatus->value.sig = GDB_SIGNAL_TRAP;
1192 result = HANDLE_EXCEPTION_IGNORED;
1193 break;
1194 }
1195 /* treat improperly formed exception as unknown, fallthrough */
1ef980b9 1196 default:
581e13c1 1197 /* Treat unhandled first chance exceptions specially. */
02e423b9 1198 if (current_event.u.Exception.dwFirstChance)
24cdb46e 1199 return HANDLE_EXCEPTION_UNHANDLED;
d50a0ce2
CV		 1200 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1201 (unsigned) current_event.u.Exception.ExceptionRecord.ExceptionCode,
a74ce742
PM		 1202 host_address_to_string (
1203 current_event.u.Exception.ExceptionRecord.ExceptionAddress));
a493e3e2 1204 ourstatus->value.sig = GDB_SIGNAL_UNKNOWN;
1ef980b9 1205 break;
24e60978 1206 }
24e60978 1207 exception_count++;
7393af7c 1208 last_sig = ourstatus->value.sig;
24cdb46e 1209 return result;
24e60978
SC		 1210}
1211
17617f2d
EZ		 1212/* Resume thread specified by ID, or all artificially suspended
1213 threads, if we are continuing execution. KILLED non-zero means we
1214 have killed the inferior, so we should ignore weird errors due to
1215 threads shutting down. */
3cee93ac 1216static BOOL
17617f2d 1217windows_continue (DWORD continue_status, int id, int killed)
3cee93ac
CF		 1218{
1219 int i;
876d1cd7 1220 windows_thread_info *th;
3cee93ac
CF		 1221 BOOL res;
1222
0c3d84be 1223 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
d50a0ce2
CV		 1224 (unsigned) current_event.dwProcessId,
1225 (unsigned) current_event.dwThreadId,
dfe7f3ac 1226 continue_status == DBG_CONTINUE ?
7393af7c 1227 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
6537bb24
PA		 1228
1229 for (th = &thread_head; (th = th->next) != NULL;)
1230 if ((id == -1 || id == (int) th->id)
1231 && th->suspended)
1232 {
1233 if (debug_registers_changed)
1234 {
1235 th->context.ContextFlags |= CONTEXT_DEBUG_REGISTERS;
1236 th->context.Dr0 = dr[0];
1237 th->context.Dr1 = dr[1];
1238 th->context.Dr2 = dr[2];
1239 th->context.Dr3 = dr[3];
1240 th->context.Dr6 = DR6_CLEAR_VALUE;
1241 th->context.Dr7 = dr[7];
1242 }
1243 if (th->context.ContextFlags)
1244 {
17617f2d
EZ		 1245 DWORD ec = 0;
1246
1247 if (GetExitCodeThread (th->h, &ec)
1248 && ec == STILL_ACTIVE)
1249 {
1250 BOOL status = SetThreadContext (th->h, &th->context);
1251
1252 if (!killed)
1253 CHECK (status);
1254 }
6537bb24
PA		 1255 th->context.ContextFlags = 0;
1256 }
1257 if (th->suspended > 0)
1258 (void) ResumeThread (th->h);
1259 th->suspended = 0;
1260 }
1261
0714f9bf
SS		 1262 res = ContinueDebugEvent (current_event.dwProcessId,
1263 current_event.dwThreadId,
1264 continue_status);
3cee93ac 1265
68ffc902
JT		 1266 if (!res)
1267 error (_("Failed to resume program execution"
1268 " (ContinueDebugEvent failed, error %u)"),
1269 (unsigned int) GetLastError ());
1270
fa4ba8da 1271 debug_registers_changed = 0;
3cee93ac
CF		 1272 return res;
1273}
1274
d6dc8049
CF		 1275/* Called in pathological case where Windows fails to send a
1276 CREATE_PROCESS_DEBUG_EVENT after an attach. */
3ee6f623 1277static DWORD
5439edaa 1278fake_create_process (void)
3ade5333
CF		 1279{
1280 current_process_handle = OpenProcess (PROCESS_ALL_ACCESS, FALSE,
1281 current_event.dwProcessId);
bf25528d
CF		 1282 if (current_process_handle != NULL)
1283 open_process_used = 1;
1284 else
1285 {
d50a0ce2
CV		 1286 error (_("OpenProcess call failed, GetLastError = %u"),
1287 (unsigned) GetLastError ());
bf25528d
CF		 1288 /* We can not debug anything in that case. */
1289 }
3ade5333 1290 main_thread_id = current_event.dwThreadId;
711e434b
PM		 1291 current_thread = windows_add_thread (
1292 ptid_build (current_event.dwProcessId, 0,
1293 current_event.dwThreadId),
1294 current_event.u.CreateThread.hThread,
1295 current_event.u.CreateThread.lpThreadLocalBase);
3ade5333
CF		 1296 return main_thread_id;
1297}
1298
a244bdca 1299static void
28439f5e 1300windows_resume (struct target_ops *ops,
2ea28649 1301 ptid_t ptid, int step, enum gdb_signal sig)
a244bdca 1302{
876d1cd7 1303 windows_thread_info *th;
a244bdca
CF		 1304 DWORD continue_status = DBG_CONTINUE;
1305
2dc38344
PA		 1306 /* A specific PTID means `step only this thread id'. */
1307 int resume_all = ptid_equal (ptid, minus_one_ptid);
1308
1309 /* If we're continuing all threads, it's the current inferior that
1310 should be handled specially. */
1311 if (resume_all)
1312 ptid = inferior_ptid;
a244bdca 1313
a493e3e2 1314 if (sig != GDB_SIGNAL_0)
a244bdca
CF		 1315 {
1316 if (current_event.dwDebugEventCode != EXCEPTION_DEBUG_EVENT)
1317 {
1318 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig));
1319 }
1320 else if (sig == last_sig)
1321 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1322 else
1323#if 0
1324/* This code does not seem to work, because
1325 the kernel does probably not consider changes in the ExceptionRecord
1326 structure when passing the exception to the inferior.
1327 Note that this seems possible in the exception handler itself. */
1328 {
1329 int i;
1330 for (i = 0; xlate[i].them != -1; i++)
1331 if (xlate[i].us == sig)
1332 {
581e13c1
MS		 1333 current_event.u.Exception.ExceptionRecord.ExceptionCode
1334 = xlate[i].them;
a244bdca
CF		 1335 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1336 break;
1337 }
1338 if (continue_status == DBG_CONTINUE)
1339 {
1340 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig));
1341 }
1342 }
1343#endif
23942819 1344 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
a244bdca
CF		 1345 last_sig));
1346 }
1347
a493e3e2 1348 last_sig = GDB_SIGNAL_0;
a244bdca 1349
dc05df57 1350 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
2dc38344 1351 ptid_get_pid (ptid), ptid_get_tid (ptid), step, sig));
a244bdca 1352
581e13c1 1353 /* Get context for currently selected thread. */
2dc38344 1354 th = thread_rec (ptid_get_tid (inferior_ptid), FALSE);
a244bdca
CF		 1355 if (th)
1356 {
1357 if (step)
1358 {
581e13c1 1359 /* Single step by setting t bit. */
a97b0ac8
UW		 1360 struct regcache *regcache = get_current_regcache ();
1361 struct gdbarch *gdbarch = get_regcache_arch (regcache);
1362 windows_fetch_inferior_registers (ops, regcache,
1363 gdbarch_ps_regnum (gdbarch));
a244bdca
CF		 1364 th->context.EFlags |= FLAG_TRACE_BIT;
1365 }
1366
1367 if (th->context.ContextFlags)
1368 {
1369 if (debug_registers_changed)
1370 {
1371 th->context.Dr0 = dr[0];
1372 th->context.Dr1 = dr[1];
1373 th->context.Dr2 = dr[2];
1374 th->context.Dr3 = dr[3];
6537bb24 1375 th->context.Dr6 = DR6_CLEAR_VALUE;
a244bdca
CF		 1376 th->context.Dr7 = dr[7];
1377 }
1378 CHECK (SetThreadContext (th->h, &th->context));
1379 th->context.ContextFlags = 0;
1380 }
1381 }
1382
1383 /* Allow continuing with the same signal that interrupted us.
581e13c1 1384 Otherwise complain. */
a244bdca 1385
2dc38344 1386 if (resume_all)
17617f2d 1387 windows_continue (continue_status, -1, 0);
2dc38344 1388 else
17617f2d 1389 windows_continue (continue_status, ptid_get_tid (ptid), 0);
a244bdca
CF		 1390}
1391
695de547
CF		 1392/* Ctrl-C handler used when the inferior is not run in the same console. The
1393 handler is in charge of interrupting the inferior using DebugBreakProcess.
1394 Note that this function is not available prior to Windows XP. In this case
1395 we emit a warning. */
d603d4b3 1396static BOOL WINAPI
695de547
CF		 1397ctrl_c_handler (DWORD event_type)
1398{
1399 const int attach_flag = current_inferior ()->attach_flag;
1400
bb0613a5
PM		 1401 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1402 if (event_type != CTRL_C_EVENT && event_type != CTRL_BREAK_EVENT)
695de547
CF		 1403 return FALSE;
1404
1405 /* If the inferior and the debugger share the same console, do nothing as
1406 the inferior has also received the Ctrl-C event. */
1407 if (!new_console && !attach_flag)
1408 return TRUE;
1409
1410 if (!DebugBreakProcess (current_process_handle))
581e13c1
MS		 1411 warning (_("Could not interrupt program. "
1412 "Press Ctrl-c in the program console."));
695de547
CF		 1413
1414 /* Return true to tell that Ctrl-C has been handled. */
1415 return TRUE;
1416}
1417
e6ad66bd
JT		 1418/* Get the next event from the child. Returns a non-zero thread id if the event
1419 requires handling by WFI (or whatever). */
1e37c281 1420static int
28439f5e
PA		 1421get_windows_debug_event (struct target_ops *ops,
1422 int pid, struct target_waitstatus *ourstatus)
1e37c281
JM		 1423{
1424 BOOL debug_event;
8a892701 1425 DWORD continue_status, event_code;
876d1cd7
YZ		 1426 windows_thread_info *th;
1427 static windows_thread_info dummy_thread_info;
e6ad66bd 1428 DWORD thread_id = 0;
1e37c281 1429
a493e3e2 1430 last_sig = GDB_SIGNAL_0;
9d3789f7 1431
8a892701 1432 if (!(debug_event = WaitForDebugEvent (&current_event, 1000)))
29fe111d 1433 goto out;
1e37c281
JM		 1434
1435 event_count++;
1436 continue_status = DBG_CONTINUE;
1e37c281 1437
8a892701 1438 event_code = current_event.dwDebugEventCode;
450005e7 1439 ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
87a45c96 1440 th = NULL;
a244bdca 1441 have_saved_context = 0;
8a892701
CF		 1442
1443 switch (event_code)
1e37c281
JM		 1444 {
1445 case CREATE_THREAD_DEBUG_EVENT:
0c3d84be 1446 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
8a892701
CF		 1447 (unsigned) current_event.dwProcessId,
1448 (unsigned) current_event.dwThreadId,
1449 "CREATE_THREAD_DEBUG_EVENT"));
dfe7f3ac 1450 if (saw_create != 1)
3ade5333 1451 {
181e7f93
PA		 1452 struct inferior *inf;
1453 inf = find_inferior_pid (current_event.dwProcessId);
1454 if (!saw_create && inf->attach_flag)
3ade5333 1455 {
d6dc8049
CF		 1456 /* Kludge around a Windows bug where first event is a create
1457 thread event. Caused when attached process does not have
581e13c1 1458 a main thread. */
e6ad66bd
JT		 1459 thread_id = fake_create_process ();
1460 if (thread_id)
181e7f93 1461 saw_create++;
3ade5333
CF		 1462 }
1463 break;
1464 }
581e13c1 1465 /* Record the existence of this thread. */
e6ad66bd 1466 thread_id = current_event.dwThreadId;
dc05df57 1467 th = windows_add_thread (ptid_build (current_event.dwProcessId, 0,
2dc38344 1468 current_event.dwThreadId),
711e434b
PM		 1469 current_event.u.CreateThread.hThread,
1470 current_event.u.CreateThread.lpThreadLocalBase);
1471
1e37c281
JM		 1472 break;
1473
1474 case EXIT_THREAD_DEBUG_EVENT:
0c3d84be 1475 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
8a892701
CF		 1476 (unsigned) current_event.dwProcessId,
1477 (unsigned) current_event.dwThreadId,
1478 "EXIT_THREAD_DEBUG_EVENT"));
b3c613f2 1479
87a45c96
CF		 1480 if (current_event.dwThreadId != main_thread_id)
1481 {
dc05df57 1482 windows_delete_thread (ptid_build (current_event.dwProcessId, 0,
e0ea48a0
EZ		 1483 current_event.dwThreadId),
1484 current_event.u.ExitThread.dwExitCode);
87a45c96
CF		 1485 th = &dummy_thread_info;
1486 }
1e37c281
JM		 1487 break;
1488
1489 case CREATE_PROCESS_DEBUG_EVENT:
0c3d84be 1490 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
8a892701
CF		 1491 (unsigned) current_event.dwProcessId,
1492 (unsigned) current_event.dwThreadId,
1493 "CREATE_PROCESS_DEBUG_EVENT"));
700b351b 1494 CloseHandle (current_event.u.CreateProcessInfo.hFile);
dfe7f3ac 1495 if (++saw_create != 1)
bf25528d 1496 break;
1e37c281 1497
dfe7f3ac 1498 current_process_handle = current_event.u.CreateProcessInfo.hProcess;
87a45c96 1499 if (main_thread_id)
695de547 1500 windows_delete_thread (ptid_build (current_event.dwProcessId, 0,
e0ea48a0
EZ		 1501 main_thread_id),
1502 0);
9d3789f7 1503 main_thread_id = current_event.dwThreadId;
581e13c1 1504 /* Add the main thread. */
dc05df57 1505 th = windows_add_thread (ptid_build (current_event.dwProcessId, 0,
695de547 1506 current_event.dwThreadId),
711e434b
PM		 1507 current_event.u.CreateProcessInfo.hThread,
1508 current_event.u.CreateProcessInfo.lpThreadLocalBase);
e6ad66bd 1509 thread_id = current_event.dwThreadId;
1e37c281
JM		 1510 break;
1511
1512 case EXIT_PROCESS_DEBUG_EVENT:
0c3d84be 1513 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
8a892701
CF		 1514 (unsigned) current_event.dwProcessId,
1515 (unsigned) current_event.dwThreadId,
1516 "EXIT_PROCESS_DEBUG_EVENT"));
16d905e2
CF		 1517 if (!windows_initialization_done)
1518 {
1519 target_terminal_ours ();
bc1e6c81 1520 target_mourn_inferior (inferior_ptid);
16d905e2
CF		 1521 error (_("During startup program exited with code 0x%x."),
1522 (unsigned int) current_event.u.ExitProcess.dwExitCode);
1523 }
1524 else if (saw_create == 1)
1525 {
1526 ourstatus->kind = TARGET_WAITKIND_EXITED;
1527 ourstatus->value.integer = current_event.u.ExitProcess.dwExitCode;
e6ad66bd 1528 thread_id = main_thread_id;
16d905e2 1529 }
8a892701 1530 break;
1e37c281
JM		 1531
1532 case LOAD_DLL_DEBUG_EVENT:
0c3d84be 1533 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
8a892701
CF		 1534 (unsigned) current_event.dwProcessId,
1535 (unsigned) current_event.dwThreadId,
1536 "LOAD_DLL_DEBUG_EVENT"));
700b351b 1537 CloseHandle (current_event.u.LoadDll.hFile);
ea39ad35 1538 if (saw_create != 1 || ! windows_initialization_done)
dfe7f3ac 1539 break;
8a892701 1540 catch_errors (handle_load_dll, NULL, (char *) "", RETURN_MASK_ALL);
450005e7
CF		 1541 ourstatus->kind = TARGET_WAITKIND_LOADED;
1542 ourstatus->value.integer = 0;
e6ad66bd 1543 thread_id = main_thread_id;
1e37c281
JM		 1544 break;
1545
1546 case UNLOAD_DLL_DEBUG_EVENT:
0c3d84be 1547 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
8a892701
CF		 1548 (unsigned) current_event.dwProcessId,
1549 (unsigned) current_event.dwThreadId,
1550 "UNLOAD_DLL_DEBUG_EVENT"));
ea39ad35 1551 if (saw_create != 1 || ! windows_initialization_done)
dfe7f3ac 1552 break;
d3ff4a77 1553 catch_errors (handle_unload_dll, NULL, (char *) "", RETURN_MASK_ALL);
de1b3c3d
PA		 1554 ourstatus->kind = TARGET_WAITKIND_LOADED;
1555 ourstatus->value.integer = 0;
e6ad66bd 1556 thread_id = main_thread_id;
d3ff4a77 1557 break;
1e37c281
JM		 1558
1559 case EXCEPTION_DEBUG_EVENT:
0c3d84be 1560 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
8a892701
CF		 1561 (unsigned) current_event.dwProcessId,
1562 (unsigned) current_event.dwThreadId,
1563 "EXCEPTION_DEBUG_EVENT"));
dfe7f3ac
CF		 1564 if (saw_create != 1)
1565 break;
24cdb46e
РИ		 1566 switch (handle_exception (ourstatus))
1567 {
1568 case HANDLE_EXCEPTION_UNHANDLED:
1569 default:
1570 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1571 break;
1572 case HANDLE_EXCEPTION_HANDLED:
1573 thread_id = current_event.dwThreadId;
1574 break;
1575 case HANDLE_EXCEPTION_IGNORED:
1576 continue_status = DBG_CONTINUE;
1577 break;
1578 }
1e37c281
JM		 1579 break;
1580
581e13c1 1581 case OUTPUT_DEBUG_STRING_EVENT: /* Message from the kernel. */
0c3d84be 1582 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
8a892701
CF		 1583 (unsigned) current_event.dwProcessId,
1584 (unsigned) current_event.dwThreadId,
1585 "OUTPUT_DEBUG_STRING_EVENT"));
dfe7f3ac
CF		 1586 if (saw_create != 1)
1587 break;
e6ad66bd 1588 thread_id = handle_output_debug_string (ourstatus);
1e37c281 1589 break;
9d3789f7 1590
1e37c281 1591 default:
dfe7f3ac
CF		 1592 if (saw_create != 1)
1593 break;
0c3d84be 1594 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
d50a0ce2
CV		 1595 (unsigned) current_event.dwProcessId,
1596 (unsigned) current_event.dwThreadId);
1597 printf_unfiltered (" unknown event code %u\n",
1598 (unsigned) current_event.dwDebugEventCode);
1e37c281
JM		 1599 break;
1600 }
1601
e6ad66bd 1602 if (!thread_id || saw_create != 1)
a244bdca 1603 {
95824559 1604 CHECK (windows_continue (continue_status, -1, 0));
a244bdca 1605 }
450005e7 1606 else
9d3789f7 1607 {
2dc38344 1608 inferior_ptid = ptid_build (current_event.dwProcessId, 0,
e6ad66bd 1609 thread_id);
776704b9
JT		 1610 current_thread = th;
1611 if (!current_thread)
f16eab5f 1612 current_thread = thread_rec (thread_id, TRUE);
9d3789f7 1613 }
1e37c281
JM		 1614
1615out:
e6ad66bd 1616 return thread_id;
1e37c281
JM		 1617}
1618
2dc38344 1619/* Wait for interesting events to occur in the target process. */
39f77062 1620static ptid_t
117de6a9 1621windows_wait (struct target_ops *ops,
47608cb1 1622 ptid_t ptid, struct target_waitstatus *ourstatus, int options)
24e60978 1623{
2dc38344 1624 int pid = -1;
39f77062 1625
c44537cf
CV		 1626 target_terminal_ours ();
1627
24e60978
SC		 1628 /* We loop when we get a non-standard exception rather than return
1629 with a SPURIOUS because resume can try and step or modify things,
3cee93ac 1630 which needs a current_thread->h. But some of these exceptions mark
24e60978 1631 the birth or death of threads, which mean that the current thread
581e13c1 1632 isn't necessarily what you think it is. */
24e60978
SC		 1633
1634 while (1)
450005e7 1635 {
c57918b2 1636 int retval;
2b008701 1637
695de547
CF		 1638 /* If the user presses Ctrl-c while the debugger is waiting
1639 for an event, he expects the debugger to interrupt his program
1640 and to get the prompt back. There are two possible situations:
1641
1642 - The debugger and the program do not share the console, in
1643 which case the Ctrl-c event only reached the debugger.
1644 In that case, the ctrl_c handler will take care of interrupting
581e13c1
MS		 1645 the inferior. Note that this case is working starting with
1646 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
695de547
CF		 1647 inferior console.
1648
1649 - The debugger and the program share the same console, in which
1650 case both debugger and inferior will receive the Ctrl-c event.
1651 In that case the ctrl_c handler will ignore the event, as the
1652 Ctrl-c event generated inside the inferior will trigger the
1653 expected debug event.
1654
1655 FIXME: brobecker/2008-05-20: If the inferior receives the
1656 signal first and the delay until GDB receives that signal
1657 is sufficiently long, GDB can sometimes receive the SIGINT
1658 after we have unblocked the CTRL+C handler. This would
1659 lead to the debugger stopping prematurely while handling
1660 the new-thread event that comes with the handling of the SIGINT
1661 inside the inferior, and then stop again immediately when
1662 the user tries to resume the execution in the inferior.
1663 This is a classic race that we should try to fix one day. */
1664 SetConsoleCtrlHandler (&ctrl_c_handler, TRUE);
28439f5e 1665 retval = get_windows_debug_event (ops, pid, ourstatus);
695de547 1666 SetConsoleCtrlHandler (&ctrl_c_handler, FALSE);
c57918b2 1667
450005e7 1668 if (retval)
2dc38344 1669 return ptid_build (current_event.dwProcessId, 0, retval);
450005e7
CF		 1670 else
1671 {
1672 int detach = 0;
3cee93ac 1673
98bbd631
AC		 1674 if (deprecated_ui_loop_hook != NULL)
1675 detach = deprecated_ui_loop_hook (0);
0714f9bf 1676
450005e7 1677 if (detach)
7d85a9c0 1678 windows_kill_inferior (ops);
450005e7
CF		 1679 }
1680 }
24e60978
SC		 1681}
1682
ea39ad35
JB		 1683/* Iterate over all DLLs currently mapped by our inferior, and
1684 add them to our list of solibs. */
94481b8c
JB		 1685
1686static void
ea39ad35 1687windows_add_all_dlls (void)
94481b8c
JB		 1688{
1689 struct so_list *so;
1690 HMODULE dummy_hmodule;
1691 DWORD cb_needed;
1692 HMODULE *hmodules;
1693 int i;
1694
94481b8c
JB		 1695 if (EnumProcessModules (current_process_handle, &dummy_hmodule,
1696 sizeof (HMODULE), &cb_needed) == 0)
1697 return;
1698
1699 if (cb_needed < 1)
1700 return;
1701
1702 hmodules = (HMODULE *) alloca (cb_needed);
1703 if (EnumProcessModules (current_process_handle, hmodules,
1704 cb_needed, &cb_needed) == 0)
1705 return;
1706
ea39ad35 1707 for (i = 1; i < (int) (cb_needed / sizeof (HMODULE)); i++)
94481b8c
JB		 1708 {
1709 MODULEINFO mi;
774f74c2
PM		 1710#ifdef __USEWIDE
1711 wchar_t dll_name[__PMAX];
1712 char name[__PMAX];
1713#else
94481b8c 1714 char dll_name[__PMAX];
774f74c2
PM		 1715 char *name;
1716#endif
94481b8c
JB		 1717 if (GetModuleInformation (current_process_handle, hmodules[i],
1718 &mi, sizeof (mi)) == 0)
1719 continue;
1720 if (GetModuleFileNameEx (current_process_handle, hmodules[i],
1721 dll_name, sizeof (dll_name)) == 0)
1722 continue;
774f74c2
PM		 1723#ifdef __USEWIDE
1724 wcstombs (name, dll_name, __PMAX);
1725#else
1726 name = dll_name;
1727#endif
ea39ad35
JB		 1728
1729 solib_end->next = windows_make_so (name, mi.lpBaseOfDll);
1730 solib_end = solib_end->next;
94481b8c
JB		 1731 }
1732}
1733
9d3789f7 1734static void
dc05df57 1735do_initial_windows_stuff (struct target_ops *ops, DWORD pid, int attaching)
9d3789f7 1736{
fa4ba8da 1737 int i;
d6b48e9c 1738 struct inferior *inf;
2020b7ab 1739 struct thread_info *tp;
9d3789f7 1740
a493e3e2 1741 last_sig = GDB_SIGNAL_0;
9d3789f7
CF		 1742 event_count = 0;
1743 exception_count = 0;
bf25528d 1744 open_process_used = 0;
fa4ba8da 1745 debug_registers_changed = 0;
dfe7f3ac 1746 debug_registers_used = 0;
fa4ba8da
PM		 1747 for (i = 0; i < sizeof (dr) / sizeof (dr[0]); i++)
1748 dr[i] = 0;
10325bc5 1749#ifdef __CYGWIN__
de1b3c3d 1750 cygwin_load_start = cygwin_load_end = 0;
10325bc5 1751#endif
9d3789f7
CF		 1752 current_event.dwProcessId = pid;
1753 memset (&current_event, 0, sizeof (current_event));
6a3cb8e8
PA		 1754 if (!target_is_pushed (ops))
1755 push_target (ops);
cb851954 1756 disable_breakpoints_in_shlibs ();
dc05df57 1757 windows_clear_solib ();
88056fbb 1758 clear_proceed_status (0);
9d3789f7
CF		 1759 init_wait_for_inferior ();
1760
6c95b8df
PA		 1761 inf = current_inferior ();
1762 inferior_appeared (inf, pid);
181e7f93 1763 inf->attach_flag = attaching;
7f9f62ba 1764
9f9d052e
PM		 1765 /* Make the new process the current inferior, so terminal handling
1766 can rely on it. When attaching, we don't know about any thread
1767 id here, but that's OK --- nothing should be referencing the
dc05df57 1768 current thread until we report an event out of windows_wait. */
9f9d052e
PM		 1769 inferior_ptid = pid_to_ptid (pid);
1770
5842f62a 1771 target_terminal_init ();
9d3789f7
CF		 1772 target_terminal_inferior ();
1773
16d905e2 1774 windows_initialization_done = 0;
c72f45d1 1775
9d3789f7
CF		 1776 while (1)
1777 {
c72f45d1
PA		 1778 struct target_waitstatus status;
1779
1780 windows_wait (ops, minus_one_ptid, &status, 0);
1781
1782 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
1783 events. */
1784 if (status.kind != TARGET_WAITKIND_LOADED
1785 && status.kind != TARGET_WAITKIND_SPURIOUS)
9d3789f7 1786 break;
c72f45d1
PA		 1787
1788 windows_resume (ops, minus_one_ptid, 0, GDB_SIGNAL_0);
9d3789f7 1789 }
eff8332b 1790
ea39ad35 1791 /* Now that the inferior has been started and all DLLs have been mapped,
3be75f87
JB		 1792 we can iterate over all DLLs and load them in.
1793
1794 We avoid doing it any earlier because, on certain versions of Windows,
1795 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
1796 we have seen on Windows 8.1 that the ntdll.dll load event does not
1797 include the DLL name, preventing us from creating an associated SO.
1798 A possible explanation is that ntdll.dll might be mapped before
1799 the SO info gets created by the Windows system -- ntdll.dll is
1800 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
1801 do not seem to suffer from that problem.
1802
1803 Rather than try to work around this sort of issue, it is much
1804 simpler to just ignore DLL load/unload events during the startup
1805 phase, and then process them all in one batch now. */
ea39ad35 1806 windows_add_all_dlls ();
94481b8c 1807
16d905e2 1808 windows_initialization_done = 1;
9d3789f7
CF		 1809 return;
1810}
1811
616a9dc4
CV		 1812/* Try to set or remove a user privilege to the current process. Return -1
1813 if that fails, the previous setting of that privilege otherwise.
1814
1815 This code is copied from the Cygwin source code and rearranged to allow
1816 dynamically loading of the needed symbols from advapi32 which is only
581e13c1 1817 available on NT/2K/XP. */
616a9dc4
CV		 1818static int
1819set_process_privilege (const char *privilege, BOOL enable)
1820{
616a9dc4
CV		 1821 HANDLE token_hdl = NULL;
1822 LUID restore_priv;
1823 TOKEN_PRIVILEGES new_priv, orig_priv;
1824 int ret = -1;
1825 DWORD size;
1826
616a9dc4
CV		 1827 if (!OpenProcessToken (GetCurrentProcess (),
1828 TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
1829 &token_hdl))
1830 goto out;
1831
418c6cb3 1832 if (!LookupPrivilegeValueA (NULL, privilege, &restore_priv))
616a9dc4
CV		 1833 goto out;
1834
1835 new_priv.PrivilegeCount = 1;
1836 new_priv.Privileges[0].Luid = restore_priv;
1837 new_priv.Privileges[0].Attributes = enable ? SE_PRIVILEGE_ENABLED : 0;
1838
1839 if (!AdjustTokenPrivileges (token_hdl, FALSE, &new_priv,
295732ea 1840 sizeof orig_priv, &orig_priv, &size))
616a9dc4
CV		 1841 goto out;
1842#if 0
1843 /* Disabled, otherwise every `attach' in an unprivileged user session
1844 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
581e13c1 1845 windows_attach(). */
616a9dc4 1846 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
581e13c1 1847 be enabled. GetLastError () returns an correct error code, though. */
616a9dc4
CV		 1848 if (enable && GetLastError () == ERROR_NOT_ALL_ASSIGNED)
1849 goto out;
1850#endif
1851
1852 ret = orig_priv.Privileges[0].Attributes == SE_PRIVILEGE_ENABLED ? 1 : 0;
1853
1854out:
1855 if (token_hdl)
1856 CloseHandle (token_hdl);
1857
1858 return ret;
1859}
1860
02cc9f49 1861/* Attach to process PID, then initialize for debugging it. */
24e60978 1862static void
c0939df1 1863windows_attach (struct target_ops *ops, const char *args, int from_tty)
24e60978
SC		 1864{
1865 BOOL ok;
559e75c0 1866 DWORD pid;
24e60978 1867
74164c56 1868 pid = parse_pid_to_attach (args);
24e60978 1869
616a9dc4
CV		 1870 if (set_process_privilege (SE_DEBUG_NAME, TRUE) < 0)
1871 {
1872 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
581e13c1
MS		 1873 printf_unfiltered ("This can cause attach to "
1874 "fail on Windows NT/2K/XP\n");
616a9dc4
CV		 1875 }
1876
dc05df57 1877 windows_init_thread_list ();
9d3789f7 1878 ok = DebugActiveProcess (pid);
91a175b3 1879 saw_create = 0;
24e60978 1880
10325bc5 1881#ifdef __CYGWIN__
24e60978 1882 if (!ok)
baa93fa6 1883 {
581e13c1 1884 /* Try fall back to Cygwin pid. */
baa93fa6
CF		 1885 pid = cygwin_internal (CW_CYGWIN_PID_TO_WINPID, pid);
1886
1887 if (pid > 0)
1888 ok = DebugActiveProcess (pid);
10325bc5
PA		 1889 }
1890#endif
baa93fa6 1891
10325bc5
PA		 1892 if (!ok)
1893 error (_("Can't attach to process."));
24e60978 1894
2b008701 1895 DebugSetProcessKillOnExit (FALSE);
3ade5333 1896
24e60978
SC		 1897 if (from_tty)
1898 {
1899 char *exec_file = (char *) get_exec_file (0);
1900
1901 if (exec_file)
1902 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
39f77062 1903 target_pid_to_str (pid_to_ptid (pid)));
24e60978
SC		 1904 else
1905 printf_unfiltered ("Attaching to %s\n",
39f77062 1906 target_pid_to_str (pid_to_ptid (pid)));
24e60978
SC		 1907
1908 gdb_flush (gdb_stdout);
1909 }
1910
dc05df57 1911 do_initial_windows_stuff (ops, pid, 1);
9d3789f7 1912 target_terminal_ours ();
24e60978
SC		 1913}
1914
24e60978 1915static void
52554a0e 1916windows_detach (struct target_ops *ops, const char *args, int from_tty)
24e60978 1917{
02cc9f49
CV		 1918 int detached = 1;
1919
2b008701 1920 ptid_t ptid = {-1};
a493e3e2 1921 windows_resume (ops, ptid, 0, GDB_SIGNAL_0);
96998ce7 1922
2b008701
CF		 1923 if (!DebugActiveProcessStop (current_event.dwProcessId))
1924 {
d50a0ce2
CV		 1925 error (_("Can't detach process %u (error %u)"),
1926 (unsigned) current_event.dwProcessId, (unsigned) GetLastError ());
2b008701 1927 detached = 0;
02cc9f49 1928 }
2b008701
CF		 1929 DebugSetProcessKillOnExit (FALSE);
1930
02cc9f49 1931 if (detached && from_tty)
24e60978
SC		 1932 {
1933 char *exec_file = get_exec_file (0);
1934 if (exec_file == 0)
1935 exec_file = "";
d50a0ce2
CV		 1936 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file,
1937 (unsigned) current_event.dwProcessId);
24e60978
SC		 1938 gdb_flush (gdb_stdout);
1939 }
7f9f62ba 1940
df7e5265 1941 x86_cleanup_dregs ();
39f77062 1942 inferior_ptid = null_ptid;
7f9f62ba
PA		 1943 detach_inferior (current_event.dwProcessId);
1944
6a3cb8e8 1945 inf_child_maybe_unpush_target (ops);
24e60978
SC		 1946}
1947
47f7ffdb
JB		 1948/* Try to determine the executable filename.
1949
1950 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
1951
1952 Upon success, the filename is stored inside EXE_NAME_RET, and
1953 this function returns nonzero.
1954
1955 Otherwise, this function returns zero and the contents of
1956 EXE_NAME_RET is undefined. */
1957
1958static int
1959windows_get_exec_module_filename (char *exe_name_ret, size_t exe_name_max_len)
1960{
1961 DWORD len;
1962 HMODULE dh_buf;
1963 DWORD cbNeeded;
1964
1965 cbNeeded = 0;
1966 if (!EnumProcessModules (current_process_handle, &dh_buf,
1967 sizeof (HMODULE), &cbNeeded) || !cbNeeded)
1968 return 0;
1969
1970 /* We know the executable is always first in the list of modules,
1971 which we just fetched. So no need to fetch more. */
1972
1973#ifdef __CYGWIN__
1974 {
1975 /* Cygwin prefers that the path be in /x/y/z format, so extract
1976 the filename into a temporary buffer first, and then convert it
1977 to POSIX format into the destination buffer. */
0ae534d2 1978 cygwin_buf_t *pathbuf = (cygwin_buf_t *) alloca (exe_name_max_len * sizeof (cygwin_buf_t));
47f7ffdb
JB		 1979
1980 len = GetModuleFileNameEx (current_process_handle,
1981 dh_buf, pathbuf, exe_name_max_len);
1982 if (len == 0)
1983 error (_("Error getting executable filename: %u."),
1984 (unsigned) GetLastError ());
1985 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX, pathbuf, exe_name_ret,
1986 exe_name_max_len) < 0)
1987 error (_("Error converting executable filename to POSIX: %d."), errno);
1988 }
1989#else
1990 len = GetModuleFileNameEx (current_process_handle,
1991 dh_buf, exe_name_ret, exe_name_max_len);
1992 if (len == 0)
1993 error (_("Error getting executable filename: %u."),
1994 (unsigned) GetLastError ());
1995#endif
1996
1997 return 1; /* success */
1998}
1999
2000/* The pid_to_exec_file target_ops method for this platform. */
2001
3ee6f623 2002static char *
8dd27370 2003windows_pid_to_exec_file (struct target_ops *self, int pid)
47216e51 2004{
b3c613f2 2005 static char path[__PMAX];
10325bc5 2006#ifdef __CYGWIN__
581e13c1 2007 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
33605d39
CF		 2008 int nchars;
2009 char procexe[sizeof ("/proc/4294967295/exe")];
08850b56
PM		 2010
2011 xsnprintf (procexe, sizeof (procexe), "/proc/%u/exe", pid);
33605d39
CF		 2012 nchars = readlink (procexe, path, sizeof(path));
2013 if (nchars > 0 && nchars < sizeof (path))
47216e51 2014 {
33605d39
CF		 2015 path[nchars] = '\0'; /* Got it */
2016 return path;
47216e51 2017 }
10325bc5
PA		 2018#endif
2019
33605d39 2020 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
581e13c1 2021 of gdb, or we're trying to debug a non-Cygwin windows executable. */
47f7ffdb 2022 if (!windows_get_exec_module_filename (path, sizeof (path)))
33605d39
CF		 2023 path[0] = '\0';
2024
2025 return path;
47216e51
CV		 2026}
2027
24e60978
SC		 2028/* Print status information about what we're accessing. */
2029
2030static void
dc05df57 2031windows_files_info (struct target_ops *ignore)
24e60978 2032{
181e7f93
PA		 2033 struct inferior *inf = current_inferior ();
2034
24e60978 2035 printf_unfiltered ("\tUsing the running image of %s %s.\n",
181e7f93
PA		 2036 inf->attach_flag ? "attached" : "child",
2037 target_pid_to_str (inferior_ptid));
24e60978
SC		 2038}
2039
cd44747c
PM		 2040/* Modify CreateProcess parameters for use of a new separate console.
2041 Parameters are:
2042 *FLAGS: DWORD parameter for general process creation flags.
2043 *SI: STARTUPINFO structure, for which the console window size and
2044 console buffer size is filled in if GDB is running in a console.
2045 to create the new console.
2046 The size of the used font is not available on all versions of
2047 Windows OS. Furthermore, the current font might not be the default
2048 font, but this is still better than before.
2049 If the windows and buffer sizes are computed,
2050 SI->DWFLAGS is changed so that this information is used
2051 by CreateProcess function. */
2052
2053static void
2054windows_set_console_info (STARTUPINFO *si, DWORD *flags)
2055{
2056 HANDLE hconsole = CreateFile ("CONOUT$", GENERIC_READ | GENERIC_WRITE,
2057 FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
2058
2059 if (hconsole != INVALID_HANDLE_VALUE)
2060 {
2061 CONSOLE_SCREEN_BUFFER_INFO sbinfo;
2062 COORD font_size;
2063 CONSOLE_FONT_INFO cfi;
2064
2065 GetCurrentConsoleFont (hconsole, FALSE, &cfi);
2066 font_size = GetConsoleFontSize (hconsole, cfi.nFont);
2067 GetConsoleScreenBufferInfo(hconsole, &sbinfo);
2068 si->dwXSize = sbinfo.srWindow.Right - sbinfo.srWindow.Left + 1;
2069 si->dwYSize = sbinfo.srWindow.Bottom - sbinfo.srWindow.Top + 1;
2070 if (font_size.X)
2071 si->dwXSize *= font_size.X;
2072 else
2073 si->dwXSize *= 8;
2074 if (font_size.Y)
2075 si->dwYSize *= font_size.Y;
2076 else
2077 si->dwYSize *= 12;
2078 si->dwXCountChars = sbinfo.dwSize.X;
2079 si->dwYCountChars = sbinfo.dwSize.Y;
2080 si->dwFlags |= STARTF_USESIZE | STARTF_USECOUNTCHARS;
2081 }
2082 *flags |= CREATE_NEW_CONSOLE;
2083}
2084
c93dbcba
EZ		 2085#ifndef __CYGWIN__
2086/* Function called by qsort to sort environment strings. */
2087
2088static int
2089envvar_cmp (const void *a, const void *b)
2090{
2091 const char **p = (const char **) a;
2092 const char **q = (const char **) b;
2093 return strcasecmp (*p, *q);
2094}
2095#endif
2096
b7ff339d
CV		 2097#ifdef __CYGWIN__
2098static void
2099clear_win32_environment (char **env)
2100{
2101 int i;
2102 size_t len;
2103 wchar_t *copy = NULL, *equalpos;
2104
2105 for (i = 0; env[i] && *env[i]; i++)
2106 {
2107 len = mbstowcs (NULL, env[i], 0) + 1;
2108 copy = (wchar_t *) xrealloc (copy, len * sizeof (wchar_t));
2109 mbstowcs (copy, env[i], len);
2110 equalpos = wcschr (copy, L'=');
2111 if (equalpos)
2112 *equalpos = L'\0';
2113 SetEnvironmentVariableW (copy, NULL);
2114 }
2115 xfree (copy);
2116}
2117#endif
2118
dc05df57 2119/* Start an inferior windows child process and sets inferior_ptid to its pid.
24e60978
SC		 2120 EXEC_FILE is the file to run.
2121 ALLARGS is a string containing the arguments to the program.
2122 ENV is the environment vector to pass. Errors reported with error(). */
2123
24e60978 2124static void
dc05df57 2125windows_create_inferior (struct target_ops *ops, char *exec_file,
136d6dae 2126 char *allargs, char **in_env, int from_tty)
24e60978 2127{
b3c613f2 2128 STARTUPINFO si;
41b4aadc 2129#ifdef __CYGWIN__
b3c613f2
CF		 2130 cygwin_buf_t real_path[__PMAX];
2131 cygwin_buf_t shell[__PMAX]; /* Path to shell */
d0d0ab16 2132 const char *sh;
b3c613f2
CF		 2133 cygwin_buf_t *toexec;
2134 cygwin_buf_t *cygallargs;
2135 cygwin_buf_t *args;
b7ff339d
CV		 2136 char **old_env = NULL;
2137 PWCHAR w32_env;
d0d0ab16 2138 size_t len;
2becadee
CF		 2139 int tty;
2140 int ostdin, ostdout, ostderr;
41b4aadc 2141#else
b3c613f2
CF		 2142 char real_path[__PMAX];
2143 char shell[__PMAX]; /* Path to shell */
d0d0ab16
CV		 2144 char *toexec;
2145 char *args;
8f205f9c 2146 size_t args_len;
41b4aadc 2147 HANDLE tty;
c93dbcba
EZ		 2148 char *w32env;
2149 char *temp;
2150 size_t envlen;
2151 int i;
2152 size_t envsize;
2153 char **env;
41b4aadc 2154#endif
d0d0ab16
CV		 2155 PROCESS_INFORMATION pi;
2156 BOOL ret;
2157 DWORD flags = 0;
3cb3b8df 2158 const char *inferior_io_terminal = get_inferior_io_terminal ();
24e60978
SC		 2159
2160 if (!exec_file)
8a3fe4f8 2161 error (_("No executable specified, use `target exec'."));
24e60978
SC		 2162
2163 memset (&si, 0, sizeof (si));
2164 si.cb = sizeof (si);
2165
d0d0ab16
CV		 2166 if (new_group)
2167 flags |= CREATE_NEW_PROCESS_GROUP;
2168
2169 if (new_console)
cd44747c 2170 windows_set_console_info (&si, &flags);
d0d0ab16 2171
10325bc5 2172#ifdef __CYGWIN__
349b409f 2173 if (!useshell)
dfe7f3ac 2174 {
d0d0ab16
CV		 2175 flags |= DEBUG_ONLY_THIS_PROCESS;
2176 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W, exec_file, real_path,
b3c613f2 2177 __PMAX * sizeof (cygwin_buf_t)) < 0)
d0d0ab16 2178 error (_("Error starting executable: %d"), errno);
dfe7f3ac 2179 toexec = real_path;
b3c613f2 2180#ifdef __USEWIDE
d0d0ab16
CV		 2181 len = mbstowcs (NULL, allargs, 0) + 1;
2182 if (len == (size_t) -1)
2183 error (_("Error starting executable: %d"), errno);
2184 cygallargs = (wchar_t *) alloca (len * sizeof (wchar_t));
2185 mbstowcs (cygallargs, allargs, len);
60c5c021
CF		 2186#else
2187 cygallargs = allargs;
b3c613f2 2188#endif
dfe7f3ac
CF		 2189 }
2190 else
2191 {
349b409f
CF		 2192 sh = getenv ("SHELL");
2193 if (!sh)
2194 sh = "/bin/sh";
b3c613f2 2195 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W, sh, shell, __PMAX) < 0)
d0d0ab16 2196 error (_("Error starting executable via shell: %d"), errno);
b3c613f2 2197#ifdef __USEWIDE
d0d0ab16
CV		 2198 len = sizeof (L" -c 'exec '") + mbstowcs (NULL, exec_file, 0)
2199 + mbstowcs (NULL, allargs, 0) + 2;
2200 cygallargs = (wchar_t *) alloca (len * sizeof (wchar_t));
2201 swprintf (cygallargs, len, L" -c 'exec %s %s'", exec_file, allargs);
b3c613f2 2202#else
08850b56
PM		 2203 len = (sizeof (" -c 'exec '") + strlen (exec_file)
2204 + strlen (allargs) + 2);
2205 cygallargs = (char *) alloca (len);
2206 xsnprintf (cygallargs, len, " -c 'exec %s %s'", exec_file, allargs);
b3c613f2 2207#endif
dfe7f3ac 2208 toexec = shell;
d0d0ab16 2209 flags |= DEBUG_PROCESS;
dfe7f3ac 2210 }
b3c613f2
CF		 2211
2212#ifdef __USEWIDE
2213 args = (cygwin_buf_t *) alloca ((wcslen (toexec) + wcslen (cygallargs) + 2)
2214 * sizeof (wchar_t));
d0d0ab16
CV		 2215 wcscpy (args, toexec);
2216 wcscat (args, L" ");
2217 wcscat (args, cygallargs);
b3c613f2
CF		 2218#else
2219 args = (cygwin_buf_t *) alloca (strlen (toexec) + strlen (cygallargs) + 2);
2220 strcpy (args, toexec);
2221 strcat (args, " ");
2222 strcat (args, cygallargs);
2223#endif
2224
b7ff339d
CV		 2225#ifdef CW_CVT_ENV_TO_WINENV
2226 /* First try to create a direct Win32 copy of the POSIX environment. */
2227 w32_env = (PWCHAR) cygwin_internal (CW_CVT_ENV_TO_WINENV, in_env);
2228 if (w32_env != (PWCHAR) -1)
2229 flags |= CREATE_UNICODE_ENVIRONMENT;
2230 else
2231 /* If that fails, fall back to old method tweaking GDB's environment. */
2232#endif
2233 {
2234 /* Reset all Win32 environment variables to avoid leftover on next run. */
2235 clear_win32_environment (environ);
2236 /* Prepare the environment vars for CreateProcess. */
2237 old_env = environ;
2238 environ = in_env;
2239 cygwin_internal (CW_SYNC_WINENV);
2240 w32_env = NULL;
2241 }
1750a5ef 2242
2becadee
CF		 2243 if (!inferior_io_terminal)
2244 tty = ostdin = ostdout = ostderr = -1;
2245 else
2246 {
2247 tty = open (inferior_io_terminal, O_RDWR | O_NOCTTY);
2248 if (tty < 0)
2249 {
2250 print_sys_errmsg (inferior_io_terminal, errno);
2251 ostdin = ostdout = ostderr = -1;
2252 }
2253 else
2254 {
2255 ostdin = dup (0);
2256 ostdout = dup (1);
2257 ostderr = dup (2);
2258 dup2 (tty, 0);
2259 dup2 (tty, 1);
2260 dup2 (tty, 2);
2261 }
2262 }
d0d0ab16
CV		 2263
2264 windows_init_thread_list ();
b3c613f2
CF		 2265 ret = CreateProcess (0,
2266 args, /* command line */
2267 NULL, /* Security */
2268 NULL, /* thread */
2269 TRUE, /* inherit handles */
2270 flags, /* start flags */
b7ff339d 2271 w32_env, /* environment */
b3c613f2
CF		 2272 NULL, /* current directory */
2273 &si,
2274 &pi);
b7ff339d
CV		 2275 if (w32_env)
2276 /* Just free the Win32 environment, if it could be created. */
2277 free (w32_env);
2278 else
2279 {
2280 /* Reset all environment variables to avoid leftover on next run. */
2281 clear_win32_environment (in_env);
2282 /* Restore normal GDB environment variables. */
2283 environ = old_env;
2284 cygwin_internal (CW_SYNC_WINENV);
2285 }
2286
d0d0ab16
CV		 2287 if (tty >= 0)
2288 {
2289 close (tty);
2290 dup2 (ostdin, 0);
2291 dup2 (ostdout, 1);
2292 dup2 (ostderr, 2);
2293 close (ostdin);
2294 close (ostdout);
2295 close (ostderr);
2296 }
41b4aadc 2297#else
b3c613f2 2298 toexec = exec_file;
8f205f9c
JB		 2299 /* Build the command line, a space-separated list of tokens where
2300 the first token is the name of the module to be executed.
2301 To avoid ambiguities introduced by spaces in the module name,
2302 we quote it. */
2303 args_len = strlen (toexec) + 2 /* quotes */ + strlen (allargs) + 2;
0ae1c716 2304 args = (char *) alloca (args_len);
8f205f9c 2305 xsnprintf (args, args_len, "\"%s\" %s", toexec, allargs);
d0d0ab16 2306
d0d0ab16
CV		 2307 flags |= DEBUG_ONLY_THIS_PROCESS;
2308
41b4aadc
CF		 2309 if (!inferior_io_terminal)
2310 tty = INVALID_HANDLE_VALUE;
2311 else
2312 {
2313 SECURITY_ATTRIBUTES sa;
2314 sa.nLength = sizeof(sa);
2315 sa.lpSecurityDescriptor = 0;
2316 sa.bInheritHandle = TRUE;
2317 tty = CreateFileA (inferior_io_terminal, GENERIC_READ | GENERIC_WRITE,
2318 0, &sa, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
2319 if (tty == INVALID_HANDLE_VALUE)
2320 warning (_("Warning: Failed to open TTY %s, error %#x."),
2321 inferior_io_terminal, (unsigned) GetLastError ());
2322 else
2323 {
2324 si.hStdInput = tty;
2325 si.hStdOutput = tty;
2326 si.hStdError = tty;
2327 si.dwFlags |= STARTF_USESTDHANDLES;
2328 }
2329 }
2becadee 2330
c93dbcba
EZ		 2331 /* CreateProcess takes the environment list as a null terminated set of
2332 strings (i.e. two nulls terminate the list). */
2333
2334 /* Get total size for env strings. */
2335 for (envlen = 0, i = 0; in_env[i] && *in_env[i]; i++)
2336 envlen += strlen (in_env[i]) + 1;
2337
2338 envsize = sizeof (in_env[0]) * (i + 1);
2339 env = (char **) alloca (envsize);
2340 memcpy (env, in_env, envsize);
2341 /* Windows programs expect the environment block to be sorted. */
2342 qsort (env, i, sizeof (char *), envvar_cmp);
2343
0ae1c716 2344 w32env = (char *) alloca (envlen + 1);
c93dbcba
EZ		 2345
2346 /* Copy env strings into new buffer. */
2347 for (temp = w32env, i = 0; env[i] && *env[i]; i++)
2348 {
2349 strcpy (temp, env[i]);
2350 temp += strlen (temp) + 1;
2351 }
2352
2353 /* Final nil string to terminate new env. */
2354 *temp = 0;
2355
dc05df57 2356 windows_init_thread_list ();
d0d0ab16
CV		 2357 ret = CreateProcessA (0,
2358 args, /* command line */
2359 NULL, /* Security */
2360 NULL, /* thread */
2361 TRUE, /* inherit handles */
2362 flags, /* start flags */
c93dbcba 2363 w32env, /* environment */
d0d0ab16
CV		 2364 NULL, /* current directory */
2365 &si,
2366 &pi);
41b4aadc
CF		 2367 if (tty != INVALID_HANDLE_VALUE)
2368 CloseHandle (tty);
10325bc5 2369#endif
2becadee 2370
24e60978 2371 if (!ret)
d50a0ce2 2372 error (_("Error creating process %s, (error %u)."),
8a3fe4f8 2373 exec_file, (unsigned) GetLastError ());
24e60978 2374
c1766e7d
PM		 2375 CloseHandle (pi.hThread);
2376 CloseHandle (pi.hProcess);
2377
dfe7f3ac
CF		 2378 if (useshell && shell[0] != '\0')
2379 saw_create = -1;
2380 else
2381 saw_create = 0;
2382
dc05df57 2383 do_initial_windows_stuff (ops, pi.dwProcessId, 0);
d3a09475 2384
17617f2d 2385 /* windows_continue (DBG_CONTINUE, -1, 0); */
24e60978
SC		 2386}
2387
2388static void
dc05df57 2389windows_mourn_inferior (struct target_ops *ops)
24e60978 2390{
17617f2d 2391 (void) windows_continue (DBG_CONTINUE, -1, 0);
df7e5265 2392 x86_cleanup_dregs();
bf25528d
CF		 2393 if (open_process_used)
2394 {
2395 CHECK (CloseHandle (current_process_handle));
2396 open_process_used = 0;
2397 }
c1ee2fb3 2398 inf_child_mourn_inferior (ops);
24e60978
SC		 2399}
2400
24e60978 2401/* Send a SIGINT to the process group. This acts just like the user typed a
581e13c1 2402 ^C on the controlling terminal. */
24e60978 2403
b607efe7 2404static void
bfedc46a 2405windows_interrupt (struct target_ops *self, ptid_t ptid)
24e60978 2406{
1ef980b9 2407 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
1e37c281 2408 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, current_event.dwProcessId));
3a4b77d8 2409 registers_changed (); /* refresh register state */
24e60978
SC		 2410}
2411
44f38867
PA		 2412/* Helper for windows_xfer_partial that handles memory transfers.
2413 Arguments are like target_xfer_partial. */
2414
9b409511 2415static enum target_xfer_status
44f38867 2416windows_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf,
9b409511 2417 ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
24e60978 2418{
5732a500 2419 SIZE_T done = 0;
44f38867 2420 BOOL success;
9e52adf9 2421 DWORD lasterror = 0;
44f38867
PA		 2422
2423 if (writebuf != NULL)
24e60978 2424 {
a2388568 2425 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
b55e14c7 2426 pulongest (len), core_addr_to_string (memaddr)));
44f38867
PA		 2427 success = WriteProcessMemory (current_process_handle,
2428 (LPVOID) (uintptr_t) memaddr, writebuf,
2429 len, &done);
9e52adf9 2430 if (!success)
7126d5c8 2431 lasterror = GetLastError ();
2b008701 2432 FlushInstructionCache (current_process_handle,
2c647436 2433 (LPCVOID) (uintptr_t) memaddr, len);
24e60978
SC		 2434 }
2435 else
2436 {
a2388568 2437 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
b55e14c7 2438 pulongest (len), core_addr_to_string (memaddr)));
44f38867
PA		 2439 success = ReadProcessMemory (current_process_handle,
2440 (LPCVOID) (uintptr_t) memaddr, readbuf,
2441 len, &done);
9e52adf9 2442 if (!success)
7126d5c8 2443 lasterror = GetLastError ();
24e60978 2444 }
9b409511 2445 *xfered_len = (ULONGEST) done;
9e52adf9 2446 if (!success && lasterror == ERROR_PARTIAL_COPY && done > 0)
9b409511 2447 return TARGET_XFER_OK;
9e52adf9 2448 else
9b409511 2449 return success ? TARGET_XFER_OK : TARGET_XFER_E_IO;
24e60978
SC		 2450}
2451
3ee6f623 2452static void
7d85a9c0 2453windows_kill_inferior (struct target_ops *ops)
24e60978 2454{
3cee93ac
CF		 2455 CHECK (TerminateProcess (current_process_handle, 0));
2456
b5edcb45
ILT		 2457 for (;;)
2458 {
17617f2d 2459 if (!windows_continue (DBG_CONTINUE, -1, 1))
b5edcb45 2460 break;
3cee93ac 2461 if (!WaitForDebugEvent (&current_event, INFINITE))
b5edcb45 2462 break;
3cee93ac 2463 if (current_event.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT)
b5edcb45
ILT		 2464 break;
2465 }
2466
581e13c1 2467 target_mourn_inferior (); /* Or just windows_mourn_inferior? */
24e60978
SC		 2468}
2469
24e60978 2470static void
de90e03d 2471windows_close (struct target_ops *self)
24e60978 2472{
dc05df57 2473 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
dfd4cc63 2474 ptid_get_pid (inferior_ptid)));
24e60978 2475}
1ef980b9 2476
581e13c1 2477/* Convert pid to printable format. */
3ee6f623 2478static char *
117de6a9 2479windows_pid_to_str (struct target_ops *ops, ptid_t ptid)
24e60978 2480{
3ee6f623 2481 static char buf[80];
3ee6f623 2482
2dc38344
PA		 2483 if (ptid_get_tid (ptid) != 0)
2484 {
2485 snprintf (buf, sizeof (buf), "Thread %d.0x%lx",
2486 ptid_get_pid (ptid), ptid_get_tid (ptid));
2487 return buf;
2488 }
2489
2490 return normal_pid_to_str (ptid);
3ee6f623
CF		 2491}
2492
9b409511 2493static enum target_xfer_status
dc05df57 2494windows_xfer_shared_libraries (struct target_ops *ops,
9b409511
YQ		 2495 enum target_object object, const char *annex,
2496 gdb_byte *readbuf, const gdb_byte *writebuf,
2497 ULONGEST offset, ULONGEST len,
2498 ULONGEST *xfered_len)
3cb8e7f6 2499{
de1b3c3d
PA		 2500 struct obstack obstack;
2501 const char *buf;
2502 LONGEST len_avail;
3cb8e7f6 2503 struct so_list *so;
3cb8e7f6 2504
de1b3c3d 2505 if (writebuf)
2ed4b548 2506 return TARGET_XFER_E_IO;
3cb8e7f6 2507
de1b3c3d
PA		 2508 obstack_init (&obstack);
2509 obstack_grow_str (&obstack, "<library-list>\n");
2510 for (so = solib_start.next; so; so = so->next)
581e13c1
MS		 2511 windows_xfer_shared_library (so->so_name, (CORE_ADDR)
2512 (uintptr_t) so->lm_info->load_addr,
f5656ead 2513 target_gdbarch (), &obstack);
de1b3c3d 2514 obstack_grow_str0 (&obstack, "</library-list>\n");
3cb8e7f6 2515
0ae1c716 2516 buf = (const char *) obstack_finish (&obstack);
de1b3c3d
PA		 2517 len_avail = strlen (buf);
2518 if (offset >= len_avail)
49dc7f4b
PM		 2519 len= 0;
2520 else
2521 {
2522 if (len > len_avail - offset)
2523 len = len_avail - offset;
2524 memcpy (readbuf, buf + offset, len);
2525 }
3cb8e7f6 2526
de1b3c3d 2527 obstack_free (&obstack, NULL);
9b409511 2528 *xfered_len = (ULONGEST) len;
0837c976 2529 return len != 0 ? TARGET_XFER_OK : TARGET_XFER_EOF;
3cb8e7f6
CF		 2530}
2531
9b409511 2532static enum target_xfer_status
dc05df57 2533windows_xfer_partial (struct target_ops *ops, enum target_object object,
9b409511
YQ		 2534 const char *annex, gdb_byte *readbuf,
2535 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
2536 ULONGEST *xfered_len)
3cb8e7f6 2537{
de1b3c3d 2538 switch (object)
3cb8e7f6 2539 {
de1b3c3d 2540 case TARGET_OBJECT_MEMORY:
9b409511 2541 return windows_xfer_memory (readbuf, writebuf, offset, len, xfered_len);
de1b3c3d
PA		 2542
2543 case TARGET_OBJECT_LIBRARIES:
dc05df57 2544 return windows_xfer_shared_libraries (ops, object, annex, readbuf,
9b409511 2545 writebuf, offset, len, xfered_len);
3929abe9 2546
de1b3c3d 2547 default:
e75fdfca
TT		 2548 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
2549 readbuf, writebuf, offset, len,
2550 xfered_len);
3929abe9 2551 }
02c5aecd
CF		 2552}
2553
711e434b
PM		 2554/* Provide thread local base, i.e. Thread Information Block address.
2555 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
2556
2557static int
bd7ae0f5
TT		 2558windows_get_tib_address (struct target_ops *self,
2559 ptid_t ptid, CORE_ADDR *addr)
711e434b 2560{
876d1cd7 2561 windows_thread_info *th;
711e434b
PM		 2562
2563 th = thread_rec (ptid_get_tid (ptid), 0);
2564 if (th == NULL)
2565 return 0;
2566
2567 if (addr != NULL)
2568 *addr = th->thread_local_base;
2569
2570 return 1;
2571}
2572
1e2f1c5c 2573static ptid_t
1e6b91a4 2574windows_get_ada_task_ptid (struct target_ops *self, long lwp, long thread)
1e2f1c5c
JB		 2575{
2576 return ptid_build (ptid_get_pid (inferior_ptid), 0, lwp);
2577}
2578
24cdb46e
РИ		 2579/* Implementation of the to_thread_name method. */
2580
2581static const char *
2582windows_thread_name (struct target_ops *self, struct thread_info *thr)
2583{
2584 return thread_rec (ptid_get_tid (thr->ptid), 0)->name;
2585}
2586
51a9c8c5
PA		 2587static struct target_ops *
2588windows_target (void)
3ee6f623 2589{
51a9c8c5
PA		 2590 struct target_ops *t = inf_child_target ();
2591
51a9c8c5
PA		 2592 t->to_close = windows_close;
2593 t->to_attach = windows_attach;
2594 t->to_attach_no_wait = 1;
2595 t->to_detach = windows_detach;
2596 t->to_resume = windows_resume;
2597 t->to_wait = windows_wait;
2598 t->to_fetch_registers = windows_fetch_inferior_registers;
2599 t->to_store_registers = windows_store_inferior_registers;
2600 t->to_xfer_partial = windows_xfer_partial;
2601 t->to_files_info = windows_files_info;
2602 t->to_kill = windows_kill_inferior;
2603 t->to_create_inferior = windows_create_inferior;
2604 t->to_mourn_inferior = windows_mourn_inferior;
2605 t->to_thread_alive = windows_thread_alive;
2606 t->to_pid_to_str = windows_pid_to_str;
bfedc46a 2607 t->to_interrupt = windows_interrupt;
51a9c8c5
PA		 2608 t->to_pid_to_exec_file = windows_pid_to_exec_file;
2609 t->to_get_ada_task_ptid = windows_get_ada_task_ptid;
2610 t->to_get_tib_address = windows_get_tib_address;
24cdb46e 2611 t->to_thread_name = windows_thread_name;
51a9c8c5
PA		 2612
2613 return t;
c719b714 2614}
24e60978 2615
d603d4b3
JK		 2616/* -Wmissing-prototypes */
2617extern initialize_file_ftype _initialize_windows_nat;
2618
24e60978 2619void
dc05df57 2620_initialize_windows_nat (void)
24e60978 2621{
51a9c8c5
PA		 2622 struct target_ops *t;
2623
2624 t = windows_target ();
2625
df7e5265 2626 x86_use_watchpoints (t);
51a9c8c5 2627
df7e5265
GB		 2628 x86_dr_low.set_control = cygwin_set_dr7;
2629 x86_dr_low.set_addr = cygwin_set_dr;
2630 x86_dr_low.get_addr = cygwin_get_dr;
2631 x86_dr_low.get_status = cygwin_get_dr6;
2632 x86_dr_low.get_control = cygwin_get_dr7;
51a9c8c5 2633
df7e5265
GB		 2634 /* x86_dr_low.debug_register_length field is set by
2635 calling x86_set_debug_register_length function
51a9c8c5 2636 in processor windows specific native file. */
fa58ee11 2637
51a9c8c5 2638 add_target (t);
1ef980b9 2639
d0d0ab16
CV		 2640#ifdef __CYGWIN__
2641 cygwin_internal (CW_SET_DOS_FILE_WARNING, 0);
2642#endif
2643
463888ab
РИ		 2644 add_com ("signal-event", class_run, signal_event_command, _("\
2645Signal a crashed process with event ID, to allow its debugging.\n\
2646This command is needed in support of setting up GDB as JIT debugger on \
2647MS-Windows. The command should be invoked from the GDB command line using \
2648the '-ex' command-line option. The ID of the event that blocks the \
2649crashed process will be supplied by the Windows JIT debugging mechanism."));
2650
10325bc5 2651#ifdef __CYGWIN__
5bf193a2
AC		 2652 add_setshow_boolean_cmd ("shell", class_support, &useshell, _("\
2653Set use of shell to start subprocess."), _("\
2654Show use of shell to start subprocess."), NULL,
2655 NULL,
2656 NULL, /* FIXME: i18n: */
2657 &setlist, &showlist);
2658
581e13c1
MS		 2659 add_setshow_boolean_cmd ("cygwin-exceptions", class_support,
2660 &cygwin_exceptions, _("\
09280ddf
CF		 2661Break when an exception is detected in the Cygwin DLL itself."), _("\
2662Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL,
2663 NULL,
2664 NULL, /* FIXME: i18n: */
2665 &setlist, &showlist);
10325bc5 2666#endif
09280ddf 2667
5bf193a2
AC		 2668 add_setshow_boolean_cmd ("new-console", class_support, &new_console, _("\
2669Set creation of new console when creating child process."), _("\
2670Show creation of new console when creating child process."), NULL,
2671 NULL,
2672 NULL, /* FIXME: i18n: */
2673 &setlist, &showlist);
2674
2675 add_setshow_boolean_cmd ("new-group", class_support, &new_group, _("\
2676Set creation of new group when creating child process."), _("\
2677Show creation of new group when creating child process."), NULL,
2678 NULL,
2679 NULL, /* FIXME: i18n: */
2680 &setlist, &showlist);
2681
2682 add_setshow_boolean_cmd ("debugexec", class_support, &debug_exec, _("\
2683Set whether to display execution in child process."), _("\
2684Show whether to display execution in child process."), NULL,
2685 NULL,
2686 NULL, /* FIXME: i18n: */
2687 &setlist, &showlist);
2688
2689 add_setshow_boolean_cmd ("debugevents", class_support, &debug_events, _("\
2690Set whether to display kernel events in child process."), _("\
2691Show whether to display kernel events in child process."), NULL,
2692 NULL,
2693 NULL, /* FIXME: i18n: */
2694 &setlist, &showlist);
2695
2696 add_setshow_boolean_cmd ("debugmemory", class_support, &debug_memory, _("\
2697Set whether to display memory accesses in child process."), _("\
2698Show whether to display memory accesses in child process."), NULL,
2699 NULL,
2700 NULL, /* FIXME: i18n: */
2701 &setlist, &showlist);
2702
2703 add_setshow_boolean_cmd ("debugexceptions", class_support,
2704 &debug_exceptions, _("\
2705Set whether to display kernel exceptions in child process."), _("\
2706Show whether to display kernel exceptions in child process."), NULL,
2707 NULL,
2708 NULL, /* FIXME: i18n: */
2709 &setlist, &showlist);
1ef980b9 2710
711e434b 2711 init_w32_command_list ();
c1748f97
PM		 2712
2713 add_cmd ("selector", class_info, display_selectors,
1a966eab 2714 _("Display selectors infos."),
c1748f97 2715 &info_w32_cmdlist);
24e60978 2716}
3cee93ac 2717
fa4ba8da
PM		 2718/* Hardware watchpoint support, adapted from go32-nat.c code. */
2719
2720/* Pass the address ADDR to the inferior in the I'th debug register.
2721 Here we just store the address in dr array, the registers will be
dc05df57 2722 actually set up when windows_continue is called. */
9bb9e8ad 2723static void
fa4ba8da
PM		 2724cygwin_set_dr (int i, CORE_ADDR addr)
2725{
2726 if (i < 0 || i > 3)
2727 internal_error (__FILE__, __LINE__,
e2e0b3e5 2728 _("Invalid register %d in cygwin_set_dr.\n"), i);
41b4aadc 2729 dr[i] = addr;
fa4ba8da
PM		 2730 debug_registers_changed = 1;
2731 debug_registers_used = 1;
2732}
2733
2734/* Pass the value VAL to the inferior in the DR7 debug control
2735 register. Here we just store the address in D_REGS, the watchpoint
dc05df57 2736 will be actually set up in windows_wait. */
9bb9e8ad
PM		 2737static void
2738cygwin_set_dr7 (unsigned long val)
fa4ba8da 2739{
9bb9e8ad 2740 dr[7] = (CORE_ADDR) val;
fa4ba8da
PM		 2741 debug_registers_changed = 1;
2742 debug_registers_used = 1;
2743}
2744
7b50312a
PA		 2745/* Get the value of debug register I from the inferior. */
2746
2747static CORE_ADDR
2748cygwin_get_dr (int i)
2749{
2750 return dr[i];
2751}
2752
fa4ba8da
PM		 2753/* Get the value of the DR6 debug status register from the inferior.
2754 Here we just return the value stored in dr[6]
2755 by the last call to thread_rec for current_event.dwThreadId id. */
9bb9e8ad 2756static unsigned long
fa4ba8da
PM		 2757cygwin_get_dr6 (void)
2758{
9bb9e8ad 2759 return (unsigned long) dr[6];
fa4ba8da
PM		 2760}
2761
7b50312a
PA		 2762/* Get the value of the DR7 debug status register from the inferior.
2763 Here we just return the value stored in dr[7] by the last call to
2764 thread_rec for current_event.dwThreadId id. */
2765
2766static unsigned long
2767cygwin_get_dr7 (void)
2768{
2769 return (unsigned long) dr[7];
2770}
2771
2dc38344 2772/* Determine if the thread referenced by "ptid" is alive
3cee93ac 2773 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
581e13c1 2774 it means that the thread has died. Otherwise it is assumed to be alive. */
3cee93ac 2775static int
28439f5e 2776windows_thread_alive (struct target_ops *ops, ptid_t ptid)
3cee93ac 2777{
2dc38344
PA		 2778 int tid;
2779
2780 gdb_assert (ptid_get_tid (ptid) != 0);
2781 tid = ptid_get_tid (ptid);
39f77062 2782
581e13c1
MS		 2783 return WaitForSingleObject (thread_rec (tid, FALSE)->h, 0) == WAIT_OBJECT_0
2784 ? FALSE : TRUE;
3cee93ac
CF		 2785}
2786
d603d4b3
JK		 2787/* -Wmissing-prototypes */
2788extern initialize_file_ftype _initialize_check_for_gdb_ini;
2789
2a3d5645
CF		 2790void
2791_initialize_check_for_gdb_ini (void)
2792{
2793 char *homedir;
2794 if (inhibit_gdbinit)
2795 return;
2796
2797 homedir = getenv ("HOME");
2798 if (homedir)
2799 {
2800 char *p;
2801 char *oldini = (char *) alloca (strlen (homedir) +
1270fac6 2802 sizeof ("gdb.ini") + 1);
2a3d5645
CF		 2803 strcpy (oldini, homedir);
2804 p = strchr (oldini, '\0');
0ba1096a 2805 if (p > oldini && !IS_DIR_SEPARATOR (p[-1]))
2a3d5645
CF		 2806 *p++ = '/';
2807 strcpy (p, "gdb.ini");
2808 if (access (oldini, 0) == 0)
2809 {
2810 int len = strlen (oldini);
1270fac6 2811 char *newini = (char *) alloca (len + 2);
08850b56 2812
1270fac6 2813 xsnprintf (newini, len + 2, "%.*s.gdbinit",
08850b56 2814 (int) (len - (sizeof ("gdb.ini") - 1)), oldini);
8a3fe4f8 2815 warning (_("obsolete '%s' found. Rename to '%s'."), oldini, newini);
2a3d5645
CF		 2816 }
2817 }
2818}
33605d39 2819
2b008701 2820/* Define dummy functions which always return error for the rare cases where
581e13c1 2821 these functions could not be found. */
2b008701
CF		 2822static BOOL WINAPI
2823bad_DebugActiveProcessStop (DWORD w)
2824{
2825 return FALSE;
2826}
2827static BOOL WINAPI
2828bad_DebugBreakProcess (HANDLE w)
2829{
2830 return FALSE;
2831}
2832static BOOL WINAPI
2833bad_DebugSetProcessKillOnExit (BOOL w)
2834{
2835 return FALSE;
2836}
2837static BOOL WINAPI
2838bad_EnumProcessModules (HANDLE w, HMODULE *x, DWORD y, LPDWORD z)
2839{
2840 return FALSE;
2841}
b3c613f2
CF		 2842
2843#ifdef __USEWIDE
2b008701 2844static DWORD WINAPI
b3c613f2 2845bad_GetModuleFileNameExW (HANDLE w, HMODULE x, LPWSTR y, DWORD z)
2b008701
CF		 2846{
2847 return 0;
2848}
d0d0ab16
CV		 2849#else
2850static DWORD WINAPI
b3c613f2 2851bad_GetModuleFileNameExA (HANDLE w, HMODULE x, LPSTR y, DWORD z)
d0d0ab16
CV		 2852{
2853 return 0;
2854}
2855#endif
b3c613f2 2856
2b008701
CF		 2857static BOOL WINAPI
2858bad_GetModuleInformation (HANDLE w, HMODULE x, LPMODULEINFO y, DWORD z)
2859{
2860 return FALSE;
2861}
2862
418c6cb3
CF		 2863static BOOL WINAPI
2864bad_OpenProcessToken (HANDLE w, DWORD x, PHANDLE y)
2865{
2866 return FALSE;
2867}
2868
cd44747c
PM		 2869static BOOL WINAPI
2870bad_GetCurrentConsoleFont (HANDLE w, BOOL bMaxWindow, CONSOLE_FONT_INFO *f)
2871{
2872 f->nFont = 0;
2873 return 1;
2874}
2875static COORD WINAPI
2876bad_GetConsoleFontSize (HANDLE w, DWORD nFont)
2877{
2878 COORD size;
2879 size.X = 8;
2880 size.Y = 12;
2881 return size;
2882}
2883
d603d4b3
JK		 2884/* -Wmissing-prototypes */
2885extern initialize_file_ftype _initialize_loadable;
2886
2b008701 2887/* Load any functions which may not be available in ancient versions
581e13c1 2888 of Windows. */
d603d4b3 2889
33605d39 2890void
2b008701 2891_initialize_loadable (void)
33605d39 2892{
2b008701
CF		 2893 HMODULE hm = NULL;
2894
43499ea3
PA		 2895#define GPA(m, func) \
2896 func = (func ## _ftype *) GetProcAddress (m, #func)
2897
2b008701
CF		 2898 hm = LoadLibrary ("kernel32.dll");
2899 if (hm)
33605d39 2900 {
43499ea3
PA		 2901 GPA (hm, DebugActiveProcessStop);
2902 GPA (hm, DebugBreakProcess);
2903 GPA (hm, DebugSetProcessKillOnExit);
2904 GPA (hm, GetConsoleFontSize);
2905 GPA (hm, DebugActiveProcessStop);
2906 GPA (hm, GetCurrentConsoleFont);
2b008701 2907 }
33605d39 2908
2b008701 2909 /* Set variables to dummy versions of these processes if the function
581e13c1 2910 wasn't found in kernel32.dll. */
b3c613f2
CF		 2911 if (!DebugBreakProcess)
2912 DebugBreakProcess = bad_DebugBreakProcess;
2913 if (!DebugActiveProcessStop || !DebugSetProcessKillOnExit)
2b008701 2914 {
b3c613f2
CF		 2915 DebugActiveProcessStop = bad_DebugActiveProcessStop;
2916 DebugSetProcessKillOnExit = bad_DebugSetProcessKillOnExit;
2b008701 2917 }
cd44747c
PM		 2918 if (!GetConsoleFontSize)
2919 GetConsoleFontSize = bad_GetConsoleFontSize;
2920 if (!GetCurrentConsoleFont)
2921 GetCurrentConsoleFont = bad_GetCurrentConsoleFont;
33605d39 2922
2b008701 2923 /* Load optional functions used for retrieving filename information
581e13c1 2924 associated with the currently debugged process or its dlls. */
2b008701
CF		 2925 hm = LoadLibrary ("psapi.dll");
2926 if (hm)
2927 {
43499ea3
PA		 2928 GPA (hm, EnumProcessModules);
2929 GPA (hm, GetModuleInformation);
aec47d1d
JB		 2930 GetModuleFileNameEx = (GetModuleFileNameEx_ftype *)
2931 GetProcAddress (hm, GetModuleFileNameEx_name);
33605d39
CF		 2932 }
2933
b3c613f2 2934 if (!EnumProcessModules || !GetModuleInformation || !GetModuleFileNameEx)
2b008701
CF		 2935 {
2936 /* Set variables to dummy versions of these processes if the function
581e13c1 2937 wasn't found in psapi.dll. */
b3c613f2
CF		 2938 EnumProcessModules = bad_EnumProcessModules;
2939 GetModuleInformation = bad_GetModuleInformation;
2940 GetModuleFileNameEx = bad_GetModuleFileNameEx;
581e13c1
MS		 2941 /* This will probably fail on Windows 9x/Me. Let the user know
2942 that we're missing some functionality. */
2943 warning(_("\
2944cannot automatically find executable file or library to read symbols.\n\
2945Use \"file\" or \"dll\" command to load executable/libraries directly."));
418c6cb3
CF		 2946 }
2947
2948 hm = LoadLibrary ("advapi32.dll");
2949 if (hm)
2950 {
43499ea3
PA		 2951 GPA (hm, OpenProcessToken);
2952 GPA (hm, LookupPrivilegeValueA);
2953 GPA (hm, AdjustTokenPrivileges);
418c6cb3 2954 /* Only need to set one of these since if OpenProcessToken fails nothing
581e13c1
MS		 2955 else is needed. */
2956 if (!OpenProcessToken || !LookupPrivilegeValueA
2957 || !AdjustTokenPrivileges)
b3c613f2 2958 OpenProcessToken = bad_OpenProcessToken;
2b008701 2959 }
43499ea3
PA		 2960
2961#undef GPA
33605d39 2962}
GDB Binutils - Deliverables
This page took 2.225948 seconds and 4 git commands to generate.