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