projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
include/elf/
[deliverable/binutils-gdb.git] / gdb / windows-nat.c
CommitLineData
dc05df57 1/* Target-vector operations for controlling windows child processes, for GDB.
0a65a603 2
281b533b 3 Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
0fb0cc75 4 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
0a65a603 5
e6433c28 6 Contributed by Cygnus Solutions, A Red Hat Company.
e88c49c3 7
24e60978
SC		 8 This file is part of GDB.
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
a9762ec7 12 the Free Software Foundation; either version 3 of the License, or
24e60978
SC		 13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
a9762ec7 16 but WITHOUT ANY WARRANTY; without even the implied warranty of
24e60978
SC		 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
a9762ec7 21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24e60978 22
dfe7f3ac 23/* Originally by Steve Chamberlain, sac@cygnus.com */
24e60978
SC		 24
25#include "defs.h"
26#include "frame.h" /* required by inferior.h */
27#include "inferior.h"
28#include "target.h"
60250e8b 29#include "exceptions.h"
24e60978
SC		 30#include "gdbcore.h"
31#include "command.h"
fa58ee11 32#include "completer.h"
4e052eda 33#include "regcache.h"
2a3d5645 34#include "top.h"
403d9909
CF		 35#include <signal.h>
36#include <sys/types.h>
37#include <fcntl.h>
38#include <stdlib.h>
39#include <windows.h>
40#include <imagehlp.h>
10325bc5 41#ifdef __CYGWIN__
403d9909 42#include <sys/cygwin.h>
10325bc5 43#endif
a244bdca 44#include <signal.h>
cad9cd60 45
24e60978 46#include "buildsym.h"
1ef980b9
SC		 47#include "symfile.h"
48#include "objfiles.h"
de1b3c3d 49#include "gdb_obstack.h"
24e60978 50#include "gdb_string.h"
fdfa3315 51#include "gdbthread.h"
24e60978 52#include "gdbcmd.h"
1750a5ef 53#include <sys/param.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"
24e60978 59
6c7de422
MK		 60#include "i386-tdep.h"
61#include "i387-tdep.h"
62
31b060a2
CF		 63#include "windows-tdep.h"
64#include "windows-nat.h"
de1b3c3d 65
dc05df57 66static struct target_ops windows_ops;
3ee6f623 67
10325bc5 68#ifdef __CYGWIN__
a244bdca 69/* The starting and ending address of the cygwin1.dll text segment. */
dc05df57
CF		 70static CORE_ADDR cygwin_load_start;
71static CORE_ADDR cygwin_load_end;
10325bc5 72#endif
a244bdca
CF		 73
74static int have_saved_context; /* True if we've saved context from a cygwin signal. */
75static CONTEXT saved_context; /* Containes the saved context from a cygwin signal. */
76
0714f9bf
SS		 77/* If we're not using the old Cygwin header file set, define the
78 following which never should have been in the generic Win32 API
79 headers in the first place since they were our own invention... */
80#ifndef _GNU_H_WINDOWS_H
9d3789f7 81enum
8e860359
CF		 82 {
83 FLAG_TRACE_BIT = 0x100,
84 CONTEXT_DEBUGGER = (CONTEXT_FULL | CONTEXT_FLOATING_POINT)
85 };
0714f9bf 86#endif
8e860359 87#include <psapi.h>
0714f9bf 88
5851ab76
JB		 89#ifndef CONTEXT_EXTENDED_REGISTERS
90/* This macro is only defined on ia32. It only makes sense on this target,
91 so define it as zero if not already defined. */
92#define CONTEXT_EXTENDED_REGISTERS 0
93#endif
94
fa4ba8da
PM		 95#define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_DEBUG_REGISTERS \
96 | CONTEXT_EXTENDED_REGISTERS
97da3b20 97
fa4ba8da 98static unsigned dr[8];
87a45c96
CF		 99static int debug_registers_changed;
100static int debug_registers_used;
6537bb24 101#define DR6_CLEAR_VALUE 0xffff0ff0
97da3b20 102
3cee93ac
CF		 103/* The string sent by cygwin when it processes a signal.
104 FIXME: This should be in a cygwin include file. */
3929abe9
CF		 105#ifndef _CYGWIN_SIGNAL_STRING
106#define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
107#endif
3cee93ac 108
29fe111d 109#define CHECK(x) check (x, __FILE__,__LINE__)
dfe7f3ac 110#define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
4e52d31c
PM		 111#define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
112#define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
113#define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
24e60978 114
dc05df57 115static void windows_stop (ptid_t);
02529b48 116static int windows_thread_alive (struct target_ops *, ptid_t);
dc05df57 117static void windows_kill_inferior (void);
3cee93ac 118
7393af7c
PM		 119static enum target_signal last_sig = TARGET_SIGNAL_0;
120/* Set if a signal was received from the debugged process */
121
3cee93ac 122/* Thread information structure used to track information that is
6537bb24 123 not available in gdb's thread structure. */
3cee93ac 124typedef struct thread_info_struct
3a4b77d8
JM		 125 {
126 struct thread_info_struct *next;
127 DWORD id;
128 HANDLE h;
129 char *name;
6537bb24 130 int suspended;
3ade5333 131 int reload_context;
3a4b77d8 132 CONTEXT context;
1e37c281 133 STACKFRAME sf;
8e860359
CF		 134 }
135thread_info;
1e37c281 136
29fe111d 137static thread_info thread_head;
24e60978 138
24e60978
SC		 139/* The process and thread handles for the above context. */
140
3cee93ac
CF		 141static DEBUG_EVENT current_event; /* The current debug event from
142 WaitForDebugEvent */
143static HANDLE current_process_handle; /* Currently executing process */
144static thread_info *current_thread; /* Info on currently selected thread */
349b409f 145static DWORD main_thread_id; /* Thread ID of the main thread */
24e60978
SC		 146
147/* Counts of things. */
148static int exception_count = 0;
149static int event_count = 0;
dfe7f3ac 150static int saw_create;
bf25528d 151static int open_process_used = 0;
24e60978
SC		 152
153/* User options. */
154static int new_console = 0;
10325bc5 155#ifdef __CYGWIN__
09280ddf 156static int cygwin_exceptions = 0;
10325bc5 157#endif
1e37c281 158static int new_group = 1;
dfe7f3ac
CF		 159static int debug_exec = 0; /* show execution */
160static int debug_events = 0; /* show events from kernel */
161static int debug_memory = 0; /* show target memory accesses */
1ef980b9 162static int debug_exceptions = 0; /* show target exceptions */
dfe7f3ac
CF		 163static int useshell = 0; /* use shell for subprocesses */
164
7e63b4e4 165/* This vector maps GDB's idea of a register's number into an offset
dc05df57 166 in the windows exception context vector.
24e60978 167
3cee93ac 168 It also contains the bit mask needed to load the register in question.
24e60978 169
7e63b4e4
JB		 170 The contents of this table can only be computed by the units
171 that provide CPU-specific support for Windows native debugging.
172 These units should set the table by calling
dc05df57 173 windows_set_context_register_offsets.
7e63b4e4 174
24e60978
SC		 175 One day we could read a reg, we could inspect the context we
176 already have loaded, if it doesn't have the bit set that we need,
177 we read that set of registers in using GetThreadContext. If the
178 context already contains what we need, we just unpack it. Then to
179 write a register, first we have to ensure that the context contains
180 the other regs of the group, and then we copy the info in and set
181 out bit. */
182
7e63b4e4 183static const int *mappings;
d3a09475 184
24e60978
SC		 185/* This vector maps the target's idea of an exception (extracted
186 from the DEBUG_EVENT structure) to GDB's idea. */
187
188struct xlate_exception
189 {
190 int them;
191 enum target_signal us;
192 };
193
24e60978
SC		 194static const struct xlate_exception
195 xlate[] =
196{
197 {EXCEPTION_ACCESS_VIOLATION, TARGET_SIGNAL_SEGV},
9cbf6c0e 198 {STATUS_STACK_OVERFLOW, TARGET_SIGNAL_SEGV},
24e60978
SC		 199 {EXCEPTION_BREAKPOINT, TARGET_SIGNAL_TRAP},
200 {DBG_CONTROL_C, TARGET_SIGNAL_INT},
201 {EXCEPTION_SINGLE_STEP, TARGET_SIGNAL_TRAP},
7393af7c 202 {STATUS_FLOAT_DIVIDE_BY_ZERO, TARGET_SIGNAL_FPE},
24e60978
SC		 203 {-1, -1}};
204
7e63b4e4
JB		 205/* Set the MAPPINGS static global to OFFSETS.
206 See the description of MAPPINGS for more details. */
207
208void
dc05df57 209windows_set_context_register_offsets (const int *offsets)
7e63b4e4
JB		 210{
211 mappings = offsets;
212}
213
fa4ba8da
PM		 214static void
215check (BOOL ok, const char *file, int line)
216{
217 if (!ok)
dfe7f3ac 218 printf_filtered ("error return %s:%d was %lu\n", file, line,
fa4ba8da
PM		 219 GetLastError ());
220}
221
6537bb24
PA		 222/* Find a thread record given a thread id. If GET_CONTEXT is not 0,
223 then also retrieve the context for this thread. If GET_CONTEXT is
224 negative, then don't suspend the thread. */
3cee93ac
CF		 225static thread_info *
226thread_rec (DWORD id, int get_context)
24e60978 227{
3cee93ac
CF		 228 thread_info *th;
229
3a4b77d8 230 for (th = &thread_head; (th = th->next) != NULL;)
3cee93ac
CF		 231 if (th->id == id)
232 {
6537bb24 233 if (!th->suspended && get_context)
3cee93ac 234 {
8a892701 235 if (get_context > 0 && id != current_event.dwThreadId)
6537bb24
PA		 236 {
237 if (SuspendThread (th->h) == (DWORD) -1)
238 {
239 DWORD err = GetLastError ();
240 warning (_("SuspendThread failed. (winerr %d)"),
241 (int) err);
242 return NULL;
243 }
244 th->suspended = 1;
245 }
3cee93ac 246 else if (get_context < 0)
6537bb24 247 th->suspended = -1;
3ade5333 248 th->reload_context = 1;
3cee93ac
CF		 249 }
250 return th;
251 }
252
253 return NULL;
254}
255
2dc38344 256/* Add a thread to the thread list. */
3cee93ac 257static thread_info *
dc05df57 258windows_add_thread (ptid_t ptid, HANDLE h)
3cee93ac
CF		 259{
260 thread_info *th;
2dc38344
PA		 261 DWORD id;
262
263 gdb_assert (ptid_get_tid (ptid) != 0);
264
265 id = ptid_get_tid (ptid);
3cee93ac
CF		 266
267 if ((th = thread_rec (id, FALSE)))
268 return th;
269
3929abe9 270 th = XZALLOC (thread_info);
3cee93ac
CF		 271 th->id = id;
272 th->h = h;
273 th->next = thread_head.next;
274 thread_head.next = th;
2dc38344
PA		 275 add_thread (ptid);
276 /* Set the debug registers for the new thread if they are used. */
fa4ba8da
PM		 277 if (debug_registers_used)
278 {
279 /* Only change the value of the debug registers. */
280 th->context.ContextFlags = CONTEXT_DEBUG_REGISTERS;
281 CHECK (GetThreadContext (th->h, &th->context));
282 th->context.Dr0 = dr[0];
283 th->context.Dr1 = dr[1];
284 th->context.Dr2 = dr[2];
285 th->context.Dr3 = dr[3];
6537bb24 286 th->context.Dr6 = DR6_CLEAR_VALUE;
fa4ba8da
PM		 287 th->context.Dr7 = dr[7];
288 CHECK (SetThreadContext (th->h, &th->context));
289 th->context.ContextFlags = 0;
290 }
3cee93ac 291 return th;
24e60978
SC		 292}
293
3cee93ac
CF		 294/* Clear out any old thread list and reintialize it to a
295 pristine state. */
24e60978 296static void
dc05df57 297windows_init_thread_list (void)
24e60978 298{
3cee93ac
CF		 299 thread_info *th = &thread_head;
300
dc05df57 301 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
3cee93ac
CF		 302 init_thread_list ();
303 while (th->next != NULL)
24e60978 304 {
3cee93ac
CF		 305 thread_info *here = th->next;
306 th->next = here->next;
b8c9b27d 307 xfree (here);
24e60978 308 }
059198c1 309 thread_head.next = NULL;
3cee93ac
CF		 310}
311
312/* Delete a thread from the list of threads */
313static void
dc05df57 314windows_delete_thread (ptid_t ptid)
3cee93ac
CF		 315{
316 thread_info *th;
2dc38344
PA		 317 DWORD id;
318
319 gdb_assert (ptid_get_tid (ptid) != 0);
320
321 id = ptid_get_tid (ptid);
3cee93ac
CF		 322
323 if (info_verbose)
2dc38344
PA		 324 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid));
325 delete_thread (ptid);
3cee93ac
CF		 326
327 for (th = &thread_head;
328 th->next != NULL && th->next->id != id;
329 th = th->next)
330 continue;
331
332 if (th->next != NULL)
24e60978 333 {
3cee93ac
CF		 334 thread_info *here = th->next;
335 th->next = here->next;
b8c9b27d 336 xfree (here);
24e60978
SC		 337 }
338}
339
3cee93ac 340static void
dc05df57 341do_windows_fetch_inferior_registers (struct regcache *regcache, int r)
24e60978 342{
1e37c281 343 char *context_offset = ((char *) &current_thread->context) + mappings[r];
20a6ec49
MD		 344 struct gdbarch *gdbarch = get_regcache_arch (regcache);
345 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1e37c281 346 long l;
6c7de422 347
3ade5333 348 if (!current_thread)
d6dc8049
CF		 349 return; /* Windows sometimes uses a non-existent thread id in its
350 events */
3ade5333
CF		 351
352 if (current_thread->reload_context)
353 {
cb832706 354#ifdef __COPY_CONTEXT_SIZE
a244bdca
CF		 355 if (have_saved_context)
356 {
357 /* Lie about where the program actually is stopped since cygwin has informed us that
358 we should consider the signal to have occurred at another location which is stored
359 in "saved_context. */
360 memcpy (&current_thread->context, &saved_context, __COPY_CONTEXT_SIZE);
361 have_saved_context = 0;
362 }
363 else
cb832706 364#endif
a244bdca
CF		 365 {
366 thread_info *th = current_thread;
367 th->context.ContextFlags = CONTEXT_DEBUGGER_DR;
368 GetThreadContext (th->h, &th->context);
88616312
PM		 369 /* Copy dr values from that thread.
370 But only if there were not modified since last stop. PR gdb/2388 */
371 if (!debug_registers_changed)
372 {
373 dr[0] = th->context.Dr0;
374 dr[1] = th->context.Dr1;
375 dr[2] = th->context.Dr2;
376 dr[3] = th->context.Dr3;
377 dr[6] = th->context.Dr6;
378 dr[7] = th->context.Dr7;
379 }
a244bdca 380 }
3ade5333
CF		 381 current_thread->reload_context = 0;
382 }
383
20a6ec49 384 if (r == I387_FISEG_REGNUM (tdep))
1e37c281 385 {
8e860359 386 l = *((long *) context_offset) & 0xffff;
56be3814 387 regcache_raw_supply (regcache, r, (char *) &l);
1e37c281 388 }
20a6ec49 389 else if (r == I387_FOP_REGNUM (tdep))
1e37c281 390 {
8e860359 391 l = (*((long *) context_offset) >> 16) & ((1 << 11) - 1);
56be3814 392 regcache_raw_supply (regcache, r, (char *) &l);
1e37c281
JM		 393 }
394 else if (r >= 0)
56be3814 395 regcache_raw_supply (regcache, r, context_offset);
3cee93ac 396 else
24e60978 397 {
20a6ec49 398 for (r = 0; r < gdbarch_num_regs (gdbarch); r++)
dc05df57 399 do_windows_fetch_inferior_registers (regcache, r);
24e60978 400 }
3cee93ac
CF		 401}
402
403static void
28439f5e
PA		 404windows_fetch_inferior_registers (struct target_ops *ops,
405 struct regcache *regcache, int r)
3cee93ac 406{
2dc38344 407 current_thread = thread_rec (ptid_get_tid (inferior_ptid), TRUE);
d6dc8049
CF		 408 /* Check if current_thread exists. Windows sometimes uses a non-existent
409 thread id in its events */
3ade5333 410 if (current_thread)
dc05df57 411 do_windows_fetch_inferior_registers (regcache, r);
3cee93ac
CF		 412}
413
414static void
dc05df57 415do_windows_store_inferior_registers (const struct regcache *regcache, int r)
3cee93ac 416{
3ade5333 417 if (!current_thread)
d6dc8049 418 /* Windows sometimes uses a non-existent thread id in its events */;
3ade5333 419 else if (r >= 0)
56be3814 420 regcache_raw_collect (regcache, r,
822c9732 421 ((char *) &current_thread->context) + mappings[r]);
24e60978
SC		 422 else
423 {
40a6adc1 424 for (r = 0; r < gdbarch_num_regs (get_regcache_arch (regcache)); r++)
dc05df57 425 do_windows_store_inferior_registers (regcache, r);
24e60978
SC		 426 }
427}
428
3cee93ac
CF		 429/* Store a new register value into the current thread context */
430static void
28439f5e
PA		 431windows_store_inferior_registers (struct target_ops *ops,
432 struct regcache *regcache, int r)
3cee93ac 433{
2dc38344 434 current_thread = thread_rec (ptid_get_tid (inferior_ptid), TRUE);
d6dc8049
CF		 435 /* Check if current_thread exists. Windows sometimes uses a non-existent
436 thread id in its events */
3ade5333 437 if (current_thread)
dc05df57 438 do_windows_store_inferior_registers (regcache, r);
3cee93ac 439}
24e60978 440
1e37c281 441static int psapi_loaded = 0;
33605d39
CF		 442static BOOL WINAPI (*psapi_EnumProcessModules) (HANDLE, HMODULE *, DWORD,
443 LPDWORD);
444static BOOL WINAPI (*psapi_GetModuleInformation) (HANDLE, HMODULE, LPMODULEINFO,
445 DWORD);
446static DWORD WINAPI (*psapi_GetModuleFileNameExA) (HANDLE, HMODULE, LPSTR,
447 DWORD);
448
449/* Get the name of a given module at at given base address. If base_address
450 is zero return the first loaded module (which is always the name of the
451 executable). */
3ee6f623 452static int
d3653bf6 453get_module_name (LPVOID base_address, char *dll_name_ret)
1e37c281
JM		 454{
455 DWORD len;
456 MODULEINFO mi;
457 int i;
8e860359 458 HMODULE dh_buf[1];
33605d39 459 HMODULE *DllHandle = dh_buf; /* Set to temporary storage for initial query */
1e37c281 460 DWORD cbNeeded;
33605d39
CF		 461#ifdef __CYGWIN__
462 char pathbuf[PATH_MAX + 1]; /* Temporary storage prior to converting to
463 posix form */
464#else
465 char *pathbuf = dll_name_ret; /* Just copy directly to passed-in arg */
466#endif
1e37c281 467
33605d39
CF		 468 /* If psapi_loaded < 0 either psapi.dll is not available or it does not contain
469 the needed functions. */
470 if (psapi_loaded <= 0)
471 goto failed;
1e37c281
JM		 472
473 cbNeeded = 0;
33605d39
CF		 474 /* Find size of buffer needed to handle list of modules loaded in inferior */
475 if (!psapi_EnumProcessModules (current_process_handle, DllHandle,
476 sizeof (HMODULE), &cbNeeded) || !cbNeeded)
1e37c281
JM		 477 goto failed;
478
33605d39 479 /* Allocate correct amount of space for module list */
8e860359 480 DllHandle = (HMODULE *) alloca (cbNeeded);
1e37c281
JM		 481 if (!DllHandle)
482 goto failed;
483
33605d39
CF		 484 /* Get the list of modules */
485 if (!psapi_EnumProcessModules (current_process_handle, DllHandle, cbNeeded,
486 &cbNeeded))
1e37c281
JM		 487 goto failed;
488
29fe111d 489 for (i = 0; i < (int) (cbNeeded / sizeof (HMODULE)); i++)
1e37c281 490 {
33605d39
CF		 491 /* Get information on this module */
492 if (!psapi_GetModuleInformation (current_process_handle, DllHandle[i],
493 &mi, sizeof (mi)))
8a3fe4f8 494 error (_("Can't get module info"));
1e37c281 495
d3653bf6 496 if (!base_address || mi.lpBaseOfDll == base_address)
33605d39
CF		 497 {
498 /* Try to find the name of the given module */
499 len = psapi_GetModuleFileNameExA (current_process_handle,
500 DllHandle[i], pathbuf, MAX_PATH);
501 if (len == 0)
502 error (_("Error getting dll name: %u."), (unsigned) GetLastError ());
503#ifdef __CYGWIN__
504 /* Cygwin prefers that the path be in /x/y/z format */
505 cygwin_conv_to_full_posix_path (pathbuf, dll_name_ret);
506#endif
507 return 1; /* success */
508 }
1e37c281
JM		 509 }
510
511failed:
512 dll_name_ret[0] = '\0';
33605d39 513 return 0; /* failure */
1e37c281
JM		 514}
515
450005e7
CF		 516/* Encapsulate the information required in a call to
517 symbol_file_add_args */
8a892701
CF		 518struct safe_symbol_file_add_args
519{
520 char *name;
521 int from_tty;
522 struct section_addr_info *addrs;
523 int mainline;
524 int flags;
7c5c87c0 525 struct ui_file *err, *out;
8a892701
CF		 526 struct objfile *ret;
527};
528
02e423b9 529/* Maintain a linked list of "so" information. */
3ee6f623 530struct lm_info
02e423b9 531{
d3653bf6 532 LPVOID load_addr;
3ee6f623
CF		 533};
534
535static struct so_list solib_start, *solib_end;
02e423b9 536
450005e7
CF		 537/* Call symbol_file_add with stderr redirected. We don't care if there
538 are errors. */
8a892701
CF		 539static int
540safe_symbol_file_add_stub (void *argv)
541{
3ee6f623 542#define p ((struct safe_symbol_file_add_args *) argv)
8a892701
CF		 543 p->ret = symbol_file_add (p->name, p->from_tty, p->addrs, p->mainline, p->flags);
544 return !!p->ret;
545#undef p
546}
547
450005e7 548/* Restore gdb's stderr after calling symbol_file_add */
8a892701 549static void
7c5c87c0 550safe_symbol_file_add_cleanup (void *p)
8a892701 551{
8e860359 552#define sp ((struct safe_symbol_file_add_args *)p)
450005e7 553 gdb_flush (gdb_stderr);
7c5c87c0 554 gdb_flush (gdb_stdout);
d3ff4a77 555 ui_file_delete (gdb_stderr);
7c5c87c0 556 ui_file_delete (gdb_stdout);
d3ff4a77 557 gdb_stderr = sp->err;
9d3789f7 558 gdb_stdout = sp->out;
8e860359 559#undef sp
8a892701
CF		 560}
561
450005e7 562/* symbol_file_add wrapper that prevents errors from being displayed. */
8a892701
CF		 563static struct objfile *
564safe_symbol_file_add (char *name, int from_tty,
565 struct section_addr_info *addrs,
566 int mainline, int flags)
8a892701
CF		 567{
568 struct safe_symbol_file_add_args p;
569 struct cleanup *cleanup;
570
7c5c87c0 571 cleanup = make_cleanup (safe_symbol_file_add_cleanup, &p);
8a892701 572
7c5c87c0
CF		 573 p.err = gdb_stderr;
574 p.out = gdb_stdout;
450005e7 575 gdb_flush (gdb_stderr);
7c5c87c0 576 gdb_flush (gdb_stdout);
d3ff4a77 577 gdb_stderr = ui_file_new ();
7c5c87c0 578 gdb_stdout = ui_file_new ();
8a892701
CF		 579 p.name = name;
580 p.from_tty = from_tty;
581 p.addrs = addrs;
582 p.mainline = mainline;
583 p.flags = flags;
584 catch_errors (safe_symbol_file_add_stub, &p, "", RETURN_MASK_ERROR);
585
586 do_cleanups (cleanup);
587 return p.ret;
588}
589
de1b3c3d 590static struct so_list *
dc05df57 591windows_make_so (const char *name, LPVOID load_addr)
8e860359 592{
3ee6f623 593 struct so_list *so;
3f8ad85b
CF		 594 char buf[MAX_PATH + 1];
595 char cwd[MAX_PATH + 1];
596 char *p;
597 WIN32_FIND_DATA w32_fd;
598 HANDLE h = FindFirstFile(name, &w32_fd);
5633f842 599 MEMORY_BASIC_INFORMATION m;
3f8ad85b 600
6badb179
CF		 601 if (h == INVALID_HANDLE_VALUE)
602 strcpy (buf, name);
603 else
3f8ad85b 604 {
c914e0cc
CF		 605 FindClose (h);
606 strcpy (buf, name);
607 if (GetCurrentDirectory (MAX_PATH + 1, cwd))
608 {
609 p = strrchr (buf, '\\');
610 if (p)
611 p[1] = '\0';
612 SetCurrentDirectory (buf);
613 GetFullPathName (w32_fd.cFileName, MAX_PATH, buf, &p);
614 SetCurrentDirectory (cwd);
615 }
3f8ad85b
CF		 616 }
617
3ee6f623
CF		 618 if (strcasecmp (buf, "ntdll.dll") == 0)
619 {
620 GetSystemDirectory (buf, sizeof (buf));
621 strcat (buf, "\\ntdll.dll");
622 }
3929abe9 623 so = XZALLOC (struct so_list);
3ee6f623
CF		 624 so->lm_info = (struct lm_info *) xmalloc (sizeof (struct lm_info));
625 so->lm_info->load_addr = load_addr;
de1b3c3d 626 strcpy (so->so_original_name, name);
10325bc5
PA		 627#ifndef __CYGWIN__
628 strcpy (so->so_name, buf);
629#else
630 cygwin_conv_to_posix_path (buf, so->so_name);
de1b3c3d
PA		 631 /* Record cygwin1.dll .text start/end. */
632 p = strchr (so->so_name, '\0') - (sizeof ("/cygwin1.dll") - 1);
633 if (p >= so->so_name && strcasecmp (p, "/cygwin1.dll") == 0)
634 {
635 bfd *abfd;
636 asection *text = NULL;
637 CORE_ADDR text_vma;
8e860359 638
610dd7f9 639 abfd = bfd_openr (so->so_name, "pei-i386");
a244bdca 640
de1b3c3d
PA		 641 if (!abfd)
642 return so;
643
644 if (bfd_check_format (abfd, bfd_object))
645 text = bfd_get_section_by_name (abfd, ".text");
646
647 if (!text)
648 {
649 bfd_close (abfd);
650 return so;
651 }
652
653 /* The symbols in a dll are offset by 0x1000, which is the the
654 offset from 0 of the first byte in an image - because of the
655 file header and the section alignment. */
dc05df57
CF		 656 cygwin_load_start = (CORE_ADDR) (uintptr_t) ((char *) load_addr + 0x1000);
657 cygwin_load_end = cygwin_load_start + bfd_section_size (abfd, text);
de1b3c3d
PA		 658
659 bfd_close (abfd);
660 }
10325bc5 661#endif
de1b3c3d
PA		 662
663 return so;
8e860359
CF		 664}
665
3ee6f623 666static char *
dfe7f3ac
CF		 667get_image_name (HANDLE h, void *address, int unicode)
668{
669 static char buf[(2 * MAX_PATH) + 1];
670 DWORD size = unicode ? sizeof (WCHAR) : sizeof (char);
671 char *address_ptr;
672 int len = 0;
673 char b[2];
5732a500 674 SIZE_T done;
dfe7f3ac
CF		 675
676 /* Attempt to read the name of the dll that was detected.
677 This is documented to work only when actively debugging
678 a program. It will not work for attached processes. */
679 if (address == NULL)
680 return NULL;
681
dfe7f3ac
CF		 682 /* See if we could read the address of a string, and that the
683 address isn't null. */
9f476a01 684 if (!ReadProcessMemory (h, address, &address_ptr, sizeof (address_ptr), &done)
6f17862b 685 || done != sizeof (address_ptr) || !address_ptr)
dfe7f3ac
CF		 686 return NULL;
687
688 /* Find the length of the string */
6f17862b
CF		 689 while (ReadProcessMemory (h, address_ptr + len++ * size, &b, size, &done)
690 && (b[0] != 0 || b[size - 1] != 0) && done == size)
691 continue;
dfe7f3ac
CF		 692
693 if (!unicode)
694 ReadProcessMemory (h, address_ptr, buf, len, &done);
695 else
696 {
697 WCHAR *unicode_address = (WCHAR *) alloca (len * sizeof (WCHAR));
698 ReadProcessMemory (h, address_ptr, unicode_address, len * sizeof (WCHAR),
699 &done);
700
701 WideCharToMultiByte (CP_ACP, 0, unicode_address, len, buf, len, 0, 0);
702 }
703
704 return buf;
705}
706
24e60978
SC		 707/* Wait for child to do something. Return pid of child, or -1 in case
708 of error; store status through argument pointer OURSTATUS. */
1750a5ef 709static int
0a65a603 710handle_load_dll (void *dummy)
24e60978 711{
3a4b77d8 712 LOAD_DLL_DEBUG_INFO *event = &current_event.u.LoadDll;
3cee93ac 713 char dll_buf[MAX_PATH + 1];
450005e7 714 char *dll_name = NULL;
3cee93ac 715
3a4b77d8 716 dll_buf[0] = dll_buf[sizeof (dll_buf) - 1] = '\0';
3cee93ac 717
d3653bf6 718 if (!get_module_name (event->lpBaseOfDll, dll_buf))
8e860359 719 dll_buf[0] = dll_buf[sizeof (dll_buf) - 1] = '\0';
3cee93ac 720
1e37c281 721 dll_name = dll_buf;
24e60978 722
dfe7f3ac 723 if (*dll_name == '\0')
de1b3c3d
PA		 724 dll_name = get_image_name (current_process_handle,
725 event->lpImageName, event->fUnicode);
3cee93ac
CF		 726 if (!dll_name)
727 return 1;
728
dc05df57 729 solib_end->next = windows_make_so (dll_name, event->lpBaseOfDll);
de1b3c3d 730 solib_end = solib_end->next;
450005e7 731
31b060a2 732 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %p.\n", solib_end->so_name,
d3653bf6 733 solib_end->lm_info->load_addr));
7488902c 734
450005e7
CF		 735 return 1;
736}
737
3ee6f623 738static void
dc05df57 739windows_free_so (struct so_list *so)
3ee6f623 740{
3ee6f623
CF		 741 if (so->lm_info)
742 xfree (so->lm_info);
de1b3c3d 743 xfree (so);
3cb8e7f6
CF		 744}
745
d3ff4a77 746static int
0a65a603 747handle_unload_dll (void *dummy)
d3ff4a77 748{
d3653bf6 749 LPVOID lpBaseOfDll = current_event.u.UnloadDll.lpBaseOfDll;
3ee6f623 750 struct so_list *so;
d3ff4a77
CF		 751
752 for (so = &solib_start; so->next != NULL; so = so->next)
3ee6f623 753 if (so->next->lm_info->load_addr == lpBaseOfDll)
d3ff4a77 754 {
3ee6f623 755 struct so_list *sodel = so->next;
d3ff4a77
CF		 756 so->next = sodel->next;
757 if (!so->next)
758 solib_end = so;
7488902c
PM		 759 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel->so_name));
760
dc05df57 761 windows_free_so (sodel);
3929abe9 762 solib_add (NULL, 0, NULL, auto_solib_add);
d3ff4a77
CF		 763 return 1;
764 }
3929abe9 765
a588db63 766 error (_("Error: dll starting at %p not found."), lpBaseOfDll);
d3ff4a77
CF		 767
768 return 0;
769}
770
450005e7 771/* Clear list of loaded DLLs. */
3ee6f623 772static void
dc05df57 773windows_clear_solib (void)
450005e7 774{
450005e7
CF		 775 solib_start.next = NULL;
776 solib_end = &solib_start;
450005e7 777}
295732ea 778
450005e7
CF		 779/* Load DLL symbol info. */
780void
7470a420 781dll_symbol_command (char *args, int from_tty)
450005e7 782{
8e860359 783 int n;
450005e7 784 dont_repeat ();
8e860359 785
450005e7 786 if (args == NULL)
8a3fe4f8 787 error (_("dll-symbols requires a file name"));
450005e7 788
8e860359
CF		 789 n = strlen (args);
790 if (n > 4 && strcasecmp (args + n - 4, ".dll") != 0)
791 {
792 char *newargs = (char *) alloca (n + 4 + 1);
793 strcpy (newargs, args);
794 strcat (newargs, ".dll");
795 args = newargs;
796 }
797
7470a420 798 safe_symbol_file_add (args, from_tty, NULL, 0, OBJF_SHARED | OBJF_USERLOADED);
8e860359 799}
450005e7 800
3cee93ac
CF		 801/* Handle DEBUG_STRING output from child process.
802 Cygwin prepends its messages with a "cygwin:". Interpret this as
803 a Cygwin signal. Otherwise just print the string as a warning. */
804static int
805handle_output_debug_string (struct target_waitstatus *ourstatus)
806{
a244bdca
CF		 807 char *s = NULL;
808 int retval = 0;
3cee93ac
CF		 809
810 if (!target_read_string
2c647436
PM		 811 ((CORE_ADDR) (uintptr_t) current_event.u.DebugString.lpDebugStringData,
812 &s, 1024, 0)
3cee93ac 813 || !s || !*s)
a244bdca
CF		 814 /* nothing to do */;
815 else if (strncmp (s, _CYGWIN_SIGNAL_STRING, sizeof (_CYGWIN_SIGNAL_STRING) - 1) != 0)
3cee93ac 816 {
10325bc5 817#ifdef __CYGWIN__
d3a09475 818 if (strncmp (s, "cYg", 3) != 0)
10325bc5 819#endif
8a3fe4f8 820 warning (("%s"), s);
3cee93ac 821 }
cb832706 822#ifdef __COPY_CONTEXT_SIZE
d3a09475 823 else
3cee93ac 824 {
a244bdca
CF		 825 /* Got a cygwin signal marker. A cygwin signal is followed by the signal number
826 itself and then optionally followed by the thread id and address to saved context
827 within the DLL. If these are supplied, then the given thread is assumed to have
828 issued the signal and the context from the thread is assumed to be stored at the
829 given address in the inferior. Tell gdb to treat this like a real signal. */
3cee93ac 830 char *p;
3929abe9 831 int sig = strtol (s + sizeof (_CYGWIN_SIGNAL_STRING) - 1, &p, 0);
a244bdca 832 int gotasig = target_signal_from_host (sig);
0714f9bf
SS		 833 ourstatus->value.sig = gotasig;
834 if (gotasig)
a244bdca
CF		 835 {
836 LPCVOID x;
837 DWORD n;
838 ourstatus->kind = TARGET_WAITKIND_STOPPED;
839 retval = strtoul (p, &p, 0);
840 if (!retval)
841 retval = main_thread_id;
842 else if ((x = (LPCVOID) strtoul (p, &p, 0))
843 && ReadProcessMemory (current_process_handle, x,
844 &saved_context, __COPY_CONTEXT_SIZE, &n)
845 && n == __COPY_CONTEXT_SIZE)
846 have_saved_context = 1;
847 current_event.dwThreadId = retval;
848 }
3cee93ac 849 }
cb832706 850#endif
3cee93ac 851
a244bdca
CF		 852 if (s)
853 xfree (s);
854 return retval;
3cee93ac 855}
24e60978 856
c1748f97
PM		 857static int
858display_selector (HANDLE thread, DWORD sel)
859{
860 LDT_ENTRY info;
861 if (GetThreadSelectorEntry (thread, sel, &info))
862 {
863 int base, limit;
864 printf_filtered ("0x%03lx: ", sel);
865 if (!info.HighWord.Bits.Pres)
baa93fa6
CF		 866 {
867 puts_filtered ("Segment not present\n");
868 return 0;
869 }
c1748f97
PM		 870 base = (info.HighWord.Bits.BaseHi << 24) +
871 (info.HighWord.Bits.BaseMid << 16)
872 + info.BaseLow;
873 limit = (info.HighWord.Bits.LimitHi << 16) + info.LimitLow;
874 if (info.HighWord.Bits.Granularity)
caad7706 875 limit = (limit << 12) | 0xfff;
c1748f97
PM		 876 printf_filtered ("base=0x%08x limit=0x%08x", base, limit);
877 if (info.HighWord.Bits.Default_Big)
baa93fa6 878 puts_filtered(" 32-bit ");
c1748f97 879 else
baa93fa6 880 puts_filtered(" 16-bit ");
c1748f97
PM		 881 switch ((info.HighWord.Bits.Type & 0xf) >> 1)
882 {
883 case 0:
baa93fa6
CF		 884 puts_filtered ("Data (Read-Only, Exp-up");
885 break;
c1748f97 886 case 1:
baa93fa6
CF		 887 puts_filtered ("Data (Read/Write, Exp-up");
888 break;
c1748f97 889 case 2:
baa93fa6
CF		 890 puts_filtered ("Unused segment (");
891 break;
c1748f97 892 case 3:
baa93fa6
CF		 893 puts_filtered ("Data (Read/Write, Exp-down");
894 break;
c1748f97 895 case 4:
baa93fa6
CF		 896 puts_filtered ("Code (Exec-Only, N.Conf");
897 break;
c1748f97 898 case 5:
baa93fa6 899 puts_filtered ("Code (Exec/Read, N.Conf");
c1748f97
PM		 900 break;
901 case 6:
baa93fa6 902 puts_filtered ("Code (Exec-Only, Conf");
c1748f97
PM		 903 break;
904 case 7:
baa93fa6 905 puts_filtered ("Code (Exec/Read, Conf");
c1748f97
PM		 906 break;
907 default:
908 printf_filtered ("Unknown type 0x%x",info.HighWord.Bits.Type);
909 }
910 if ((info.HighWord.Bits.Type & 0x1) == 0)
baa93fa6 911 puts_filtered(", N.Acc");
c1748f97
PM		 912 puts_filtered (")\n");
913 if ((info.HighWord.Bits.Type & 0x10) == 0)
914 puts_filtered("System selector ");
915 printf_filtered ("Priviledge level = %d. ", info.HighWord.Bits.Dpl);
916 if (info.HighWord.Bits.Granularity)
baa93fa6 917 puts_filtered ("Page granular.\n");
c1748f97
PM		 918 else
919 puts_filtered ("Byte granular.\n");
920 return 1;
921 }
922 else
923 {
924 printf_filtered ("Invalid selector 0x%lx.\n",sel);
925 return 0;
926 }
927}
928
929static void
930display_selectors (char * args, int from_tty)
931{
932 if (!current_thread)
933 {
934 puts_filtered ("Impossible to display selectors now.\n");
935 return;
936 }
937 if (!args)
938 {
939
940 puts_filtered ("Selector $cs\n");
941 display_selector (current_thread->h,
baa93fa6 942 current_thread->context.SegCs);
c1748f97
PM		 943 puts_filtered ("Selector $ds\n");
944 display_selector (current_thread->h,
baa93fa6 945 current_thread->context.SegDs);
c1748f97
PM		 946 puts_filtered ("Selector $es\n");
947 display_selector (current_thread->h,
baa93fa6 948 current_thread->context.SegEs);
c1748f97
PM		 949 puts_filtered ("Selector $ss\n");
950 display_selector (current_thread->h,
baa93fa6 951 current_thread->context.SegSs);
c1748f97
PM		 952 puts_filtered ("Selector $fs\n");
953 display_selector (current_thread->h,
954 current_thread->context.SegFs);
955 puts_filtered ("Selector $gs\n");
956 display_selector (current_thread->h,
baa93fa6 957 current_thread->context.SegGs);
c1748f97
PM		 958 }
959 else
960 {
961 int sel;
962 sel = parse_and_eval_long (args);
963 printf_filtered ("Selector \"%s\"\n",args);
964 display_selector (current_thread->h, sel);
965 }
966}
967
968static struct cmd_list_element *info_w32_cmdlist = NULL;
969
970static void
971info_w32_command (char *args, int from_tty)
972{
973 help_list (info_w32_cmdlist, "info w32 ", class_info, gdb_stdout);
974}
975
976
7393af7c 977#define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
31b060a2 978 printf_unfiltered ("gdb: Target exception %s at %p\n", x, \
5732a500 979 current_event.u.Exception.ExceptionRecord.ExceptionAddress)
7393af7c 980
36339ecd 981static int
450005e7 982handle_exception (struct target_waitstatus *ourstatus)
24e60978 983{
3cee93ac 984 thread_info *th;
29fe111d 985 DWORD code = current_event.u.Exception.ExceptionRecord.ExceptionCode;
3cee93ac 986
29fe111d 987 ourstatus->kind = TARGET_WAITKIND_STOPPED;
8a892701 988
3cee93ac
CF		 989 /* Record the context of the current thread */
990 th = thread_rec (current_event.dwThreadId, -1);
24e60978 991
29fe111d 992 switch (code)
24e60978 993 {
1ef980b9 994 case EXCEPTION_ACCESS_VIOLATION:
7393af7c
PM		 995 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
996 ourstatus->value.sig = TARGET_SIGNAL_SEGV;
10325bc5 997#ifdef __CYGWIN__
8da8e0b3 998 {
a244bdca
CF		 999 /* See if the access violation happened within the cygwin DLL itself. Cygwin uses
1000 a kind of exception handling to deal with passed-in invalid addresses. gdb
1001 should not treat these as real SEGVs since they will be silently handled by
1002 cygwin. A real SEGV will (theoretically) be caught by cygwin later in the process
1003 and will be sent as a cygwin-specific-signal. So, ignore SEGVs if they show up
1004 within the text segment of the DLL itself. */
8da8e0b3 1005 char *fn;
dc05df57 1006 CORE_ADDR addr = (CORE_ADDR) (uintptr_t) current_event.u.Exception.ExceptionRecord.ExceptionAddress;
09280ddf 1007 if ((!cygwin_exceptions && (addr >= cygwin_load_start && addr < cygwin_load_end))
a244bdca
CF		 1008 || (find_pc_partial_function (addr, &fn, NULL, NULL)
1009 && strncmp (fn, "KERNEL32!IsBad", strlen ("KERNEL32!IsBad")) == 0))
8da8e0b3
CF		 1010 return 0;
1011 }
10325bc5 1012#endif
7393af7c
PM		 1013 break;
1014 case STATUS_STACK_OVERFLOW:
1015 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1ef980b9 1016 ourstatus->value.sig = TARGET_SIGNAL_SEGV;
7393af7c
PM		 1017 break;
1018 case STATUS_FLOAT_DENORMAL_OPERAND:
1019 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1020 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1021 break;
1022 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
1023 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1024 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1025 break;
1026 case STATUS_FLOAT_INEXACT_RESULT:
1027 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1028 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1029 break;
1030 case STATUS_FLOAT_INVALID_OPERATION:
1031 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1032 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1033 break;
1034 case STATUS_FLOAT_OVERFLOW:
1035 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1036 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1037 break;
1038 case STATUS_FLOAT_STACK_CHECK:
1039 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1040 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1ef980b9 1041 break;
3b7c8b74 1042 case STATUS_FLOAT_UNDERFLOW:
7393af7c
PM		 1043 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1044 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1045 break;
3b7c8b74 1046 case STATUS_FLOAT_DIVIDE_BY_ZERO:
7393af7c
PM		 1047 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1048 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1049 break;
3b7c8b74 1050 case STATUS_INTEGER_DIVIDE_BY_ZERO:
7393af7c 1051 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
3b7c8b74 1052 ourstatus->value.sig = TARGET_SIGNAL_FPE;
3b7c8b74 1053 break;
7393af7c
PM		 1054 case STATUS_INTEGER_OVERFLOW:
1055 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1056 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1ef980b9
SC		 1057 break;
1058 case EXCEPTION_BREAKPOINT:
7393af7c 1059 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1ef980b9
SC		 1060 ourstatus->value.sig = TARGET_SIGNAL_TRAP;
1061 break;
1062 case DBG_CONTROL_C:
7393af7c 1063 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1ef980b9 1064 ourstatus->value.sig = TARGET_SIGNAL_INT;
5b421780
PM		 1065 break;
1066 case DBG_CONTROL_BREAK:
7393af7c 1067 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
5b421780 1068 ourstatus->value.sig = TARGET_SIGNAL_INT;
1ef980b9
SC		 1069 break;
1070 case EXCEPTION_SINGLE_STEP:
7393af7c 1071 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1ef980b9
SC		 1072 ourstatus->value.sig = TARGET_SIGNAL_TRAP;
1073 break;
8227c82d 1074 case EXCEPTION_ILLEGAL_INSTRUCTION:
7393af7c
PM		 1075 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1076 ourstatus->value.sig = TARGET_SIGNAL_ILL;
1077 break;
1078 case EXCEPTION_PRIV_INSTRUCTION:
1079 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1080 ourstatus->value.sig = TARGET_SIGNAL_ILL;
1081 break;
1082 case EXCEPTION_NONCONTINUABLE_EXCEPTION:
1083 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
8227c82d
CF		 1084 ourstatus->value.sig = TARGET_SIGNAL_ILL;
1085 break;
1ef980b9 1086 default:
a244bdca 1087 /* Treat unhandled first chance exceptions specially. */
02e423b9 1088 if (current_event.u.Exception.dwFirstChance)
a244bdca 1089 return -1;
31b060a2 1090 printf_unfiltered ("gdb: unknown target exception 0x%08lx at %p\n",
3a4b77d8 1091 current_event.u.Exception.ExceptionRecord.ExceptionCode,
5732a500 1092 current_event.u.Exception.ExceptionRecord.ExceptionAddress);
24e60978 1093 ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
1ef980b9 1094 break;
24e60978 1095 }
24e60978 1096 exception_count++;
7393af7c 1097 last_sig = ourstatus->value.sig;
36339ecd 1098 return 1;
24e60978
SC		 1099}
1100
3cee93ac
CF		 1101/* Resume all artificially suspended threads if we are continuing
1102 execution */
1103static BOOL
dc05df57 1104windows_continue (DWORD continue_status, int id)
3cee93ac
CF		 1105{
1106 int i;
1107 thread_info *th;
1108 BOOL res;
1109
7393af7c
PM		 1110 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%ld, %s);\n",
1111 current_event.dwProcessId, current_event.dwThreadId,
dfe7f3ac 1112 continue_status == DBG_CONTINUE ?
7393af7c 1113 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
6537bb24
PA		 1114
1115 for (th = &thread_head; (th = th->next) != NULL;)
1116 if ((id == -1 || id == (int) th->id)
1117 && th->suspended)
1118 {
1119 if (debug_registers_changed)
1120 {
1121 th->context.ContextFlags |= CONTEXT_DEBUG_REGISTERS;
1122 th->context.Dr0 = dr[0];
1123 th->context.Dr1 = dr[1];
1124 th->context.Dr2 = dr[2];
1125 th->context.Dr3 = dr[3];
1126 th->context.Dr6 = DR6_CLEAR_VALUE;
1127 th->context.Dr7 = dr[7];
1128 }
1129 if (th->context.ContextFlags)
1130 {
1131 CHECK (SetThreadContext (th->h, &th->context));
1132 th->context.ContextFlags = 0;
1133 }
1134 if (th->suspended > 0)
1135 (void) ResumeThread (th->h);
1136 th->suspended = 0;
1137 }
1138
0714f9bf
SS		 1139 res = ContinueDebugEvent (current_event.dwProcessId,
1140 current_event.dwThreadId,
1141 continue_status);
3cee93ac 1142
fa4ba8da 1143 debug_registers_changed = 0;
3cee93ac
CF		 1144 return res;
1145}
1146
d6dc8049
CF		 1147/* Called in pathological case where Windows fails to send a
1148 CREATE_PROCESS_DEBUG_EVENT after an attach. */
3ee6f623 1149static DWORD
5439edaa 1150fake_create_process (void)
3ade5333
CF		 1151{
1152 current_process_handle = OpenProcess (PROCESS_ALL_ACCESS, FALSE,
1153 current_event.dwProcessId);
bf25528d
CF		 1154 if (current_process_handle != NULL)
1155 open_process_used = 1;
1156 else
1157 {
1158 error (_("OpenProcess call failed, GetLastError = %lud\n"),
1159 GetLastError ());
1160 /* We can not debug anything in that case. */
1161 }
3ade5333 1162 main_thread_id = current_event.dwThreadId;
dc05df57
CF		 1163 current_thread = windows_add_thread (ptid_build (current_event.dwProcessId, 0,
1164 current_event.dwThreadId),
1165 current_event.u.CreateThread.hThread);
3ade5333
CF		 1166 return main_thread_id;
1167}
1168
a244bdca 1169static void
28439f5e
PA		 1170windows_resume (struct target_ops *ops,
1171 ptid_t ptid, int step, enum target_signal sig)
a244bdca
CF		 1172{
1173 thread_info *th;
1174 DWORD continue_status = DBG_CONTINUE;
1175
2dc38344
PA		 1176 /* A specific PTID means `step only this thread id'. */
1177 int resume_all = ptid_equal (ptid, minus_one_ptid);
1178
1179 /* If we're continuing all threads, it's the current inferior that
1180 should be handled specially. */
1181 if (resume_all)
1182 ptid = inferior_ptid;
a244bdca
CF		 1183
1184 if (sig != TARGET_SIGNAL_0)
1185 {
1186 if (current_event.dwDebugEventCode != EXCEPTION_DEBUG_EVENT)
1187 {
1188 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig));
1189 }
1190 else if (sig == last_sig)
1191 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1192 else
1193#if 0
1194/* This code does not seem to work, because
1195 the kernel does probably not consider changes in the ExceptionRecord
1196 structure when passing the exception to the inferior.
1197 Note that this seems possible in the exception handler itself. */
1198 {
1199 int i;
1200 for (i = 0; xlate[i].them != -1; i++)
1201 if (xlate[i].us == sig)
1202 {
1203 current_event.u.Exception.ExceptionRecord.ExceptionCode =
1204 xlate[i].them;
1205 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1206 break;
1207 }
1208 if (continue_status == DBG_CONTINUE)
1209 {
1210 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig));
1211 }
1212 }
1213#endif
1214 DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1215 last_sig));
1216 }
1217
1218 last_sig = TARGET_SIGNAL_0;
1219
dc05df57 1220 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
2dc38344 1221 ptid_get_pid (ptid), ptid_get_tid (ptid), step, sig));
a244bdca
CF		 1222
1223 /* Get context for currently selected thread */
2dc38344 1224 th = thread_rec (ptid_get_tid (inferior_ptid), FALSE);
a244bdca
CF		 1225 if (th)
1226 {
1227 if (step)
1228 {
1229 /* Single step by setting t bit */
28439f5e
PA		 1230 windows_fetch_inferior_registers (ops,
1231 get_current_regcache (),
1232 gdbarch_ps_regnum (current_gdbarch));
a244bdca
CF		 1233 th->context.EFlags |= FLAG_TRACE_BIT;
1234 }
1235
1236 if (th->context.ContextFlags)
1237 {
1238 if (debug_registers_changed)
1239 {
1240 th->context.Dr0 = dr[0];
1241 th->context.Dr1 = dr[1];
1242 th->context.Dr2 = dr[2];
1243 th->context.Dr3 = dr[3];
6537bb24 1244 th->context.Dr6 = DR6_CLEAR_VALUE;
a244bdca
CF		 1245 th->context.Dr7 = dr[7];
1246 }
1247 CHECK (SetThreadContext (th->h, &th->context));
1248 th->context.ContextFlags = 0;
1249 }
1250 }
1251
1252 /* Allow continuing with the same signal that interrupted us.
1253 Otherwise complain. */
1254
2dc38344 1255 if (resume_all)
dc05df57 1256 windows_continue (continue_status, -1);
2dc38344 1257 else
dc05df57 1258 windows_continue (continue_status, ptid_get_tid (ptid));
a244bdca
CF		 1259}
1260
8a892701
CF		 1261/* Get the next event from the child. Return 1 if the event requires
1262 handling by WFI (or whatever).
1263 */
1e37c281 1264static int
28439f5e
PA		 1265get_windows_debug_event (struct target_ops *ops,
1266 int pid, struct target_waitstatus *ourstatus)
1e37c281
JM		 1267{
1268 BOOL debug_event;
8a892701 1269 DWORD continue_status, event_code;
87a45c96 1270 thread_info *th;
8a892701 1271 static thread_info dummy_thread_info;
450005e7 1272 int retval = 0;
1e37c281 1273
7393af7c 1274 last_sig = TARGET_SIGNAL_0;
9d3789f7 1275
8a892701 1276 if (!(debug_event = WaitForDebugEvent (&current_event, 1000)))
29fe111d 1277 goto out;
1e37c281
JM		 1278
1279 event_count++;
1280 continue_status = DBG_CONTINUE;
1e37c281 1281
8a892701 1282 event_code = current_event.dwDebugEventCode;
450005e7 1283 ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
87a45c96 1284 th = NULL;
a244bdca 1285 have_saved_context = 0;
8a892701
CF		 1286
1287 switch (event_code)
1e37c281
JM		 1288 {
1289 case CREATE_THREAD_DEBUG_EVENT:
1290 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
8a892701
CF		 1291 (unsigned) current_event.dwProcessId,
1292 (unsigned) current_event.dwThreadId,
1293 "CREATE_THREAD_DEBUG_EVENT"));
dfe7f3ac 1294 if (saw_create != 1)
3ade5333 1295 {
181e7f93
PA		 1296 struct inferior *inf;
1297 inf = find_inferior_pid (current_event.dwProcessId);
1298 if (!saw_create && inf->attach_flag)
3ade5333 1299 {
d6dc8049
CF		 1300 /* Kludge around a Windows bug where first event is a create
1301 thread event. Caused when attached process does not have
1302 a main thread. */
3a3e9ee3 1303 retval = fake_create_process ();
181e7f93
PA		 1304 if (retval)
1305 saw_create++;
3ade5333
CF		 1306 }
1307 break;
1308 }
1e37c281 1309 /* Record the existence of this thread */
450005e7 1310 retval = current_event.dwThreadId;
dc05df57 1311 th = windows_add_thread (ptid_build (current_event.dwProcessId, 0,
2dc38344
PA		 1312 current_event.dwThreadId),
1313 current_event.u.CreateThread.hThread);
1e37c281
JM		 1314 break;
1315
1316 case EXIT_THREAD_DEBUG_EVENT:
1317 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
8a892701
CF		 1318 (unsigned) current_event.dwProcessId,
1319 (unsigned) current_event.dwThreadId,
1320 "EXIT_THREAD_DEBUG_EVENT"));
87a45c96
CF		 1321 if (current_event.dwThreadId != main_thread_id)
1322 {
dc05df57 1323 windows_delete_thread (ptid_build (current_event.dwProcessId, 0,
2dc38344 1324 current_event.dwThreadId));
87a45c96
CF		 1325 th = &dummy_thread_info;
1326 }
1e37c281
JM		 1327 break;
1328
1329 case CREATE_PROCESS_DEBUG_EVENT:
1330 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
8a892701
CF		 1331 (unsigned) current_event.dwProcessId,
1332 (unsigned) current_event.dwThreadId,
1333 "CREATE_PROCESS_DEBUG_EVENT"));
700b351b 1334 CloseHandle (current_event.u.CreateProcessInfo.hFile);
dfe7f3ac 1335 if (++saw_create != 1)
bf25528d 1336 break;
1e37c281 1337
dfe7f3ac 1338 current_process_handle = current_event.u.CreateProcessInfo.hProcess;
87a45c96 1339 if (main_thread_id)
dc05df57 1340 windows_delete_thread (ptid_build (current_event.dwProcessId, 0,
2dc38344 1341 main_thread_id));
9d3789f7 1342 main_thread_id = current_event.dwThreadId;
1e37c281 1343 /* Add the main thread */
dc05df57 1344 th = windows_add_thread (ptid_build (current_event.dwProcessId, 0,
2dc38344 1345 current_event.dwThreadId),
8a892701 1346 current_event.u.CreateProcessInfo.hThread);
3a3e9ee3 1347 retval = current_event.dwThreadId;
1e37c281
JM		 1348 break;
1349
1350 case EXIT_PROCESS_DEBUG_EVENT:
1351 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
8a892701
CF		 1352 (unsigned) current_event.dwProcessId,
1353 (unsigned) current_event.dwThreadId,
1354 "EXIT_PROCESS_DEBUG_EVENT"));
dfe7f3ac
CF		 1355 if (saw_create != 1)
1356 break;
1e37c281
JM		 1357 ourstatus->kind = TARGET_WAITKIND_EXITED;
1358 ourstatus->value.integer = current_event.u.ExitProcess.dwExitCode;
9d3789f7 1359 retval = main_thread_id;
8a892701 1360 break;
1e37c281
JM		 1361
1362 case LOAD_DLL_DEBUG_EVENT:
1363 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
8a892701
CF		 1364 (unsigned) current_event.dwProcessId,
1365 (unsigned) current_event.dwThreadId,
1366 "LOAD_DLL_DEBUG_EVENT"));
700b351b 1367 CloseHandle (current_event.u.LoadDll.hFile);
dfe7f3ac
CF		 1368 if (saw_create != 1)
1369 break;
8a892701 1370 catch_errors (handle_load_dll, NULL, (char *) "", RETURN_MASK_ALL);
450005e7
CF		 1371 ourstatus->kind = TARGET_WAITKIND_LOADED;
1372 ourstatus->value.integer = 0;
9d3789f7 1373 retval = main_thread_id;
1e37c281
JM		 1374 break;
1375
1376 case UNLOAD_DLL_DEBUG_EVENT:
1377 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
8a892701
CF		 1378 (unsigned) current_event.dwProcessId,
1379 (unsigned) current_event.dwThreadId,
1380 "UNLOAD_DLL_DEBUG_EVENT"));
dfe7f3ac
CF		 1381 if (saw_create != 1)
1382 break;
d3ff4a77 1383 catch_errors (handle_unload_dll, NULL, (char *) "", RETURN_MASK_ALL);
de1b3c3d
PA		 1384 ourstatus->kind = TARGET_WAITKIND_LOADED;
1385 ourstatus->value.integer = 0;
1386 retval = main_thread_id;
d3ff4a77 1387 break;
1e37c281
JM		 1388
1389 case EXCEPTION_DEBUG_EVENT:
1390 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
8a892701
CF		 1391 (unsigned) current_event.dwProcessId,
1392 (unsigned) current_event.dwThreadId,
1393 "EXCEPTION_DEBUG_EVENT"));
dfe7f3ac
CF		 1394 if (saw_create != 1)
1395 break;
a244bdca
CF		 1396 switch (handle_exception (ourstatus))
1397 {
1398 case 0:
1399 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1400 break;
1401 case 1:
1402 retval = current_event.dwThreadId;
1403 break;
1404 case -1:
1405 last_sig = 1;
1406 continue_status = -1;
1407 break;
1408 }
1e37c281
JM		 1409 break;
1410
8a892701 1411 case OUTPUT_DEBUG_STRING_EVENT: /* message from the kernel */
1e37c281 1412 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
8a892701
CF		 1413 (unsigned) current_event.dwProcessId,
1414 (unsigned) current_event.dwThreadId,
1415 "OUTPUT_DEBUG_STRING_EVENT"));
dfe7f3ac
CF		 1416 if (saw_create != 1)
1417 break;
a244bdca 1418 retval = handle_output_debug_string (ourstatus);
1e37c281 1419 break;
9d3789f7 1420
1e37c281 1421 default:
dfe7f3ac
CF		 1422 if (saw_create != 1)
1423 break;
29fe111d
CF		 1424 printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",
1425 (DWORD) current_event.dwProcessId,
1426 (DWORD) current_event.dwThreadId);
1427 printf_unfiltered (" unknown event code %ld\n",
1e37c281
JM		 1428 current_event.dwDebugEventCode);
1429 break;
1430 }
1431
dfe7f3ac 1432 if (!retval || saw_create != 1)
a244bdca
CF		 1433 {
1434 if (continue_status == -1)
02529b48 1435 windows_resume (ops, minus_one_ptid, 0, 1);
a244bdca 1436 else
dc05df57 1437 CHECK (windows_continue (continue_status, -1));
a244bdca 1438 }
450005e7 1439 else
9d3789f7 1440 {
2dc38344
PA		 1441 inferior_ptid = ptid_build (current_event.dwProcessId, 0,
1442 retval);
3ade5333 1443 current_thread = th ?: thread_rec (current_event.dwThreadId, TRUE);
9d3789f7 1444 }
1e37c281
JM		 1445
1446out:
450005e7 1447 return retval;
1e37c281
JM		 1448}
1449
2dc38344 1450/* Wait for interesting events to occur in the target process. */
39f77062 1451static ptid_t
117de6a9
PA		 1452windows_wait (struct target_ops *ops,
1453 ptid_t ptid, struct target_waitstatus *ourstatus)
24e60978 1454{
2dc38344 1455 int pid = -1;
39f77062 1456
c44537cf
CV		 1457 target_terminal_ours ();
1458
24e60978
SC		 1459 /* We loop when we get a non-standard exception rather than return
1460 with a SPURIOUS because resume can try and step or modify things,
3cee93ac 1461 which needs a current_thread->h. But some of these exceptions mark
24e60978
SC		 1462 the birth or death of threads, which mean that the current thread
1463 isn't necessarily what you think it is. */
1464
1465 while (1)
450005e7 1466 {
c57918b2
JB		 1467 int retval;
1468
1469 /* Ignore CTRL+C signals while waiting for a debug event.
1470 FIXME: brobecker/2008-05-20: When the user presses CTRL+C while
1471 the inferior is running, both the inferior and GDB receive the
1472 associated signal. If the inferior receives the signal first
1473 and the delay until GDB receives that signal is sufficiently long,
1474 GDB can sometimes receive the SIGINT after we have unblocked
1475 the CTRL+C handler. This would lead to the debugger to stop
1476 prematurely while handling the new-thread event that comes
1477 with the handling of the SIGINT inside the inferior, and then
1478 stop again immediately when the user tries to resume the execution
1479 in the inferior. This is a classic race, and it would be nice
1480 to find a better solution to that problem. But in the meantime,
1481 the current approach already greatly mitigate this issue. */
1482 SetConsoleCtrlHandler (NULL, TRUE);
28439f5e 1483 retval = get_windows_debug_event (ops, pid, ourstatus);
c57918b2
JB		 1484 SetConsoleCtrlHandler (NULL, FALSE);
1485
450005e7 1486 if (retval)
2dc38344 1487 return ptid_build (current_event.dwProcessId, 0, retval);
450005e7
CF		 1488 else
1489 {
1490 int detach = 0;
3cee93ac 1491
98bbd631
AC		 1492 if (deprecated_ui_loop_hook != NULL)
1493 detach = deprecated_ui_loop_hook (0);
0714f9bf 1494
450005e7 1495 if (detach)
dc05df57 1496 windows_kill_inferior ();
450005e7
CF		 1497 }
1498 }
24e60978
SC		 1499}
1500
9d3789f7 1501static void
dc05df57 1502do_initial_windows_stuff (struct target_ops *ops, DWORD pid, int attaching)
9d3789f7
CF		 1503{
1504 extern int stop_after_trap;
fa4ba8da 1505 int i;
d6b48e9c 1506 struct inferior *inf;
2020b7ab 1507 struct thread_info *tp;
9d3789f7 1508
7393af7c 1509 last_sig = TARGET_SIGNAL_0;
9d3789f7
CF		 1510 event_count = 0;
1511 exception_count = 0;
bf25528d 1512 open_process_used = 0;
fa4ba8da 1513 debug_registers_changed = 0;
dfe7f3ac 1514 debug_registers_used = 0;
fa4ba8da
PM		 1515 for (i = 0; i < sizeof (dr) / sizeof (dr[0]); i++)
1516 dr[i] = 0;
10325bc5 1517#ifdef __CYGWIN__
de1b3c3d 1518 cygwin_load_start = cygwin_load_end = 0;
10325bc5 1519#endif
9d3789f7
CF		 1520 current_event.dwProcessId = pid;
1521 memset (&current_event, 0, sizeof (current_event));
0795be10 1522 push_target (ops);
cb851954 1523 disable_breakpoints_in_shlibs ();
dc05df57 1524 windows_clear_solib ();
9d3789f7
CF		 1525 clear_proceed_status ();
1526 init_wait_for_inferior ();
1527
d6b48e9c 1528 inf = add_inferior (pid);
181e7f93 1529 inf->attach_flag = attaching;
7f9f62ba 1530
9f9d052e
PM		 1531 /* Make the new process the current inferior, so terminal handling
1532 can rely on it. When attaching, we don't know about any thread
1533 id here, but that's OK --- nothing should be referencing the
dc05df57 1534 current thread until we report an event out of windows_wait. */
9f9d052e
PM		 1535 inferior_ptid = pid_to_ptid (pid);
1536
c44537cf 1537 terminal_init_inferior_with_pgrp (pid);
9d3789f7
CF		 1538 target_terminal_inferior ();
1539
d6b48e9c 1540 inf->stop_soon = STOP_QUIETLY;
9d3789f7
CF		 1541 while (1)
1542 {
1543 stop_after_trap = 1;
ae123ec6 1544 wait_for_inferior (0);
2020b7ab
PA		 1545 tp = inferior_thread ();
1546 if (tp->stop_signal != TARGET_SIGNAL_TRAP)
1547 resume (0, tp->stop_signal);
9d3789f7
CF		 1548 else
1549 break;
1550 }
eff8332b 1551
d6b48e9c 1552 inf->stop_soon = NO_STOP_QUIETLY;
9d3789f7
CF		 1553 stop_after_trap = 0;
1554 return;
1555}
1556
02cc9f49
CV		 1557/* Since Windows XP, detaching from a process is supported by Windows.
1558 The following code tries loading the appropriate functions dynamically.
1559 If loading these functions succeeds use them to actually detach from
1560 the inferior process, otherwise behave as usual, pretending that
1561 detach has worked. */
def4de3a
JB		 1562static BOOL WINAPI (*kernel32_DebugSetProcessKillOnExit)(BOOL);
1563static BOOL WINAPI (*kernel32_DebugActiveProcessStop)(DWORD);
02cc9f49
CV		 1564
1565static int
5ae5f592 1566has_detach_ability (void)
02cc9f49
CV		 1567{
1568 static HMODULE kernel32 = NULL;
1569
1570 if (!kernel32)
1571 kernel32 = LoadLibrary ("kernel32.dll");
1572 if (kernel32)
1573 {
def4de3a 1574 if (!kernel32_DebugSetProcessKillOnExit)
308a8808
JB		 1575 kernel32_DebugSetProcessKillOnExit =
1576 (void *) GetProcAddress (kernel32, "DebugSetProcessKillOnExit");
def4de3a 1577 if (!kernel32_DebugActiveProcessStop)
308a8808
JB		 1578 kernel32_DebugActiveProcessStop =
1579 (void *) GetProcAddress (kernel32, "DebugActiveProcessStop");
def4de3a
JB		 1580 if (kernel32_DebugSetProcessKillOnExit
1581 && kernel32_DebugActiveProcessStop)
02cc9f49
CV		 1582 return 1;
1583 }
1584 return 0;
1585}
24e60978 1586
616a9dc4
CV		 1587/* Try to set or remove a user privilege to the current process. Return -1
1588 if that fails, the previous setting of that privilege otherwise.
1589
1590 This code is copied from the Cygwin source code and rearranged to allow
1591 dynamically loading of the needed symbols from advapi32 which is only
1592 available on NT/2K/XP. */
1593static int
1594set_process_privilege (const char *privilege, BOOL enable)
1595{
1596 static HMODULE advapi32 = NULL;
1597 static BOOL WINAPI (*OpenProcessToken)(HANDLE, DWORD, PHANDLE);
1598 static BOOL WINAPI (*LookupPrivilegeValue)(LPCSTR, LPCSTR, PLUID);
1599 static BOOL WINAPI (*AdjustTokenPrivileges)(HANDLE, BOOL, PTOKEN_PRIVILEGES,
1600 DWORD, PTOKEN_PRIVILEGES, PDWORD);
1601
1602 HANDLE token_hdl = NULL;
1603 LUID restore_priv;
1604 TOKEN_PRIVILEGES new_priv, orig_priv;
1605 int ret = -1;
1606 DWORD size;
1607
1608 if (GetVersion () >= 0x80000000) /* No security availbale on 9x/Me */
1609 return 0;
1610
1611 if (!advapi32)
1612 {
1613 if (!(advapi32 = LoadLibrary ("advapi32.dll")))
1614 goto out;
1615 if (!OpenProcessToken)
308a8808
JB		 1616 OpenProcessToken =
1617 (void *) GetProcAddress (advapi32, "OpenProcessToken");
616a9dc4 1618 if (!LookupPrivilegeValue)
308a8808
JB		 1619 LookupPrivilegeValue =
1620 (void *) GetProcAddress (advapi32, "LookupPrivilegeValueA");
616a9dc4 1621 if (!AdjustTokenPrivileges)
308a8808
JB		 1622 AdjustTokenPrivileges =
1623 (void *) GetProcAddress (advapi32, "AdjustTokenPrivileges");
616a9dc4 1624 if (!OpenProcessToken || !LookupPrivilegeValue || !AdjustTokenPrivileges)
295732ea 1625 {
616a9dc4
CV		 1626 advapi32 = NULL;
1627 goto out;
1628 }
1629 }
295732ea 1630
616a9dc4
CV		 1631 if (!OpenProcessToken (GetCurrentProcess (),
1632 TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
1633 &token_hdl))
1634 goto out;
1635
1636 if (!LookupPrivilegeValue (NULL, privilege, &restore_priv))
1637 goto out;
1638
1639 new_priv.PrivilegeCount = 1;
1640 new_priv.Privileges[0].Luid = restore_priv;
1641 new_priv.Privileges[0].Attributes = enable ? SE_PRIVILEGE_ENABLED : 0;
1642
1643 if (!AdjustTokenPrivileges (token_hdl, FALSE, &new_priv,
295732ea 1644 sizeof orig_priv, &orig_priv, &size))
616a9dc4
CV		 1645 goto out;
1646#if 0
1647 /* Disabled, otherwise every `attach' in an unprivileged user session
1648 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
dc05df57 1649 windows_attach(). */
616a9dc4
CV		 1650 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1651 be enabled. GetLastError () returns an correct error code, though. */
1652 if (enable && GetLastError () == ERROR_NOT_ALL_ASSIGNED)
1653 goto out;
1654#endif
1655
1656 ret = orig_priv.Privileges[0].Attributes == SE_PRIVILEGE_ENABLED ? 1 : 0;
1657
1658out:
1659 if (token_hdl)
1660 CloseHandle (token_hdl);
1661
1662 return ret;
1663}
1664
02cc9f49 1665/* Attach to process PID, then initialize for debugging it. */
24e60978 1666static void
dc05df57 1667windows_attach (struct target_ops *ops, char *args, int from_tty)
24e60978
SC		 1668{
1669 BOOL ok;
559e75c0 1670 DWORD pid;
24e60978
SC		 1671
1672 if (!args)
e2e0b3e5 1673 error_no_arg (_("process-id to attach"));
24e60978 1674
616a9dc4
CV		 1675 if (set_process_privilege (SE_DEBUG_NAME, TRUE) < 0)
1676 {
1677 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1678 printf_unfiltered ("This can cause attach to fail on Windows NT/2K/XP\n");
1679 }
1680
baa93fa6
CF		 1681 pid = strtoul (args, 0, 0); /* Windows pid */
1682
dc05df57 1683 windows_init_thread_list ();
9d3789f7 1684 ok = DebugActiveProcess (pid);
91a175b3 1685 saw_create = 0;
24e60978 1686
10325bc5 1687#ifdef __CYGWIN__
24e60978 1688 if (!ok)
baa93fa6
CF		 1689 {
1690 /* Try fall back to Cygwin pid */
1691 pid = cygwin_internal (CW_CYGWIN_PID_TO_WINPID, pid);
1692
1693 if (pid > 0)
1694 ok = DebugActiveProcess (pid);
10325bc5
PA		 1695 }
1696#endif
baa93fa6 1697
10325bc5
PA		 1698 if (!ok)
1699 error (_("Can't attach to process."));
24e60978 1700
02cc9f49 1701 if (has_detach_ability ())
def4de3a 1702 kernel32_DebugSetProcessKillOnExit (FALSE);
3ade5333 1703
24e60978
SC		 1704 if (from_tty)
1705 {
1706 char *exec_file = (char *) get_exec_file (0);
1707
1708 if (exec_file)
1709 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
39f77062 1710 target_pid_to_str (pid_to_ptid (pid)));
24e60978
SC		 1711 else
1712 printf_unfiltered ("Attaching to %s\n",
39f77062 1713 target_pid_to_str (pid_to_ptid (pid)));
24e60978
SC		 1714
1715 gdb_flush (gdb_stdout);
1716 }
1717
dc05df57 1718 do_initial_windows_stuff (ops, pid, 1);
9d3789f7 1719 target_terminal_ours ();
24e60978
SC		 1720}
1721
24e60978 1722static void
dc05df57 1723windows_detach (struct target_ops *ops, char *args, int from_tty)
24e60978 1724{
02cc9f49
CV		 1725 int detached = 1;
1726
1727 if (has_detach_ability ())
1728 {
96998ce7 1729 ptid_t ptid = {-1};
28439f5e 1730 windows_resume (ops, ptid, 0, TARGET_SIGNAL_0);
96998ce7 1731
def4de3a 1732 if (!kernel32_DebugActiveProcessStop (current_event.dwProcessId))
3bccec63 1733 {
8a3fe4f8 1734 error (_("Can't detach process %lu (error %lu)"),
02cc9f49
CV		 1735 current_event.dwProcessId, GetLastError ());
1736 detached = 0;
3bccec63 1737 }
def4de3a 1738 kernel32_DebugSetProcessKillOnExit (FALSE);
02cc9f49
CV		 1739 }
1740 if (detached && from_tty)
24e60978
SC		 1741 {
1742 char *exec_file = get_exec_file (0);
1743 if (exec_file == 0)
1744 exec_file = "";
02cc9f49
CV		 1745 printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file,
1746 current_event.dwProcessId);
24e60978
SC		 1747 gdb_flush (gdb_stdout);
1748 }
7f9f62ba 1749
39f77062 1750 inferior_ptid = null_ptid;
7f9f62ba
PA		 1751 detach_inferior (current_event.dwProcessId);
1752
0795be10 1753 unpush_target (ops);
24e60978
SC		 1754}
1755
3ee6f623 1756static char *
dc05df57 1757windows_pid_to_exec_file (int pid)
47216e51 1758{
47216e51 1759 static char path[MAX_PATH + 1];
10325bc5
PA		 1760
1761#ifdef __CYGWIN__
33605d39
CF		 1762 /* Try to find exe name as symlink target of /proc/<pid>/exe */
1763 int nchars;
1764 char procexe[sizeof ("/proc/4294967295/exe")];
2dc38344 1765 sprintf (procexe, "/proc/%u/exe", pid);
33605d39
CF		 1766 nchars = readlink (procexe, path, sizeof(path));
1767 if (nchars > 0 && nchars < sizeof (path))
47216e51 1768 {
33605d39
CF		 1769 path[nchars] = '\0'; /* Got it */
1770 return path;
47216e51 1771 }
10325bc5
PA		 1772#endif
1773
33605d39
CF		 1774 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
1775 of gdb, or we're trying to debug a non-Cygwin windows executable. */
1776 if (!get_module_name (0, path))
1777 path[0] = '\0';
1778
1779 return path;
47216e51
CV		 1780}
1781
24e60978
SC		 1782/* Print status information about what we're accessing. */
1783
1784static void
dc05df57 1785windows_files_info (struct target_ops *ignore)
24e60978 1786{
181e7f93
PA		 1787 struct inferior *inf = current_inferior ();
1788
24e60978 1789 printf_unfiltered ("\tUsing the running image of %s %s.\n",
181e7f93
PA		 1790 inf->attach_flag ? "attached" : "child",
1791 target_pid_to_str (inferior_ptid));
24e60978
SC		 1792}
1793
24e60978 1794static void
dc05df57 1795windows_open (char *arg, int from_tty)
24e60978 1796{
8a3fe4f8 1797 error (_("Use the \"run\" command to start a Unix child process."));
24e60978
SC		 1798}
1799
dc05df57 1800/* Start an inferior windows child process and sets inferior_ptid to its pid.
24e60978
SC		 1801 EXEC_FILE is the file to run.
1802 ALLARGS is a string containing the arguments to the program.
1803 ENV is the environment vector to pass. Errors reported with error(). */
1804
24e60978 1805static void
dc05df57 1806windows_create_inferior (struct target_ops *ops, char *exec_file,
136d6dae 1807 char *allargs, char **in_env, int from_tty)
24e60978 1808{
24e60978
SC		 1809 STARTUPINFO si;
1810 PROCESS_INFORMATION pi;
24e60978
SC		 1811 BOOL ret;
1812 DWORD flags;
eb708f2e 1813 char *args;
dfe7f3ac
CF		 1814 char real_path[MAXPATHLEN];
1815 char *toexec;
349b409f
CF		 1816 char shell[MAX_PATH + 1]; /* Path to shell */
1817 const char *sh;
2becadee
CF		 1818 int tty;
1819 int ostdin, ostdout, ostderr;
3cb3b8df 1820 const char *inferior_io_terminal = get_inferior_io_terminal ();
24e60978
SC		 1821
1822 if (!exec_file)
8a3fe4f8 1823 error (_("No executable specified, use `target exec'."));
24e60978
SC		 1824
1825 memset (&si, 0, sizeof (si));
1826 si.cb = sizeof (si);
1827
10325bc5 1828#ifdef __CYGWIN__
349b409f 1829 if (!useshell)
dfe7f3ac
CF		 1830 {
1831 flags = DEBUG_ONLY_THIS_PROCESS;
1832 cygwin_conv_to_win32_path (exec_file, real_path);
1833 toexec = real_path;
1834 }
1835 else
1836 {
349b409f
CF		 1837 char *newallargs;
1838 sh = getenv ("SHELL");
1839 if (!sh)
1840 sh = "/bin/sh";
1841 cygwin_conv_to_win32_path (sh, shell);
1842 newallargs = alloca (sizeof (" -c 'exec '") + strlen (exec_file)
1843 + strlen (allargs) + 2);
dfe7f3ac
CF		 1844 sprintf (newallargs, " -c 'exec %s %s'", exec_file, allargs);
1845 allargs = newallargs;
1846 toexec = shell;
1847 flags = DEBUG_PROCESS;
1848 }
10325bc5
PA		 1849#else
1850 toexec = exec_file;
1851 flags = DEBUG_ONLY_THIS_PROCESS;
1852#endif
eb708f2e 1853
eeb25b8a
PM		 1854 if (new_group)
1855 flags |= CREATE_NEW_PROCESS_GROUP;
1856
1857 if (new_console)
1858 flags |= CREATE_NEW_CONSOLE;
1859
dfe7f3ac
CF		 1860 args = alloca (strlen (toexec) + strlen (allargs) + 2);
1861 strcpy (args, toexec);
eb708f2e
SC		 1862 strcat (args, " ");
1863 strcat (args, allargs);
1864
10325bc5 1865#ifdef __CYGWIN__
e88c49c3 1866 /* Prepare the environment vars for CreateProcess. */
002c07a9 1867 cygwin_internal (CW_SYNC_WINENV);
1750a5ef 1868
2becadee
CF		 1869 if (!inferior_io_terminal)
1870 tty = ostdin = ostdout = ostderr = -1;
1871 else
1872 {
1873 tty = open (inferior_io_terminal, O_RDWR | O_NOCTTY);
1874 if (tty < 0)
1875 {
1876 print_sys_errmsg (inferior_io_terminal, errno);
1877 ostdin = ostdout = ostderr = -1;
1878 }
1879 else
1880 {
1881 ostdin = dup (0);
1882 ostdout = dup (1);
1883 ostderr = dup (2);
1884 dup2 (tty, 0);
1885 dup2 (tty, 1);
1886 dup2 (tty, 2);
1887 }
1888 }
10325bc5 1889#endif
2becadee 1890
dc05df57 1891 windows_init_thread_list ();
1750a5ef 1892 ret = CreateProcess (0,
3a4b77d8 1893 args, /* command line */
24e60978
SC		 1894 NULL, /* Security */
1895 NULL, /* thread */
1896 TRUE, /* inherit handles */
1897 flags, /* start flags */
002c07a9 1898 NULL, /* environment */
24e60978
SC		 1899 NULL, /* current directory */
1900 &si,
1901 &pi);
10325bc5
PA		 1902
1903#ifdef __CYGWIN__
2becadee
CF		 1904 if (tty >= 0)
1905 {
1906 close (tty);
1907 dup2 (ostdin, 0);
1908 dup2 (ostdout, 1);
1909 dup2 (ostderr, 2);
1910 close (ostdin);
1911 close (ostdout);
1912 close (ostderr);
1913 }
10325bc5 1914#endif
2becadee 1915
24e60978 1916 if (!ret)
8a3fe4f8
AC		 1917 error (_("Error creating process %s, (error %d)."),
1918 exec_file, (unsigned) GetLastError ());
24e60978 1919
c1766e7d
PM		 1920 CloseHandle (pi.hThread);
1921 CloseHandle (pi.hProcess);
1922
dfe7f3ac
CF		 1923 if (useshell && shell[0] != '\0')
1924 saw_create = -1;
1925 else
1926 saw_create = 0;
1927
dc05df57 1928 do_initial_windows_stuff (ops, pi.dwProcessId, 0);
d3a09475 1929
dc05df57 1930 /* windows_continue (DBG_CONTINUE, -1); */
24e60978
SC		 1931}
1932
1933static void
dc05df57 1934windows_mourn_inferior (struct target_ops *ops)
24e60978 1935{
dc05df57 1936 (void) windows_continue (DBG_CONTINUE, -1);
fa4ba8da 1937 i386_cleanup_dregs();
bf25528d
CF		 1938 if (open_process_used)
1939 {
1940 CHECK (CloseHandle (current_process_handle));
1941 open_process_used = 0;
1942 }
0795be10 1943 unpush_target (ops);
24e60978
SC		 1944 generic_mourn_inferior ();
1945}
1946
24e60978
SC		 1947/* Send a SIGINT to the process group. This acts just like the user typed a
1948 ^C on the controlling terminal. */
1949
b607efe7 1950static void
dc05df57 1951windows_stop (ptid_t ptid)
24e60978 1952{
1ef980b9 1953 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
1e37c281 1954 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, current_event.dwProcessId));
3a4b77d8 1955 registers_changed (); /* refresh register state */
24e60978
SC		 1956}
1957
3ee6f623 1958static int
dc05df57 1959windows_xfer_memory (CORE_ADDR memaddr, gdb_byte *our, int len,
0a65a603
AC		 1960 int write, struct mem_attrib *mem,
1961 struct target_ops *target)
24e60978 1962{
5732a500 1963 SIZE_T done = 0;
24e60978
SC		 1964 if (write)
1965 {
29fe111d 1966 DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
2c647436
PM		 1967 len, (DWORD) (uintptr_t) memaddr));
1968 if (!WriteProcessMemory (current_process_handle,
1969 (LPVOID) (uintptr_t) memaddr, our,
6f17862b
CF		 1970 len, &done))
1971 done = 0;
2c647436
PM		 1972 FlushInstructionCache (current_process_handle,
1973 (LPCVOID) (uintptr_t) memaddr, len);
24e60978
SC		 1974 }
1975 else
1976 {
29fe111d 1977 DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
2c647436
PM		 1978 len, (DWORD) (uintptr_t) memaddr));
1979 if (!ReadProcessMemory (current_process_handle,
1980 (LPCVOID) (uintptr_t) memaddr, our,
6f17862b
CF		 1981 len, &done))
1982 done = 0;
24e60978
SC		 1983 }
1984 return done;
1985}
1986
3ee6f623 1987static void
dc05df57 1988windows_kill_inferior (void)
24e60978 1989{
3cee93ac
CF		 1990 CHECK (TerminateProcess (current_process_handle, 0));
1991
b5edcb45
ILT		 1992 for (;;)
1993 {
dc05df57 1994 if (!windows_continue (DBG_CONTINUE, -1))
b5edcb45 1995 break;
3cee93ac 1996 if (!WaitForDebugEvent (&current_event, INFINITE))
b5edcb45 1997 break;
3cee93ac 1998 if (current_event.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT)
b5edcb45
ILT		 1999 break;
2000 }
2001
dc05df57 2002 target_mourn_inferior (); /* or just windows_mourn_inferior? */
24e60978
SC		 2003}
2004
24e60978 2005static void
dc05df57 2006windows_prepare_to_store (struct regcache *regcache)
24e60978
SC		 2007{
2008 /* Do nothing, since we can store individual regs */
2009}
2010
2011static int
dc05df57 2012windows_can_run (void)
24e60978
SC		 2013{
2014 return 1;
2015}
2016
2017static void
dc05df57 2018windows_close (int x)
24e60978 2019{
dc05df57 2020 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
3bccec63 2021 PIDGET (inferior_ptid)));
24e60978 2022}
1ef980b9 2023
3ee6f623
CF		 2024/* Convert pid to printable format. */
2025static char *
117de6a9 2026windows_pid_to_str (struct target_ops *ops, ptid_t ptid)
24e60978 2027{
3ee6f623 2028 static char buf[80];
3ee6f623 2029
2dc38344
PA		 2030 if (ptid_get_tid (ptid) != 0)
2031 {
2032 snprintf (buf, sizeof (buf), "Thread %d.0x%lx",
2033 ptid_get_pid (ptid), ptid_get_tid (ptid));
2034 return buf;
2035 }
2036
2037 return normal_pid_to_str (ptid);
3ee6f623
CF		 2038}
2039
de1b3c3d 2040static LONGEST
dc05df57 2041windows_xfer_shared_libraries (struct target_ops *ops,
de1b3c3d
PA		 2042 enum target_object object, const char *annex,
2043 gdb_byte *readbuf, const gdb_byte *writebuf,
2044 ULONGEST offset, LONGEST len)
3cb8e7f6 2045{
de1b3c3d
PA		 2046 struct obstack obstack;
2047 const char *buf;
2048 LONGEST len_avail;
3cb8e7f6 2049 struct so_list *so;
3cb8e7f6 2050
de1b3c3d
PA		 2051 if (writebuf)
2052 return -1;
3cb8e7f6 2053
de1b3c3d
PA		 2054 obstack_init (&obstack);
2055 obstack_grow_str (&obstack, "<library-list>\n");
2056 for (so = solib_start.next; so; so = so->next)
dc05df57
CF		 2057 windows_xfer_shared_library (so->so_name, (CORE_ADDR) (uintptr_t) so->lm_info->load_addr,
2058 &obstack);
de1b3c3d 2059 obstack_grow_str0 (&obstack, "</library-list>\n");
3cb8e7f6 2060
de1b3c3d
PA		 2061 buf = obstack_finish (&obstack);
2062 len_avail = strlen (buf);
2063 if (offset >= len_avail)
2064 return 0;
3cb8e7f6 2065
de1b3c3d
PA		 2066 if (len > len_avail - offset)
2067 len = len_avail - offset;
2068 memcpy (readbuf, buf + offset, len);
3cb8e7f6 2069
de1b3c3d
PA		 2070 obstack_free (&obstack, NULL);
2071 return len;
3cb8e7f6
CF		 2072}
2073
de1b3c3d 2074static LONGEST
dc05df57 2075windows_xfer_partial (struct target_ops *ops, enum target_object object,
de1b3c3d
PA		 2076 const char *annex, gdb_byte *readbuf,
2077 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
3cb8e7f6 2078{
de1b3c3d 2079 switch (object)
3cb8e7f6 2080 {
de1b3c3d
PA		 2081 case TARGET_OBJECT_MEMORY:
2082 if (readbuf)
2083 return (*ops->deprecated_xfer_memory) (offset, readbuf,
244e85c8 2084 len, 0/*read*/, NULL, ops);
de1b3c3d
PA		 2085 if (writebuf)
2086 return (*ops->deprecated_xfer_memory) (offset, (gdb_byte *) writebuf,
2087 len, 1/*write*/, NULL, ops);
2088 return -1;
2089
2090 case TARGET_OBJECT_LIBRARIES:
dc05df57 2091 return windows_xfer_shared_libraries (ops, object, annex, readbuf,
de1b3c3d 2092 writebuf, offset, len);
3929abe9 2093
de1b3c3d
PA		 2094 default:
2095 if (ops->beneath != NULL)
2096 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
2097 readbuf, writebuf, offset, len);
2098 return -1;
3929abe9 2099 }
02c5aecd
CF		 2100}
2101
3ee6f623 2102static void
dc05df57 2103init_windows_ops (void)
3ee6f623 2104{
dc05df57
CF		 2105 windows_ops.to_shortname = "child";
2106 windows_ops.to_longname = "Win32 child process";
2107 windows_ops.to_doc = "Win32 child process (started by the \"run\" command).";
2108 windows_ops.to_open = windows_open;
2109 windows_ops.to_close = windows_close;
2110 windows_ops.to_attach = windows_attach;
2111 windows_ops.to_attach_no_wait = 1;
2112 windows_ops.to_detach = windows_detach;
2113 windows_ops.to_resume = windows_resume;
2114 windows_ops.to_wait = windows_wait;
2115 windows_ops.to_fetch_registers = windows_fetch_inferior_registers;
2116 windows_ops.to_store_registers = windows_store_inferior_registers;
2117 windows_ops.to_prepare_to_store = windows_prepare_to_store;
2118 windows_ops.deprecated_xfer_memory = windows_xfer_memory;
2119 windows_ops.to_xfer_partial = windows_xfer_partial;
2120 windows_ops.to_files_info = windows_files_info;
2121 windows_ops.to_insert_breakpoint = memory_insert_breakpoint;
2122 windows_ops.to_remove_breakpoint = memory_remove_breakpoint;
2123 windows_ops.to_terminal_init = terminal_init_inferior;
2124 windows_ops.to_terminal_inferior = terminal_inferior;
2125 windows_ops.to_terminal_ours_for_output = terminal_ours_for_output;
2126 windows_ops.to_terminal_ours = terminal_ours;
2127 windows_ops.to_terminal_save_ours = terminal_save_ours;
2128 windows_ops.to_terminal_info = child_terminal_info;
2129 windows_ops.to_kill = windows_kill_inferior;
2130 windows_ops.to_create_inferior = windows_create_inferior;
2131 windows_ops.to_mourn_inferior = windows_mourn_inferior;
2132 windows_ops.to_can_run = windows_can_run;
2133 windows_ops.to_thread_alive = windows_thread_alive;
2134 windows_ops.to_pid_to_str = windows_pid_to_str;
2135 windows_ops.to_stop = windows_stop;
2136 windows_ops.to_stratum = process_stratum;
2137 windows_ops.to_has_all_memory = 1;
2138 windows_ops.to_has_memory = 1;
2139 windows_ops.to_has_stack = 1;
2140 windows_ops.to_has_registers = 1;
2141 windows_ops.to_has_execution = 1;
2142 windows_ops.to_pid_to_exec_file = windows_pid_to_exec_file;
5aca5a82
PM		 2143 i386_use_watchpoints (&windows_ops);
2144
dc05df57 2145 windows_ops.to_magic = OPS_MAGIC;
c719b714 2146}
24e60978 2147
3929abe9 2148static void
dc05df57 2149set_windows_aliases (char *argv0)
3929abe9
CF		 2150{
2151 add_info_alias ("dll", "sharedlibrary", 1);
2152}
2153
24e60978 2154void
dc05df57 2155_initialize_windows_nat (void)
24e60978 2156{
fa58ee11
EZ		 2157 struct cmd_list_element *c;
2158
dc05df57 2159 init_windows_ops ();
1ef980b9 2160
fa58ee11 2161 c = add_com ("dll-symbols", class_files, dll_symbol_command,
1bedd215 2162 _("Load dll library symbols from FILE."));
5ba2abeb 2163 set_cmd_completer (c, filename_completer);
450005e7
CF		 2164
2165 add_com_alias ("sharedlibrary", "dll-symbols", class_alias, 1);
2166
10325bc5 2167#ifdef __CYGWIN__
5bf193a2
AC		 2168 add_setshow_boolean_cmd ("shell", class_support, &useshell, _("\
2169Set use of shell to start subprocess."), _("\
2170Show use of shell to start subprocess."), NULL,
2171 NULL,
2172 NULL, /* FIXME: i18n: */
2173 &setlist, &showlist);
2174
09280ddf
CF		 2175 add_setshow_boolean_cmd ("cygwin-exceptions", class_support, &cygwin_exceptions, _("\
2176Break when an exception is detected in the Cygwin DLL itself."), _("\
2177Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL,
2178 NULL,
2179 NULL, /* FIXME: i18n: */
2180 &setlist, &showlist);
10325bc5 2181#endif
09280ddf 2182
5bf193a2
AC		 2183 add_setshow_boolean_cmd ("new-console", class_support, &new_console, _("\
2184Set creation of new console when creating child process."), _("\
2185Show creation of new console when creating child process."), NULL,
2186 NULL,
2187 NULL, /* FIXME: i18n: */
2188 &setlist, &showlist);
2189
2190 add_setshow_boolean_cmd ("new-group", class_support, &new_group, _("\
2191Set creation of new group when creating child process."), _("\
2192Show creation of new group when creating child process."), NULL,
2193 NULL,
2194 NULL, /* FIXME: i18n: */
2195 &setlist, &showlist);
2196
2197 add_setshow_boolean_cmd ("debugexec", class_support, &debug_exec, _("\
2198Set whether to display execution in child process."), _("\
2199Show whether to display execution in child process."), NULL,
2200 NULL,
2201 NULL, /* FIXME: i18n: */
2202 &setlist, &showlist);
2203
2204 add_setshow_boolean_cmd ("debugevents", class_support, &debug_events, _("\
2205Set whether to display kernel events in child process."), _("\
2206Show whether to display kernel events in child process."), NULL,
2207 NULL,
2208 NULL, /* FIXME: i18n: */
2209 &setlist, &showlist);
2210
2211 add_setshow_boolean_cmd ("debugmemory", class_support, &debug_memory, _("\
2212Set whether to display memory accesses in child process."), _("\
2213Show whether to display memory accesses in child process."), NULL,
2214 NULL,
2215 NULL, /* FIXME: i18n: */
2216 &setlist, &showlist);
2217
2218 add_setshow_boolean_cmd ("debugexceptions", class_support,
2219 &debug_exceptions, _("\
2220Set whether to display kernel exceptions in child process."), _("\
2221Show whether to display kernel exceptions in child process."), NULL,
2222 NULL,
2223 NULL, /* FIXME: i18n: */
2224 &setlist, &showlist);
1ef980b9 2225
c1748f97 2226 add_prefix_cmd ("w32", class_info, info_w32_command,
1bedd215 2227 _("Print information specific to Win32 debugging."),
baa93fa6 2228 &info_w32_cmdlist, "info w32 ", 0, &infolist);
c1748f97
PM		 2229
2230 add_cmd ("selector", class_info, display_selectors,
1a966eab 2231 _("Display selectors infos."),
c1748f97 2232 &info_w32_cmdlist);
dc05df57
CF		 2233 add_target (&windows_ops);
2234 deprecated_init_ui_hook = set_windows_aliases;
24e60978 2235}
3cee93ac 2236
fa4ba8da
PM		 2237/* Hardware watchpoint support, adapted from go32-nat.c code. */
2238
2239/* Pass the address ADDR to the inferior in the I'th debug register.
2240 Here we just store the address in dr array, the registers will be
dc05df57 2241 actually set up when windows_continue is called. */
fa4ba8da
PM		 2242void
2243cygwin_set_dr (int i, CORE_ADDR addr)
2244{
2245 if (i < 0 || i > 3)
2246 internal_error (__FILE__, __LINE__,
e2e0b3e5 2247 _("Invalid register %d in cygwin_set_dr.\n"), i);
fa4ba8da
PM		 2248 dr[i] = (unsigned) addr;
2249 debug_registers_changed = 1;
2250 debug_registers_used = 1;
2251}
2252
2253/* Pass the value VAL to the inferior in the DR7 debug control
2254 register. Here we just store the address in D_REGS, the watchpoint
dc05df57 2255 will be actually set up in windows_wait. */
fa4ba8da
PM		 2256void
2257cygwin_set_dr7 (unsigned val)
2258{
2259 dr[7] = val;
2260 debug_registers_changed = 1;
2261 debug_registers_used = 1;
2262}
2263
2264/* Get the value of the DR6 debug status register from the inferior.
2265 Here we just return the value stored in dr[6]
2266 by the last call to thread_rec for current_event.dwThreadId id. */
2267unsigned
2268cygwin_get_dr6 (void)
2269{
2270 return dr[6];
2271}
2272
2dc38344 2273/* Determine if the thread referenced by "ptid" is alive
3cee93ac 2274 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
2dc38344 2275 it means that the thread has died. Otherwise it is assumed to be alive. */
3cee93ac 2276static int
28439f5e 2277windows_thread_alive (struct target_ops *ops, ptid_t ptid)
3cee93ac 2278{
2dc38344
PA		 2279 int tid;
2280
2281 gdb_assert (ptid_get_tid (ptid) != 0);
2282 tid = ptid_get_tid (ptid);
39f77062 2283
2dc38344 2284 return WaitForSingleObject (thread_rec (tid, FALSE)->h, 0) == WAIT_OBJECT_0 ?
3a4b77d8 2285 FALSE : TRUE;
3cee93ac
CF		 2286}
2287
2a3d5645
CF		 2288void
2289_initialize_check_for_gdb_ini (void)
2290{
2291 char *homedir;
2292 if (inhibit_gdbinit)
2293 return;
2294
2295 homedir = getenv ("HOME");
2296 if (homedir)
2297 {
2298 char *p;
2299 char *oldini = (char *) alloca (strlen (homedir) +
2300 sizeof ("/gdb.ini"));
2301 strcpy (oldini, homedir);
2302 p = strchr (oldini, '\0');
2303 if (p > oldini && p[-1] != '/')
2304 *p++ = '/';
2305 strcpy (p, "gdb.ini");
2306 if (access (oldini, 0) == 0)
2307 {
2308 int len = strlen (oldini);
2309 char *newini = alloca (len + 1);
dfe7f3ac 2310 sprintf (newini, "%.*s.gdbinit",
58fa08f0 2311 (int) (len - (sizeof ("gdb.ini") - 1)), oldini);
8a3fe4f8 2312 warning (_("obsolete '%s' found. Rename to '%s'."), oldini, newini);
2a3d5645
CF		 2313 }
2314 }
2315}
33605d39
CF		 2316
2317void
2318_initialize_psapi (void)
2319{
2320 /* Load optional functions used for retrieving filename information
2321 associated with the currently debugged process or its dlls. */
2322 if (!psapi_loaded)
2323 {
2324 HMODULE psapi_module_handle;
2325
2326 psapi_loaded = -1;
2327
2328 psapi_module_handle = LoadLibrary ("psapi.dll");
2329 if (psapi_module_handle)
2330 {
2331 psapi_EnumProcessModules = (void *) GetProcAddress (psapi_module_handle, "EnumProcessModules");
2332 psapi_GetModuleInformation = (void *) GetProcAddress (psapi_module_handle, "GetModuleInformation");
2333 psapi_GetModuleFileNameExA = (void *) GetProcAddress (psapi_module_handle, "GetModuleFileNameExA");
2334
2335 if (psapi_EnumProcessModules != NULL
2336 && psapi_GetModuleInformation != NULL
2337 && psapi_GetModuleFileNameExA != NULL)
2338 psapi_loaded = 1;
2339 }
2340 }
2341
2342 /* This will probably fail on Windows 9x/Me. Let the user know that we're
2343 missing some functionality. */
2344 if (psapi_loaded < 0)
2345 warning(_("cannot automatically find executable file or library to read symbols. Use \"file\" or \"dll\" command to load executable/libraries directly."));
2346}
GDB Binutils - Deliverables
This page took 1.227348 seconds and 4 git commands to generate.