gdb/win32-nat.c

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