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