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