gdb/win32-nat.c

   1 /* Target-vector operations for controlling win32 child processes, for GDB.
   2
   3    Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 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 /* by Steve Chamberlain, sac@cygnus.com */
  26
  27 /* We assume we're being built with and will be used for cygwin.  */
  28
  29 #include "defs.h"
  30 #include "tm.h"                 /* required for SSE registers */
  31 #include "frame.h"              /* required by inferior.h */
  32 #include "inferior.h"
  33 #include "target.h"
  34 #include "gdbcore.h"
  35 #include "command.h"
  36 #include "completer.h"
  37 #include "regcache.h"
  38 #include "top.h"
  39 #include "i386-tdep.h"
  40 #include <signal.h>
  41 #include <sys/types.h>
  42 #include <fcntl.h>
  43 #include <stdlib.h>
  44 #include <windows.h>
  45 #include <imagehlp.h>
  46 #include <sys/cygwin.h>
  47
  48 #include "buildsym.h"
  49 #include "symfile.h"
  50 #include "objfiles.h"
  51 #include "gdb_string.h"
  52 #include "gdbthread.h"
  53 #include "gdbcmd.h"
  54 #include <sys/param.h>
  55 #include <unistd.h>
  56
  57 /* The ui's event loop. */
  58 extern int (*ui_loop_hook) (int signo);
  59
  60 /* If we're not using the old Cygwin header file set, define the
  61    following which never should have been in the generic Win32 API
  62    headers in the first place since they were our own invention... */
  63 #ifndef _GNU_H_WINDOWS_H
  64 enum
  65   {
  66     FLAG_TRACE_BIT = 0x100,
  67     CONTEXT_DEBUGGER = (CONTEXT_FULL | CONTEXT_FLOATING_POINT)
  68   };
  69 #endif
  70 #include <sys/procfs.h>
  71 #include <psapi.h>
  72
  73 #ifdef HAVE_SSE_REGS
  74 #define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_DEBUG_REGISTERS \
  75         | CONTEXT_EXTENDED_REGISTERS
  76 #else
  77 #define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_DEBUG_REGISTERS
  78 #endif
  79
  80 static unsigned dr[8];
  81 static int debug_registers_changed = 0;
  82 static int debug_registers_used = 0;
  83
  84 /* The string sent by cygwin when it processes a signal.
  85    FIXME: This should be in a cygwin include file. */
  86 #define CYGWIN_SIGNAL_STRING "cygwin: signal"
  87
  88 #define CHECK(x)        check (x, __FILE__,__LINE__)
  89 #define DEBUG_EXEC(x)   if (debug_exec)         printf x
  90 #define DEBUG_EVENTS(x) if (debug_events)       printf x
  91 #define DEBUG_MEM(x)    if (debug_memory)       printf x
  92 #define DEBUG_EXCEPT(x) if (debug_exceptions)   printf x
  93
  94 /* Forward declaration */
  95 extern struct target_ops child_ops;
  96
  97 static void child_stop (void);
  98 static int win32_child_thread_alive (ptid_t);
  99 void child_kill_inferior (void);
 100
 101 static int last_sig = 0;        /* Set if a signal was received from the
 102                                    debugged process */
 103 /* Thread information structure used to track information that is
 104    not available in gdb's thread structure. */
 105 typedef struct thread_info_struct
 106   {
 107     struct thread_info_struct *next;
 108     DWORD id;
 109     HANDLE h;
 110     char *name;
 111     int suspend_count;
 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
 131 /* User options. */
 132 static int new_console = 0;
 133 static int new_group = 1;
 134 static int debug_exec = 0;      /* show execution */
 135 static int debug_events = 0;    /* show events from kernel */
 136 static int debug_memory = 0;    /* show target memory accesses */
 137 static int debug_exceptions = 0;        /* show target exceptions */
 138
 139 /* This vector maps GDB's idea of a register's number into an address
 140    in the win32 exception context vector.
 141
 142    It also contains the bit mask needed to load the register in question.
 143
 144    One day we could read a reg, we could inspect the context we
 145    already have loaded, if it doesn't have the bit set that we need,
 146    we read that set of registers in using GetThreadContext.  If the
 147    context already contains what we need, we just unpack it. Then to
 148    write a register, first we have to ensure that the context contains
 149    the other regs of the group, and then we copy the info in and set
 150    out bit. */
 151
 152 #define context_offset(x) ((int)&(((CONTEXT *)NULL)->x))
 153 static const int mappings[] =
 154 {
 155   context_offset (Eax),
 156   context_offset (Ecx),
 157   context_offset (Edx),
 158   context_offset (Ebx),
 159   context_offset (Esp),
 160   context_offset (Ebp),
 161   context_offset (Esi),
 162   context_offset (Edi),
 163   context_offset (Eip),
 164   context_offset (EFlags),
 165   context_offset (SegCs),
 166   context_offset (SegSs),
 167   context_offset (SegDs),
 168   context_offset (SegEs),
 169   context_offset (SegFs),
 170   context_offset (SegGs),
 171   context_offset (FloatSave.RegisterArea[0 * 10]),
 172   context_offset (FloatSave.RegisterArea[1 * 10]),
 173   context_offset (FloatSave.RegisterArea[2 * 10]),
 174   context_offset (FloatSave.RegisterArea[3 * 10]),
 175   context_offset (FloatSave.RegisterArea[4 * 10]),
 176   context_offset (FloatSave.RegisterArea[5 * 10]),
 177   context_offset (FloatSave.RegisterArea[6 * 10]),
 178   context_offset (FloatSave.RegisterArea[7 * 10]),
 179   context_offset (FloatSave.ControlWord),
 180   context_offset (FloatSave.StatusWord),
 181   context_offset (FloatSave.TagWord),
 182   context_offset (FloatSave.ErrorSelector),
 183   context_offset (FloatSave.ErrorOffset),
 184   context_offset (FloatSave.DataSelector),
 185   context_offset (FloatSave.DataOffset),
 186   context_offset (FloatSave.ErrorSelector)
 187 #ifdef HAVE_SSE_REGS
 188   /* XMM0-7 */ ,
 189   context_offset (ExtendedRegisters[10*16]),
 190   context_offset (ExtendedRegisters[11*16]),
 191   context_offset (ExtendedRegisters[12*16]),
 192   context_offset (ExtendedRegisters[13*16]),
 193   context_offset (ExtendedRegisters[14*16]),
 194   context_offset (ExtendedRegisters[15*16]),
 195   context_offset (ExtendedRegisters[16*16]),
 196   context_offset (ExtendedRegisters[17*16]),
 197   /* MXCSR */
 198   context_offset (ExtendedRegisters[24])
 199 #endif
 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   {-1, -1}};
 222
 223 static void
 224 check (BOOL ok, const char *file, int line)
 225 {
 226   if (!ok)
 227     printf_filtered ("error return %s:%d was %lu\n", file, line,
 228                      GetLastError ());
 229 }
 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 *
 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
 250             th->context.ContextFlags = CONTEXT_DEBUGGER_DR;
 251             GetThreadContext (th->h, &th->context);
 252             if (id == current_event.dwThreadId)
 253               {
 254                 /* Copy dr values from that thread.  */
 255                 dr[0] = th->context.Dr0;
 256                 dr[1] = th->context.Dr1;
 257                 dr[2] = th->context.Dr2;
 258                 dr[3] = th->context.Dr3;
 259                 dr[6] = th->context.Dr6;
 260                 dr[7] = th->context.Dr7;
 261               }
 262           }
 263         return th;
 264       }
 265
 266   return NULL;
 267 }
 268
 269 /* Add a thread to the thread list */
 270 static thread_info *
 271 child_add_thread (DWORD id, HANDLE h)
 272 {
 273   thread_info *th;
 274
 275   if ((th = thread_rec (id, FALSE)))
 276     return th;
 277
 278   th = (thread_info *) xmalloc (sizeof (*th));
 279   memset (th, 0, sizeof (*th));
 280   th->id = id;
 281   th->h = h;
 282   th->next = thread_head.next;
 283   thread_head.next = th;
 284   add_thread (pid_to_ptid (id));
 285   /* Set the debug registers for the new thread in they are used.  */
 286   if (debug_registers_used)
 287     {
 288       /* Only change the value of the debug registers.  */
 289       th->context.ContextFlags = CONTEXT_DEBUG_REGISTERS;
 290       CHECK (GetThreadContext (th->h, &th->context));
 291       th->context.Dr0 = dr[0];
 292       th->context.Dr1 = dr[1];
 293       th->context.Dr2 = dr[2];
 294       th->context.Dr3 = dr[3];
 295       /* th->context.Dr6 = dr[6];
 296       FIXME: should we set dr6 also ?? */
 297       th->context.Dr7 = dr[7];
 298       CHECK (SetThreadContext (th->h, &th->context));
 299       th->context.ContextFlags = 0;
 300     }
 301   return th;
 302 }
 303
 304 /* Clear out any old thread list and reintialize it to a
 305    pristine state. */
 306 static void
 307 child_init_thread_list (void)
 308 {
 309   thread_info *th = &thread_head;
 310
 311   DEBUG_EVENTS (("gdb: child_init_thread_list\n"));
 312   init_thread_list ();
 313   while (th->next != NULL)
 314     {
 315       thread_info *here = th->next;
 316       th->next = here->next;
 317       (void) CloseHandle (here->h);
 318       xfree (here);
 319     }
 320 }
 321
 322 /* Delete a thread from the list of threads */
 323 static void
 324 child_delete_thread (DWORD id)
 325 {
 326   thread_info *th;
 327
 328   if (info_verbose)
 329     printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (pid_to_ptid (id)));
 330   delete_thread (pid_to_ptid (id));
 331
 332   for (th = &thread_head;
 333        th->next != NULL && th->next->id != id;
 334        th = th->next)
 335     continue;
 336
 337   if (th->next != NULL)
 338     {
 339       thread_info *here = th->next;
 340       th->next = here->next;
 341       CloseHandle (here->h);
 342       xfree (here);
 343     }
 344 }
 345
 346 static void
 347 do_child_fetch_inferior_registers (int r)
 348 {
 349   char *context_offset = ((char *) &current_thread->context) + mappings[r];
 350   long l;
 351   if (r == FCS_REGNUM)
 352     {
 353       l = *((long *) context_offset) & 0xffff;
 354       supply_register (r, (char *) &l);
 355     }
 356   else if (r == FOP_REGNUM)
 357     {
 358       l = (*((long *) context_offset) >> 16) & ((1 << 11) - 1);
 359       supply_register (r, (char *) &l);
 360     }
 361   else if (r >= 0)
 362     supply_register (r, context_offset);
 363   else
 364     {
 365       for (r = 0; r < NUM_REGS; r++)
 366         do_child_fetch_inferior_registers (r);
 367     }
 368 }
 369
 370 static void
 371 child_fetch_inferior_registers (int r)
 372 {
 373   current_thread = thread_rec (PIDGET (inferior_ptid), TRUE);
 374   do_child_fetch_inferior_registers (r);
 375 }
 376
 377 static void
 378 do_child_store_inferior_registers (int r)
 379 {
 380   if (r >= 0)
 381     read_register_gen (r, ((char *) &current_thread->context) + mappings[r]);
 382   else
 383     {
 384       for (r = 0; r < NUM_REGS; r++)
 385         do_child_store_inferior_registers (r);
 386     }
 387 }
 388
 389 /* Store a new register value into the current thread context */
 390 static void
 391 child_store_inferior_registers (int r)
 392 {
 393   current_thread = thread_rec (PIDGET (inferior_ptid), TRUE);
 394   do_child_store_inferior_registers (r);
 395 }
 396
 397 static int psapi_loaded = 0;
 398 static HMODULE psapi_module_handle = NULL;
 399 static BOOL WINAPI (*psapi_EnumProcessModules) (HANDLE, HMODULE *, DWORD, LPDWORD) = NULL;
 400 static BOOL WINAPI (*psapi_GetModuleInformation) (HANDLE, HMODULE, LPMODULEINFO, DWORD) = NULL;
 401 static DWORD WINAPI (*psapi_GetModuleFileNameExA) (HANDLE, HMODULE, LPSTR, DWORD) = NULL;
 402
 403 int
 404 psapi_get_dll_name (DWORD BaseAddress, char *dll_name_ret)
 405 {
 406   DWORD len;
 407   MODULEINFO mi;
 408   int i;
 409   HMODULE dh_buf[1];
 410   HMODULE *DllHandle = dh_buf;
 411   DWORD cbNeeded;
 412   BOOL ok;
 413
 414   if (!psapi_loaded ||
 415       psapi_EnumProcessModules == NULL ||
 416       psapi_GetModuleInformation == NULL ||
 417       psapi_GetModuleFileNameExA == NULL)
 418     {
 419       if (psapi_loaded)
 420         goto failed;
 421       psapi_loaded = 1;
 422       psapi_module_handle = LoadLibrary ("psapi.dll");
 423       if (!psapi_module_handle)
 424         {
 425           /* printf_unfiltered ("error loading psapi.dll: %u", GetLastError ()); */
 426           goto failed;
 427         }
 428       psapi_EnumProcessModules = GetProcAddress (psapi_module_handle, "EnumProcessModules");
 429       psapi_GetModuleInformation = GetProcAddress (psapi_module_handle, "GetModuleInformation");
 430       psapi_GetModuleFileNameExA = (void *) GetProcAddress (psapi_module_handle,
 431                                                     "GetModuleFileNameExA");
 432       if (psapi_EnumProcessModules == NULL ||
 433           psapi_GetModuleInformation == NULL ||
 434           psapi_GetModuleFileNameExA == NULL)
 435         goto failed;
 436     }
 437
 438   cbNeeded = 0;
 439   ok = (*psapi_EnumProcessModules) (current_process_handle,
 440                                     DllHandle,
 441                                     sizeof (HMODULE),
 442                                     &cbNeeded);
 443
 444   if (!ok || !cbNeeded)
 445     goto failed;
 446
 447   DllHandle = (HMODULE *) alloca (cbNeeded);
 448   if (!DllHandle)
 449     goto failed;
 450
 451   ok = (*psapi_EnumProcessModules) (current_process_handle,
 452                                     DllHandle,
 453                                     cbNeeded,
 454                                     &cbNeeded);
 455   if (!ok)
 456     goto failed;
 457
 458   for (i = 0; i < (int) (cbNeeded / sizeof (HMODULE)); i++)
 459     {
 460       if (!(*psapi_GetModuleInformation) (current_process_handle,
 461                                           DllHandle[i],
 462                                           &mi,
 463                                           sizeof (mi)))
 464         error ("Can't get module info");
 465
 466       len = (*psapi_GetModuleFileNameExA) (current_process_handle,
 467                                            DllHandle[i],
 468                                            dll_name_ret,
 469                                            MAX_PATH);
 470       if (len == 0)
 471         error ("Error getting dll name: %u\n", GetLastError ());
 472
 473       if ((DWORD) (mi.lpBaseOfDll) == BaseAddress)
 474         return 1;
 475     }
 476
 477 failed:
 478   dll_name_ret[0] = '\0';
 479   return 0;
 480 }
 481
 482 /* Encapsulate the information required in a call to
 483    symbol_file_add_args */
 484 struct safe_symbol_file_add_args
 485 {
 486   char *name;
 487   int from_tty;
 488   struct section_addr_info *addrs;
 489   int mainline;
 490   int flags;
 491   struct ui_file *err, *out;
 492   struct objfile *ret;
 493 };
 494
 495 /* Maintain a linked list of "so" information. */
 496 struct so_stuff
 497 {
 498   struct so_stuff *next;
 499   DWORD load_addr;
 500   int loaded;
 501   struct objfile *objfile;
 502   char name[1];
 503 } solib_start, *solib_end;
 504
 505 /* Call symbol_file_add with stderr redirected.  We don't care if there
 506    are errors. */
 507 static int
 508 safe_symbol_file_add_stub (void *argv)
 509 {
 510 #define p ((struct safe_symbol_file_add_args *)argv)
 511   struct so_stuff *so = &solib_start;
 512
 513   while ((so = so->next))
 514     if (so->loaded && strcasecmp (so->name, p->name) == 0)
 515       return 0;
 516   p->ret = symbol_file_add (p->name, p->from_tty, p->addrs, p->mainline, p->flags);
 517   return !!p->ret;
 518 #undef p
 519 }
 520
 521 /* Restore gdb's stderr after calling symbol_file_add */
 522 static void
 523 safe_symbol_file_add_cleanup (void *p)
 524 {
 525 #define sp ((struct safe_symbol_file_add_args *)p)
 526   gdb_flush (gdb_stderr);
 527   gdb_flush (gdb_stdout);
 528   ui_file_delete (gdb_stderr);
 529   ui_file_delete (gdb_stdout);
 530   gdb_stderr = sp->err;
 531   gdb_stdout = sp->out;
 532 #undef sp
 533 }
 534
 535 /* symbol_file_add wrapper that prevents errors from being displayed. */
 536 static struct objfile *
 537 safe_symbol_file_add (char *name, int from_tty,
 538                       struct section_addr_info *addrs,
 539                       int mainline, int flags)
 540 {
 541   struct safe_symbol_file_add_args p;
 542   struct cleanup *cleanup;
 543
 544   cleanup = make_cleanup (safe_symbol_file_add_cleanup, &p);
 545
 546   p.err = gdb_stderr;
 547   p.out = gdb_stdout;
 548   gdb_flush (gdb_stderr);
 549   gdb_flush (gdb_stdout);
 550   gdb_stderr = ui_file_new ();
 551   gdb_stdout = ui_file_new ();
 552   p.name = name;
 553   p.from_tty = from_tty;
 554   p.addrs = addrs;
 555   p.mainline = mainline;
 556   p.flags = flags;
 557   catch_errors (safe_symbol_file_add_stub, &p, "", RETURN_MASK_ERROR);
 558
 559   do_cleanups (cleanup);
 560   return p.ret;
 561 }
 562
 563 /* Remember the maximum DLL length for printing in info dll command. */
 564 int max_dll_name_len;
 565
 566 static void
 567 register_loaded_dll (const char *name, DWORD load_addr)
 568 {
 569   struct so_stuff *so;
 570   char ppath[MAX_PATH + 1];
 571   char buf[MAX_PATH + 1];
 572   char cwd[MAX_PATH + 1];
 573   char *p;
 574   WIN32_FIND_DATA w32_fd;
 575   HANDLE h = FindFirstFile(name, &w32_fd);
 576   size_t len;
 577
 578   FindClose (h);
 579   strcpy (buf, name);
 580   if (GetCurrentDirectory (MAX_PATH + 1, cwd))
 581     {
 582       p = strrchr (buf, '\\');
 583       if (p)
 584         p[1] = '\0';
 585       SetCurrentDirectory (buf);
 586       GetFullPathName (w32_fd.cFileName, MAX_PATH, buf, &p);
 587       SetCurrentDirectory (cwd);
 588     }
 589
 590   cygwin_conv_to_posix_path (buf, ppath);
 591   so = (struct so_stuff *) xmalloc (sizeof (struct so_stuff) + strlen (ppath) + 8 + 1);
 592   so->loaded = 0;
 593   so->load_addr = load_addr;
 594   so->next = NULL;
 595   so->objfile = NULL;
 596   strcpy (so->name, ppath);
 597
 598   solib_end->next = so;
 599   solib_end = so;
 600   len = strlen (ppath);
 601   if (len > max_dll_name_len)
 602     max_dll_name_len = len;
 603 }
 604
 605 /* Wait for child to do something.  Return pid of child, or -1 in case
 606    of error; store status through argument pointer OURSTATUS.  */
 607 static int
 608 handle_load_dll (void *dummy)
 609 {
 610   LOAD_DLL_DEBUG_INFO *event = &current_event.u.LoadDll;
 611   DWORD dll_name_ptr;
 612   DWORD done;
 613   char dll_buf[MAX_PATH + 1];
 614   char *dll_name = NULL;
 615   char *p;
 616
 617   dll_buf[0] = dll_buf[sizeof (dll_buf) - 1] = '\0';
 618
 619   if (!psapi_get_dll_name ((DWORD) (event->lpBaseOfDll), dll_buf))
 620     dll_buf[0] = dll_buf[sizeof (dll_buf) - 1] = '\0';
 621
 622   dll_name = dll_buf;
 623
 624   /* Attempt to read the name of the dll that was detected.
 625      This is documented to work only when actively debugging
 626      a program.  It will not work for attached processes. */
 627   if (dll_name == NULL || *dll_name == '\0')
 628     {
 629       DWORD size = event->fUnicode ? sizeof (WCHAR) : sizeof (char);
 630       int len = 0;
 631       char b[2];
 632
 633       ReadProcessMemory (current_process_handle,
 634                          (LPCVOID) event->lpImageName,
 635                          (char *) &dll_name_ptr,
 636                          sizeof (dll_name_ptr), &done);
 637
 638       /* See if we could read the address of a string, and that the
 639          address isn't null. */
 640
 641       if (done != sizeof (dll_name_ptr) || !dll_name_ptr)
 642         return 1;
 643
 644       do
 645         {
 646           ReadProcessMemory (current_process_handle,
 647                              (LPCVOID) (dll_name_ptr + len * size),
 648                              &b,
 649                              size,
 650                              &done);
 651           len++;
 652         }
 653       while ((b[0] != 0 || b[size - 1] != 0) && done == size);
 654
 655       dll_name = alloca (len);
 656
 657       if (event->fUnicode)
 658         {
 659           WCHAR *unicode_dll_name = (WCHAR *) alloca (len * sizeof (WCHAR));
 660           ReadProcessMemory (current_process_handle,
 661                              (LPCVOID) dll_name_ptr,
 662                              unicode_dll_name,
 663                              len * sizeof (WCHAR),
 664                              &done);
 665
 666           WideCharToMultiByte (CP_ACP, 0,
 667                                unicode_dll_name, len,
 668                                dll_name, len, 0, 0);
 669         }
 670       else
 671         {
 672           ReadProcessMemory (current_process_handle,
 673                              (LPCVOID) dll_name_ptr,
 674                              dll_name,
 675                              len,
 676                              &done);
 677         }
 678     }
 679
 680   if (!dll_name)
 681     return 1;
 682
 683   register_loaded_dll (dll_name, (DWORD) event->lpBaseOfDll + 0x1000);
 684
 685   return 1;
 686 }
 687
 688 static int
 689 handle_unload_dll (void *dummy)
 690 {
 691   DWORD lpBaseOfDll = (DWORD) current_event.u.UnloadDll.lpBaseOfDll + 0x1000;
 692   struct so_stuff *so;
 693
 694   for (so = &solib_start; so->next != NULL; so = so->next)
 695     if (so->next->load_addr == lpBaseOfDll)
 696       {
 697         struct so_stuff *sodel = so->next;
 698         so->next = sodel->next;
 699         if (!so->next)
 700           solib_end = so;
 701         if (sodel->objfile)
 702           free_objfile (sodel->objfile);
 703         xfree(sodel);
 704         return 1;
 705       }
 706   error ("Error: dll starting at 0x%lx not found.\n", (DWORD) lpBaseOfDll);
 707
 708   return 0;
 709 }
 710
 711 /* Return name of last loaded DLL. */
 712 char *
 713 child_solib_loaded_library_pathname (int pid)
 714 {
 715   return !solib_end || !solib_end->name[0] ? NULL : solib_end->name;
 716 }
 717
 718 /* Clear list of loaded DLLs. */
 719 void
 720 child_clear_solibs (void)
 721 {
 722   struct so_stuff *so, *so1 = solib_start.next;
 723
 724   while ((so = so1) != NULL)
 725     {
 726       so1 = so->next;
 727       xfree (so);
 728     }
 729
 730   solib_start.next = NULL;
 731   solib_start.objfile = NULL;
 732   solib_end = &solib_start;
 733   max_dll_name_len = sizeof ("DLL Name") - 1;
 734 }
 735
 736 /* Add DLL symbol information. */
 737 static struct objfile *
 738 solib_symbols_add (char *name, int from_tty, CORE_ADDR load_addr)
 739 {
 740   struct section_addr_info section_addrs;
 741
 742   /* The symbols in a dll are offset by 0x1000, which is the
 743      the offset from 0 of the first byte in an image - because
 744      of the file header and the section alignment. */
 745
 746   if (!name || !name[0])
 747     return NULL;
 748
 749   memset (&section_addrs, 0, sizeof (section_addrs));
 750   section_addrs.other[0].name = ".text";
 751   section_addrs.other[0].addr = load_addr;
 752   return safe_symbol_file_add (name, from_tty, NULL, 0, OBJF_SHARED);
 753 }
 754
 755 /* Load DLL symbol info. */
 756 void
 757 dll_symbol_command (char *args, int from_tty)
 758 {
 759   int n;
 760   dont_repeat ();
 761
 762   if (args == NULL)
 763     error ("dll-symbols requires a file name");
 764
 765   n = strlen (args);
 766   if (n > 4 && strcasecmp (args + n - 4, ".dll") != 0)
 767     {
 768       char *newargs = (char *) alloca (n + 4 + 1);
 769       strcpy (newargs, args);
 770       strcat (newargs, ".dll");
 771       args = newargs;
 772     }
 773
 774   safe_symbol_file_add (args, from_tty, NULL, 0, OBJF_SHARED | OBJF_USERLOADED);
 775 }
 776
 777 /* List currently loaded DLLs. */
 778 void
 779 info_dll_command (char *ignore, int from_tty)
 780 {
 781   struct so_stuff *so = &solib_start;
 782
 783   if (!so->next)
 784     return;
 785
 786   printf ("%*s  Load Address\n", -max_dll_name_len, "DLL Name");
 787   while ((so = so->next) != NULL)
 788     printf_filtered ("%*s  %08lx\n", -max_dll_name_len, so->name, so->load_addr);
 789
 790   return;
 791 }
 792
 793 /* Handle DEBUG_STRING output from child process.
 794    Cygwin prepends its messages with a "cygwin:".  Interpret this as
 795    a Cygwin signal.  Otherwise just print the string as a warning. */
 796 static int
 797 handle_output_debug_string (struct target_waitstatus *ourstatus)
 798 {
 799   char *s;
 800   int gotasig = FALSE;
 801
 802   if (!target_read_string
 803     ((CORE_ADDR) current_event.u.DebugString.lpDebugStringData, &s, 1024, 0)
 804       || !s || !*s)
 805     return gotasig;
 806
 807   if (strncmp (s, CYGWIN_SIGNAL_STRING, sizeof (CYGWIN_SIGNAL_STRING) - 1) != 0)
 808     {
 809       if (strncmp (s, "cYg", 3) != 0)
 810         warning ("%s", s);
 811     }
 812   else
 813     {
 814       char *p;
 815       int sig = strtol (s + sizeof (CYGWIN_SIGNAL_STRING) - 1, &p, 0);
 816       gotasig = target_signal_from_host (sig);
 817       ourstatus->value.sig = gotasig;
 818       if (gotasig)
 819         ourstatus->kind = TARGET_WAITKIND_STOPPED;
 820     }
 821
 822   xfree (s);
 823   return gotasig;
 824 }
 825
 826 static int
 827 handle_exception (struct target_waitstatus *ourstatus)
 828 {
 829   thread_info *th;
 830   DWORD code = current_event.u.Exception.ExceptionRecord.ExceptionCode;
 831
 832   ourstatus->kind = TARGET_WAITKIND_STOPPED;
 833
 834   /* Record the context of the current thread */
 835   th = thread_rec (current_event.dwThreadId, -1);
 836
 837   switch (code)
 838     {
 839     case EXCEPTION_ACCESS_VIOLATION:
 840       DEBUG_EXCEPT (("gdb: Target exception ACCESS_VIOLATION at 0x%08lx\n",
 841        (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress));
 842       ourstatus->value.sig = TARGET_SIGNAL_SEGV;
 843       last_sig = SIGSEGV;
 844       break;
 845     case STATUS_FLOAT_UNDERFLOW:
 846     case STATUS_FLOAT_DIVIDE_BY_ZERO:
 847     case STATUS_FLOAT_OVERFLOW:
 848     case STATUS_INTEGER_DIVIDE_BY_ZERO:
 849       DEBUG_EXCEPT (("gdb: Target exception STACK_OVERFLOW at 0x%08lx\n",
 850        (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress));
 851       ourstatus->value.sig = TARGET_SIGNAL_FPE;
 852       last_sig = SIGFPE;
 853       break;
 854     case STATUS_STACK_OVERFLOW:
 855       DEBUG_EXCEPT (("gdb: Target exception STACK_OVERFLOW at 0x%08lx\n",
 856        (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress));
 857       ourstatus->value.sig = TARGET_SIGNAL_SEGV;
 858       break;
 859     case EXCEPTION_BREAKPOINT:
 860       DEBUG_EXCEPT (("gdb: Target exception BREAKPOINT at 0x%08lx\n",
 861        (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress));
 862       ourstatus->value.sig = TARGET_SIGNAL_TRAP;
 863       break;
 864     case DBG_CONTROL_C:
 865       DEBUG_EXCEPT (("gdb: Target exception CONTROL_C at 0x%08lx\n",
 866        (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress));
 867       ourstatus->value.sig = TARGET_SIGNAL_INT;
 868       last_sig = SIGINT;        /* FIXME - should check pass state */
 869       break;
 870     case DBG_CONTROL_BREAK:
 871       DEBUG_EXCEPT (("gdb: Target exception CONTROL_BREAK at 0x%08lx\n",
 872        (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress));
 873       ourstatus->value.sig = TARGET_SIGNAL_INT;
 874       last_sig = SIGINT;        /* FIXME - should check pass state */
 875       break;
 876     case EXCEPTION_SINGLE_STEP:
 877       DEBUG_EXCEPT (("gdb: Target exception SINGLE_STEP at 0x%08lx\n",
 878        (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress));
 879       ourstatus->value.sig = TARGET_SIGNAL_TRAP;
 880       break;
 881     case EXCEPTION_ILLEGAL_INSTRUCTION:
 882       DEBUG_EXCEPT (("gdb: Target exception SINGLE_ILL at 0x%08lx\n",
 883        (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress));
 884       ourstatus->value.sig = TARGET_SIGNAL_ILL;
 885       last_sig = SIGILL;
 886       break;
 887     default:
 888       if (current_event.u.Exception.dwFirstChance)
 889         return 0;
 890       printf_unfiltered ("gdb: unknown target exception 0x%08lx at 0x%08lx\n",
 891                     current_event.u.Exception.ExceptionRecord.ExceptionCode,
 892         (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress);
 893       ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
 894       break;
 895     }
 896   exception_count++;
 897   return 1;
 898 }
 899
 900 /* Resume all artificially suspended threads if we are continuing
 901    execution */
 902 static BOOL
 903 child_continue (DWORD continue_status, int id)
 904 {
 905   int i;
 906   thread_info *th;
 907   BOOL res;
 908
 909   DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%ld, DBG_CONTINUE);\n",
 910                  current_event.dwProcessId, current_event.dwThreadId));
 911   res = ContinueDebugEvent (current_event.dwProcessId,
 912                             current_event.dwThreadId,
 913                             continue_status);
 914   continue_status = 0;
 915   if (res)
 916     for (th = &thread_head; (th = th->next) != NULL;)
 917       if (((id == -1) || (id == (int) th->id)) && th->suspend_count)
 918         {
 919
 920           for (i = 0; i < th->suspend_count; i++)
 921             (void) ResumeThread (th->h);
 922           th->suspend_count = 0;
 923           if (debug_registers_changed)
 924             {
 925               /* Only change the value of the debug reisters */
 926               th->context.ContextFlags = CONTEXT_DEBUG_REGISTERS;
 927               th->context.Dr0 = dr[0];
 928               th->context.Dr1 = dr[1];
 929               th->context.Dr2 = dr[2];
 930               th->context.Dr3 = dr[3];
 931               /* th->context.Dr6 = dr[6];
 932                  FIXME: should we set dr6 also ?? */
 933               th->context.Dr7 = dr[7];
 934               CHECK (SetThreadContext (th->h, &th->context));
 935               th->context.ContextFlags = 0;
 936             }
 937         }
 938
 939   debug_registers_changed = 0;
 940   return res;
 941 }
 942
 943 /* Get the next event from the child.  Return 1 if the event requires
 944    handling by WFI (or whatever).
 945  */
 946 static int
 947 get_child_debug_event (int pid, struct target_waitstatus *ourstatus)
 948 {
 949   BOOL debug_event;
 950   DWORD continue_status, event_code;
 951   thread_info *th = NULL;
 952   static thread_info dummy_thread_info;
 953   int retval = 0;
 954
 955   last_sig = 0;
 956
 957   if (!(debug_event = WaitForDebugEvent (&current_event, 1000)))
 958     goto out;
 959
 960   event_count++;
 961   continue_status = DBG_CONTINUE;
 962
 963   event_code = current_event.dwDebugEventCode;
 964   ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
 965
 966   switch (event_code)
 967     {
 968     case CREATE_THREAD_DEBUG_EVENT:
 969       DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
 970                      (unsigned) current_event.dwProcessId,
 971                      (unsigned) current_event.dwThreadId,
 972                      "CREATE_THREAD_DEBUG_EVENT"));
 973       /* Record the existence of this thread */
 974       th = child_add_thread (current_event.dwThreadId,
 975                              current_event.u.CreateThread.hThread);
 976       if (info_verbose)
 977         printf_unfiltered ("[New %s]\n",
 978                            target_pid_to_str (
 979                              pid_to_ptid (current_event.dwThreadId)));
 980       retval = current_event.dwThreadId;
 981       break;
 982
 983     case EXIT_THREAD_DEBUG_EVENT:
 984       DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
 985                      (unsigned) current_event.dwProcessId,
 986                      (unsigned) current_event.dwThreadId,
 987                      "EXIT_THREAD_DEBUG_EVENT"));
 988       child_delete_thread (current_event.dwThreadId);
 989       th = &dummy_thread_info;
 990       break;
 991
 992     case CREATE_PROCESS_DEBUG_EVENT:
 993       DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
 994                      (unsigned) current_event.dwProcessId,
 995                      (unsigned) current_event.dwThreadId,
 996                      "CREATE_PROCESS_DEBUG_EVENT"));
 997       CloseHandle (current_event.u.CreateProcessInfo.hFile);
 998       current_process_handle = current_event.u.CreateProcessInfo.hProcess;
 999
1000       main_thread_id = current_event.dwThreadId;
1001       /* Add the main thread */
1002 #if 0
1003       th = child_add_thread (current_event.dwProcessId,
1004                              current_event.u.CreateProcessInfo.hProcess);
1005 #endif
1006       th = child_add_thread (main_thread_id,
1007                              current_event.u.CreateProcessInfo.hThread);
1008       retval = ourstatus->value.related_pid = current_event.dwThreadId;
1009       break;
1010
1011     case EXIT_PROCESS_DEBUG_EVENT:
1012       DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1013                      (unsigned) current_event.dwProcessId,
1014                      (unsigned) current_event.dwThreadId,
1015                      "EXIT_PROCESS_DEBUG_EVENT"));
1016       ourstatus->kind = TARGET_WAITKIND_EXITED;
1017       ourstatus->value.integer = current_event.u.ExitProcess.dwExitCode;
1018       CloseHandle (current_process_handle);
1019       retval = main_thread_id;
1020       break;
1021
1022     case LOAD_DLL_DEBUG_EVENT:
1023       DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1024                      (unsigned) current_event.dwProcessId,
1025                      (unsigned) current_event.dwThreadId,
1026                      "LOAD_DLL_DEBUG_EVENT"));
1027       CloseHandle (current_event.u.LoadDll.hFile);
1028       catch_errors (handle_load_dll, NULL, (char *) "", RETURN_MASK_ALL);
1029       registers_changed ();     /* mark all regs invalid */
1030       ourstatus->kind = TARGET_WAITKIND_LOADED;
1031       ourstatus->value.integer = 0;
1032       retval = main_thread_id;
1033       break;
1034
1035     case UNLOAD_DLL_DEBUG_EVENT:
1036       DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1037                      (unsigned) current_event.dwProcessId,
1038                      (unsigned) current_event.dwThreadId,
1039                      "UNLOAD_DLL_DEBUG_EVENT"));
1040       catch_errors (handle_unload_dll, NULL, (char *) "", RETURN_MASK_ALL);
1041       registers_changed ();     /* mark all regs invalid */
1042       /* ourstatus->kind = TARGET_WAITKIND_UNLOADED;
1043          does not exist yet. */
1044       break;
1045
1046     case EXCEPTION_DEBUG_EVENT:
1047       DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1048                      (unsigned) current_event.dwProcessId,
1049                      (unsigned) current_event.dwThreadId,
1050                      "EXCEPTION_DEBUG_EVENT"));
1051       if (handle_exception (ourstatus))
1052         retval = current_event.dwThreadId;
1053       break;
1054
1055     case OUTPUT_DEBUG_STRING_EVENT:     /* message from the kernel */
1056       DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1057                      (unsigned) current_event.dwProcessId,
1058                      (unsigned) current_event.dwThreadId,
1059                      "OUTPUT_DEBUG_STRING_EVENT"));
1060       if (handle_output_debug_string (ourstatus))
1061         retval = main_thread_id;
1062       break;
1063
1064     default:
1065       printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",
1066                          (DWORD) current_event.dwProcessId,
1067                          (DWORD) current_event.dwThreadId);
1068       printf_unfiltered ("                 unknown event code %ld\n",
1069                          current_event.dwDebugEventCode);
1070       break;
1071     }
1072
1073   if (!retval)
1074     CHECK (child_continue (continue_status, -1));
1075   else
1076     {
1077       current_thread = th ? : thread_rec (current_event.dwThreadId, TRUE);
1078       inferior_ptid = pid_to_ptid (retval);
1079     }
1080
1081 out:
1082   return retval;
1083 }
1084
1085 /* Wait for interesting events to occur in the target process. */
1086 static ptid_t
1087 child_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
1088 {
1089   int pid = PIDGET (ptid);
1090
1091   /* We loop when we get a non-standard exception rather than return
1092      with a SPURIOUS because resume can try and step or modify things,
1093      which needs a current_thread->h.  But some of these exceptions mark
1094      the birth or death of threads, which mean that the current thread
1095      isn't necessarily what you think it is. */
1096
1097   while (1)
1098     {
1099       int retval = get_child_debug_event (pid, ourstatus);
1100       if (retval)
1101         return pid_to_ptid (retval);
1102       else
1103         {
1104           int detach = 0;
1105
1106           if (ui_loop_hook != NULL)
1107             detach = ui_loop_hook (0);
1108
1109           if (detach)
1110             child_kill_inferior ();
1111         }
1112     }
1113 }
1114
1115 static void
1116 do_initial_child_stuff (DWORD pid)
1117 {
1118   extern int stop_after_trap;
1119   int i;
1120
1121   last_sig = 0;
1122   event_count = 0;
1123   exception_count = 0;
1124   debug_registers_changed = 0;
1125   debug_registers_used = 0;
1126   for (i = 0; i < sizeof (dr) / sizeof (dr[0]); i++)
1127     dr[i] = 0;
1128   current_event.dwProcessId = pid;
1129   memset (&current_event, 0, sizeof (current_event));
1130   push_target (&child_ops);
1131   child_init_thread_list ();
1132   child_clear_solibs ();
1133   clear_proceed_status ();
1134   init_wait_for_inferior ();
1135
1136   target_terminal_init ();
1137   target_terminal_inferior ();
1138
1139   while (1)
1140     {
1141       stop_after_trap = 1;
1142       wait_for_inferior ();
1143       if (stop_signal != TARGET_SIGNAL_TRAP)
1144         resume (0, stop_signal);
1145       else
1146         break;
1147     }
1148   stop_after_trap = 0;
1149   return;
1150 }
1151
1152 /* Since Windows XP, detaching from a process is supported by Windows.
1153    The following code tries loading the appropriate functions dynamically.
1154    If loading these functions succeeds use them to actually detach from
1155    the inferior process, otherwise behave as usual, pretending that
1156    detach has worked. */
1157 static BOOL WINAPI (*DebugSetProcessKillOnExit)(BOOL);
1158 static BOOL WINAPI (*DebugActiveProcessStop)(DWORD);
1159
1160 static int
1161 has_detach_ability ()
1162 {
1163   static HMODULE kernel32 = NULL;
1164
1165   if (!kernel32)
1166     kernel32 = LoadLibrary ("kernel32.dll");
1167   if (kernel32)
1168     {
1169       if (!DebugSetProcessKillOnExit)
1170         DebugSetProcessKillOnExit = GetProcAddress (kernel32,
1171                                                  "DebugSetProcessKillOnExit");
1172       if (!DebugActiveProcessStop)
1173         DebugActiveProcessStop = GetProcAddress (kernel32,
1174                                                  "DebugActiveProcessStop");
1175       if (DebugSetProcessKillOnExit && DebugActiveProcessStop)
1176         return 1;
1177     }
1178   return 0;
1179 }
1180
1181 /* Attach to process PID, then initialize for debugging it.  */
1182 static void
1183 child_attach (char *args, int from_tty)
1184 {
1185   BOOL ok;
1186   DWORD pid;
1187
1188   if (!args)
1189     error_no_arg ("process-id to attach");
1190
1191   pid = strtoul (args, 0, 0);
1192   ok = DebugActiveProcess (pid);
1193
1194   if (!ok)
1195     error ("Can't attach to process.");
1196
1197   if (has_detach_ability ())
1198     {
1199       attach_flag = 1;
1200       DebugSetProcessKillOnExit (FALSE);
1201     }
1202
1203   if (from_tty)
1204     {
1205       char *exec_file = (char *) get_exec_file (0);
1206
1207       if (exec_file)
1208         printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
1209                            target_pid_to_str (pid_to_ptid (pid)));
1210       else
1211         printf_unfiltered ("Attaching to %s\n",
1212                            target_pid_to_str (pid_to_ptid (pid)));
1213
1214       gdb_flush (gdb_stdout);
1215     }
1216
1217   do_initial_child_stuff (pid);
1218   target_terminal_ours ();
1219 }
1220
1221 static void
1222 child_detach (char *args, int from_tty)
1223 {
1224   int detached = 1;
1225
1226   if (has_detach_ability ())
1227     {
1228       delete_command (NULL, 0);
1229       child_continue (DBG_CONTINUE, -1);
1230       if (!DebugActiveProcessStop (current_event.dwProcessId))
1231         {
1232           error ("Can't detach process %lu (error %lu)",
1233                  current_event.dwProcessId, GetLastError ());
1234           detached = 0;
1235         }
1236       DebugSetProcessKillOnExit (FALSE);
1237     }
1238   if (detached && from_tty)
1239     {
1240       char *exec_file = get_exec_file (0);
1241       if (exec_file == 0)
1242         exec_file = "";
1243       printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file,
1244                          current_event.dwProcessId);
1245       gdb_flush (gdb_stdout);
1246     }
1247   inferior_ptid = null_ptid;
1248   unpush_target (&child_ops);
1249 }
1250
1251 /* Print status information about what we're accessing.  */
1252
1253 static void
1254 child_files_info (struct target_ops *ignore)
1255 {
1256   printf_unfiltered ("\tUsing the running image of %s %s.\n",
1257       attach_flag ? "attached" : "child", target_pid_to_str (inferior_ptid));
1258 }
1259
1260 /* ARGSUSED */
1261 static void
1262 child_open (char *arg, int from_tty)
1263 {
1264   error ("Use the \"run\" command to start a Unix child process.");
1265 }
1266
1267 /* Start an inferior win32 child process and sets inferior_ptid to its pid.
1268    EXEC_FILE is the file to run.
1269    ALLARGS is a string containing the arguments to the program.
1270    ENV is the environment vector to pass.  Errors reported with error().  */
1271
1272 static void
1273 child_create_inferior (char *exec_file, char *allargs, char **env)
1274 {
1275   char real_path[MAXPATHLEN];
1276   char *winenv;
1277   char *temp;
1278   int envlen;
1279   int i;
1280   STARTUPINFO si;
1281   PROCESS_INFORMATION pi;
1282   BOOL ret;
1283   DWORD flags;
1284   char *args;
1285
1286   if (!exec_file)
1287     error ("No executable specified, use `target exec'.\n");
1288
1289   memset (&si, 0, sizeof (si));
1290   si.cb = sizeof (si);
1291
1292   cygwin_conv_to_win32_path (exec_file, real_path);
1293
1294   flags = DEBUG_ONLY_THIS_PROCESS;
1295
1296   if (new_group)
1297     flags |= CREATE_NEW_PROCESS_GROUP;
1298
1299   if (new_console)
1300     flags |= CREATE_NEW_CONSOLE;
1301
1302   args = alloca (strlen (real_path) + strlen (allargs) + 2);
1303
1304   strcpy (args, real_path);
1305
1306   strcat (args, " ");
1307   strcat (args, allargs);
1308
1309   /* Prepare the environment vars for CreateProcess.  */
1310   {
1311     /* This code use to assume all env vars were file names and would
1312        translate them all to win32 style.  That obviously doesn't work in the
1313        general case.  The current rule is that we only translate PATH.
1314        We need to handle PATH because we're about to call CreateProcess and
1315        it uses PATH to find DLL's.  Fortunately PATH has a well-defined value
1316        in both posix and win32 environments.  cygwin.dll will change it back
1317        to posix style if necessary.  */
1318
1319     static const char *conv_path_names[] =
1320     {
1321       "PATH=",
1322       0
1323     };
1324
1325     /* CreateProcess takes the environment list as a null terminated set of
1326        strings (i.e. two nulls terminate the list).  */
1327
1328     /* Get total size for env strings.  */
1329     for (envlen = 0, i = 0; env[i] && *env[i]; i++)
1330       {
1331         int j, len;
1332
1333         for (j = 0; conv_path_names[j]; j++)
1334           {
1335             len = strlen (conv_path_names[j]);
1336             if (strncmp (conv_path_names[j], env[i], len) == 0)
1337               {
1338                 if (cygwin_posix_path_list_p (env[i] + len))
1339                   envlen += len
1340                     + cygwin_posix_to_win32_path_list_buf_size (env[i] + len);
1341                 else
1342                   envlen += strlen (env[i]) + 1;
1343                 break;
1344               }
1345           }
1346         if (conv_path_names[j] == NULL)
1347           envlen += strlen (env[i]) + 1;
1348       }
1349
1350     winenv = alloca (envlen + 1);
1351
1352     /* Copy env strings into new buffer.  */
1353     for (temp = winenv, i = 0; env[i] && *env[i]; i++)
1354       {
1355         int j, len;
1356
1357         for (j = 0; conv_path_names[j]; j++)
1358           {
1359             len = strlen (conv_path_names[j]);
1360             if (strncmp (conv_path_names[j], env[i], len) == 0)
1361               {
1362                 if (cygwin_posix_path_list_p (env[i] + len))
1363                   {
1364                     memcpy (temp, env[i], len);
1365                     cygwin_posix_to_win32_path_list (env[i] + len, temp + len);
1366                   }
1367                 else
1368                   strcpy (temp, env[i]);
1369                 break;
1370               }
1371           }
1372         if (conv_path_names[j] == NULL)
1373           strcpy (temp, env[i]);
1374
1375         temp += strlen (temp) + 1;
1376       }
1377
1378     /* Final nil string to terminate new env.  */
1379     *temp = 0;
1380   }
1381
1382   ret = CreateProcess (0,
1383                        args,    /* command line */
1384                        NULL,    /* Security */
1385                        NULL,    /* thread */
1386                        TRUE,    /* inherit handles */
1387                        flags,   /* start flags */
1388                        winenv,
1389                        NULL,    /* current directory */
1390                        &si,
1391                        &pi);
1392   if (!ret)
1393     error ("Error creating process %s, (error %d)\n", exec_file, GetLastError ());
1394
1395   CloseHandle (pi.hThread);
1396   CloseHandle (pi.hProcess);
1397   do_initial_child_stuff (pi.dwProcessId);
1398
1399   /* child_continue (DBG_CONTINUE, -1); */
1400   proceed ((CORE_ADDR) - 1, TARGET_SIGNAL_0, 0);
1401 }
1402
1403 static void
1404 child_mourn_inferior (void)
1405 {
1406   (void) child_continue (DBG_CONTINUE, -1);
1407   i386_cleanup_dregs();
1408   unpush_target (&child_ops);
1409   generic_mourn_inferior ();
1410 }
1411
1412 /* Send a SIGINT to the process group.  This acts just like the user typed a
1413    ^C on the controlling terminal. */
1414
1415 static void
1416 child_stop (void)
1417 {
1418   DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
1419   CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, current_event.dwProcessId));
1420   registers_changed ();         /* refresh register state */
1421 }
1422
1423 int
1424 child_xfer_memory (CORE_ADDR memaddr, char *our, int len,
1425                    int write, struct mem_attrib *mem,
1426                    struct target_ops *target)
1427 {
1428   DWORD done;
1429   if (write)
1430     {
1431       DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
1432                   len, (DWORD) memaddr));
1433       WriteProcessMemory (current_process_handle, (LPVOID) memaddr, our,
1434                           len, &done);
1435       FlushInstructionCache (current_process_handle, (LPCVOID) memaddr, len);
1436     }
1437   else
1438     {
1439       DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
1440                   len, (DWORD) memaddr));
1441       ReadProcessMemory (current_process_handle, (LPCVOID) memaddr, our, len,
1442                          &done);
1443     }
1444   return done;
1445 }
1446
1447 void
1448 child_kill_inferior (void)
1449 {
1450   CHECK (TerminateProcess (current_process_handle, 0));
1451
1452   for (;;)
1453     {
1454       if (!child_continue (DBG_CONTINUE, -1))
1455         break;
1456       if (!WaitForDebugEvent (&current_event, INFINITE))
1457         break;
1458       if (current_event.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT)
1459         break;
1460     }
1461
1462   CHECK (CloseHandle (current_process_handle));
1463
1464   /* this may fail in an attached process so don't check. */
1465   (void) CloseHandle (current_thread->h);
1466   target_mourn_inferior ();     /* or just child_mourn_inferior? */
1467 }
1468
1469 void
1470 child_resume (ptid_t ptid, int step, enum target_signal sig)
1471 {
1472   thread_info *th;
1473   DWORD continue_status = last_sig > 0 && last_sig < NSIG ?
1474   DBG_EXCEPTION_NOT_HANDLED : DBG_CONTINUE;
1475   int pid = PIDGET (ptid);
1476
1477   last_sig = 0;
1478
1479   DEBUG_EXEC (("gdb: child_resume (pid=%d, step=%d, sig=%d);\n",
1480                pid, step, sig));
1481
1482   /* Get context for currently selected thread */
1483   th = thread_rec (current_event.dwThreadId, FALSE);
1484   if (th)
1485     {
1486       if (step)
1487         {
1488           /* Single step by setting t bit */
1489           child_fetch_inferior_registers (PS_REGNUM);
1490           th->context.EFlags |= FLAG_TRACE_BIT;
1491         }
1492
1493       if (th->context.ContextFlags)
1494         {
1495      if (debug_registers_changed)
1496        {
1497           th->context.Dr0 = dr[0];
1498           th->context.Dr1 = dr[1];
1499           th->context.Dr2 = dr[2];
1500           th->context.Dr3 = dr[3];
1501           /* th->context.Dr6 = dr[6];
1502            FIXME: should we set dr6 also ?? */
1503           th->context.Dr7 = dr[7];
1504        }
1505           CHECK (SetThreadContext (th->h, &th->context));
1506           th->context.ContextFlags = 0;
1507         }
1508     }
1509
1510   /* Allow continuing with the same signal that interrupted us.
1511      Otherwise complain. */
1512
1513   child_continue (continue_status, pid);
1514 }
1515
1516 static void
1517 child_prepare_to_store (void)
1518 {
1519   /* Do nothing, since we can store individual regs */
1520 }
1521
1522 static int
1523 child_can_run (void)
1524 {
1525   return 1;
1526 }
1527
1528 static void
1529 child_close (int x)
1530 {
1531   DEBUG_EVENTS (("gdb: child_close, inferior_ptid=%d\n",
1532                 PIDGET (inferior_ptid)));
1533 }
1534
1535 struct target_ops child_ops;
1536
1537 static void
1538 init_child_ops (void)
1539 {
1540   child_ops.to_shortname = "child";
1541   child_ops.to_longname = "Win32 child process";
1542   child_ops.to_doc = "Win32 child process (started by the \"run\" command).";
1543   child_ops.to_open = child_open;
1544   child_ops.to_close = child_close;
1545   child_ops.to_attach = child_attach;
1546   child_ops.to_detach = child_detach;
1547   child_ops.to_resume = child_resume;
1548   child_ops.to_wait = child_wait;
1549   child_ops.to_fetch_registers = child_fetch_inferior_registers;
1550   child_ops.to_store_registers = child_store_inferior_registers;
1551   child_ops.to_prepare_to_store = child_prepare_to_store;
1552   child_ops.to_xfer_memory = child_xfer_memory;
1553   child_ops.to_files_info = child_files_info;
1554   child_ops.to_insert_breakpoint = memory_insert_breakpoint;
1555   child_ops.to_remove_breakpoint = memory_remove_breakpoint;
1556   child_ops.to_terminal_init = terminal_init_inferior;
1557   child_ops.to_terminal_inferior = terminal_inferior;
1558   child_ops.to_terminal_ours_for_output = terminal_ours_for_output;
1559   child_ops.to_terminal_ours = terminal_ours;
1560   child_ops.to_terminal_info = child_terminal_info;
1561   child_ops.to_kill = child_kill_inferior;
1562   child_ops.to_load = 0;
1563   child_ops.to_lookup_symbol = 0;
1564   child_ops.to_create_inferior = child_create_inferior;
1565   child_ops.to_mourn_inferior = child_mourn_inferior;
1566   child_ops.to_can_run = child_can_run;
1567   child_ops.to_notice_signals = 0;
1568   child_ops.to_thread_alive = win32_child_thread_alive;
1569   child_ops.to_pid_to_str = cygwin_pid_to_str;
1570   child_ops.to_stop = child_stop;
1571   child_ops.to_stratum = process_stratum;
1572   child_ops.DONT_USE = 0;
1573   child_ops.to_has_all_memory = 1;
1574   child_ops.to_has_memory = 1;
1575   child_ops.to_has_stack = 1;
1576   child_ops.to_has_registers = 1;
1577   child_ops.to_has_execution = 1;
1578   child_ops.to_sections = 0;
1579   child_ops.to_sections_end = 0;
1580   child_ops.to_magic = OPS_MAGIC;
1581 }
1582
1583 void
1584 _initialize_inftarg (void)
1585 {
1586   struct cmd_list_element *c;
1587
1588   init_child_ops ();
1589
1590   c = add_com ("dll-symbols", class_files, dll_symbol_command,
1591                "Load dll library symbols from FILE.");
1592   c->completer = filename_completer;
1593
1594   add_com_alias ("sharedlibrary", "dll-symbols", class_alias, 1);
1595
1596   add_show_from_set (add_set_cmd ("new-console", class_support, var_boolean,
1597                                   (char *) &new_console,
1598                  "Set creation of new console when creating child process.",
1599                                   &setlist),
1600                      &showlist);
1601
1602   add_show_from_set (add_set_cmd ("new-group", class_support, var_boolean,
1603                                   (char *) &new_group,
1604                    "Set creation of new group when creating child process.",
1605                                   &setlist),
1606                      &showlist);
1607
1608   add_show_from_set (add_set_cmd ("debugexec", class_support, var_boolean,
1609                                   (char *) &debug_exec,
1610                        "Set whether to display execution in child process.",
1611                                   &setlist),
1612                      &showlist);
1613
1614   add_show_from_set (add_set_cmd ("debugevents", class_support, var_boolean,
1615                                   (char *) &debug_events,
1616                    "Set whether to display kernel events in child process.",
1617                                   &setlist),
1618                      &showlist);
1619
1620   add_show_from_set (add_set_cmd ("debugmemory", class_support, var_boolean,
1621                                   (char *) &debug_memory,
1622                  "Set whether to display memory accesses in child process.",
1623                                   &setlist),
1624                      &showlist);
1625
1626   add_show_from_set (add_set_cmd ("debugexceptions", class_support, var_boolean,
1627                                   (char *) &debug_exceptions,
1628                "Set whether to display kernel exceptions in child process.",
1629                                   &setlist),
1630                      &showlist);
1631
1632   add_info ("dll", info_dll_command, "Status of loaded DLLs.");
1633   add_info_alias ("sharedlibrary", "dll", 1);
1634
1635   add_target (&child_ops);
1636 }
1637
1638 /* Hardware watchpoint support, adapted from go32-nat.c code.  */
1639
1640 /* Pass the address ADDR to the inferior in the I'th debug register.
1641    Here we just store the address in dr array, the registers will be
1642    actually set up when child_continue is called.  */
1643 void
1644 cygwin_set_dr (int i, CORE_ADDR addr)
1645 {
1646   if (i < 0 || i > 3)
1647     internal_error (__FILE__, __LINE__,
1648                     "Invalid register %d in cygwin_set_dr.\n", i);
1649   dr[i] = (unsigned) addr;
1650   debug_registers_changed = 1;
1651   debug_registers_used = 1;
1652 }
1653
1654 /* Pass the value VAL to the inferior in the DR7 debug control
1655    register.  Here we just store the address in D_REGS, the watchpoint
1656    will be actually set up in child_wait.  */
1657 void
1658 cygwin_set_dr7 (unsigned val)
1659 {
1660   dr[7] = val;
1661   debug_registers_changed = 1;
1662   debug_registers_used = 1;
1663 }
1664
1665 /* Get the value of the DR6 debug status register from the inferior.
1666    Here we just return the value stored in dr[6]
1667    by the last call to thread_rec for current_event.dwThreadId id.  */
1668 unsigned
1669 cygwin_get_dr6 (void)
1670 {
1671   return dr[6];
1672 }
1673
1674
1675 /* Determine if the thread referenced by "pid" is alive
1676    by "polling" it.  If WaitForSingleObject returns WAIT_OBJECT_0
1677    it means that the pid has died.  Otherwise it is assumed to be alive. */
1678 static int
1679 win32_child_thread_alive (ptid_t ptid)
1680 {
1681   int pid = PIDGET (ptid);
1682
1683   return WaitForSingleObject (thread_rec (pid, FALSE)->h, 0) == WAIT_OBJECT_0 ?
1684     FALSE : TRUE;
1685 }
1686
1687 /* Convert pid to printable format. */
1688 char *
1689 cygwin_pid_to_str (ptid_t ptid)
1690 {
1691   static char buf[80];
1692   int pid = PIDGET (ptid);
1693
1694   if ((DWORD) pid == current_event.dwProcessId)
1695     sprintf (buf, "process %d", pid);
1696   else
1697     sprintf (buf, "thread %ld.0x%x", current_event.dwProcessId, pid);
1698   return buf;
1699 }
1700
1701 static int
1702 core_dll_symbols_add (char *dll_name, DWORD base_addr)
1703 {
1704   struct objfile *objfile;
1705   char *objfile_basename;
1706   const char *dll_basename;
1707
1708   if (!(dll_basename = strrchr (dll_name, '/')))
1709     dll_basename = dll_name;
1710   else
1711     dll_basename++;
1712
1713   ALL_OBJFILES (objfile)
1714   {
1715     objfile_basename = strrchr (objfile->name, '/');
1716
1717     if (objfile_basename &&
1718         strcmp (dll_basename, objfile_basename + 1) == 0)
1719       {
1720         printf_unfiltered ("%08lx:%s (symbols previously loaded)\n",
1721                            base_addr, dll_name);
1722         goto out;
1723       }
1724   }
1725
1726   register_loaded_dll (dll_name, base_addr + 0x1000);
1727   solib_symbols_add (dll_name, 0, (CORE_ADDR) base_addr + 0x1000);
1728
1729 out:
1730   return 1;
1731 }
1732
1733 typedef struct
1734 {
1735   struct target_ops *target;
1736   bfd_vma addr;
1737 }
1738 map_code_section_args;
1739
1740 static void
1741 map_single_dll_code_section (bfd * abfd, asection * sect, void *obj)
1742 {
1743   int old;
1744   int update_coreops;
1745   struct section_table *new_target_sect_ptr;
1746
1747   map_code_section_args *args = (map_code_section_args *) obj;
1748   struct target_ops *target = args->target;
1749   if (sect->flags & SEC_CODE)
1750     {
1751       update_coreops = core_ops.to_sections == target->to_sections;
1752
1753       if (target->to_sections)
1754         {
1755           old = target->to_sections_end - target->to_sections;
1756           target->to_sections = (struct section_table *)
1757             xrealloc ((char *) target->to_sections,
1758                       (sizeof (struct section_table)) * (1 + old));
1759         }
1760       else
1761         {
1762           old = 0;
1763           target->to_sections = (struct section_table *)
1764             xmalloc ((sizeof (struct section_table)));
1765         }
1766       target->to_sections_end = target->to_sections + (1 + old);
1767
1768       /* Update the to_sections field in the core_ops structure
1769          if needed.  */
1770       if (update_coreops)
1771         {
1772           core_ops.to_sections = target->to_sections;
1773           core_ops.to_sections_end = target->to_sections_end;
1774         }
1775       new_target_sect_ptr = target->to_sections + old;
1776       new_target_sect_ptr->addr = args->addr + bfd_section_vma (abfd, sect);
1777       new_target_sect_ptr->endaddr = args->addr + bfd_section_vma (abfd, sect) +
1778         bfd_section_size (abfd, sect);;
1779       new_target_sect_ptr->the_bfd_section = sect;
1780       new_target_sect_ptr->bfd = abfd;
1781     }
1782 }
1783
1784 static int
1785 dll_code_sections_add (const char *dll_name, int base_addr, struct target_ops *target)
1786 {
1787   bfd *dll_bfd;
1788   map_code_section_args map_args;
1789   asection *lowest_sect;
1790   char *name;
1791   if (dll_name == NULL || target == NULL)
1792     return 0;
1793   name = xstrdup (dll_name);
1794   dll_bfd = bfd_openr (name, "pei-i386");
1795   if (dll_bfd == NULL)
1796     return 0;
1797
1798   if (bfd_check_format (dll_bfd, bfd_object))
1799     {
1800       lowest_sect = bfd_get_section_by_name (dll_bfd, ".text");
1801       if (lowest_sect == NULL)
1802         return 0;
1803       map_args.target = target;
1804       map_args.addr = base_addr - bfd_section_vma (dll_bfd, lowest_sect);
1805
1806       bfd_map_over_sections (dll_bfd, &map_single_dll_code_section, (void *) (&map_args));
1807     }
1808
1809   return 1;
1810 }
1811
1812 static void
1813 core_section_load_dll_symbols (bfd * abfd, asection * sect, void *obj)
1814 {
1815   struct target_ops *target = (struct target_ops *) obj;
1816
1817   DWORD base_addr;
1818
1819   int dll_name_size;
1820   char *dll_name = NULL;
1821   char *buf = NULL;
1822   struct win32_pstatus *pstatus;
1823   char *p;
1824
1825   if (strncmp (sect->name, ".module", 7))
1826     return;
1827
1828   buf = (char *) xmalloc (sect->_raw_size + 1);
1829   if (!buf)
1830     {
1831       printf_unfiltered ("memory allocation failed for %s\n", sect->name);
1832       goto out;
1833     }
1834   if (!bfd_get_section_contents (abfd, sect, buf, 0, sect->_raw_size))
1835     goto out;
1836
1837   pstatus = (struct win32_pstatus *) buf;
1838
1839   memmove (&base_addr, &(pstatus->data.module_info.base_address), sizeof (base_addr));
1840   dll_name_size = pstatus->data.module_info.module_name_size;
1841   if (offsetof (struct win32_pstatus, data.module_info.module_name) + dll_name_size > sect->_raw_size)
1842       goto out;
1843
1844   dll_name = (char *) xmalloc (dll_name_size + 1);
1845   if (!dll_name)
1846     {
1847       printf_unfiltered ("memory allocation failed for %s\n", sect->name);
1848       goto out;
1849     }
1850   strncpy (dll_name, pstatus->data.module_info.module_name, dll_name_size);
1851
1852   while ((p = strchr (dll_name, '\\')))
1853     *p = '/';
1854
1855   if (!core_dll_symbols_add (dll_name, (DWORD) base_addr))
1856     printf_unfiltered ("%s: Failed to load dll symbols.\n", dll_name);
1857
1858   if (!dll_code_sections_add (dll_name, (DWORD) base_addr + 0x1000, target))
1859     printf_unfiltered ("%s: Failed to map dll code sections.\n", dll_name);
1860
1861 out:
1862   if (buf)
1863     xfree (buf);
1864   if (dll_name)
1865     xfree (dll_name);
1866   return;
1867 }
1868
1869 void
1870 child_solib_add (char *filename, int from_tty, struct target_ops *target,
1871                  int readsyms)
1872 {
1873   if (!readsyms)
1874     return;
1875   if (core_bfd)
1876     {
1877       child_clear_solibs ();
1878       bfd_map_over_sections (core_bfd, &core_section_load_dll_symbols, target);
1879     }
1880   else
1881     {
1882       if (solib_end && solib_end->name)
1883              solib_end->objfile = solib_symbols_add (solib_end->name, from_tty,
1884                                                 solib_end->load_addr);
1885     }
1886 }
1887
1888 static void
1889 fetch_elf_core_registers (char *core_reg_sect,
1890                           unsigned core_reg_size,
1891                           int which,
1892                           CORE_ADDR reg_addr)
1893 {
1894   int r;
1895   if (core_reg_size < sizeof (CONTEXT))
1896     {
1897       error ("Core file register section too small (%u bytes).", core_reg_size);
1898       return;
1899     }
1900   for (r = 0; r < NUM_REGS; r++)
1901     supply_register (r, core_reg_sect + mappings[r]);
1902 }
1903
1904 static struct core_fns win32_elf_core_fns =
1905 {
1906   bfd_target_elf_flavour,
1907   default_check_format,
1908   default_core_sniffer,
1909   fetch_elf_core_registers,
1910   NULL
1911 };
1912
1913 void
1914 _initialize_core_win32 (void)
1915 {
1916   add_core_fns (&win32_elf_core_fns);
1917 }
1918
1919 void
1920 _initialize_check_for_gdb_ini (void)
1921 {
1922   char *homedir;
1923   if (inhibit_gdbinit)
1924     return;
1925
1926   homedir = getenv ("HOME");
1927   if (homedir)
1928     {
1929       char *p;
1930       char *oldini = (char *) alloca (strlen (homedir) +
1931                                       sizeof ("/gdb.ini"));
1932       strcpy (oldini, homedir);
1933       p = strchr (oldini, '\0');
1934       if (p > oldini && p[-1] != '/')
1935         *p++ = '/';
1936       strcpy (p, "gdb.ini");
1937       if (access (oldini, 0) == 0)
1938         {
1939           int len = strlen (oldini);
1940           char *newini = alloca (len + 1);
1941           sprintf (newini, "%.*s.gdbinit", len - (sizeof ("gdb.ini") - 1), oldini);
1942           warning ("obsolete '%s' found. Rename to '%s'.", oldini, newini);
1943         }
1944     }
1945 }