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