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