OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [win32-nat.c] - Blame information for rev 24

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.