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