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