gdb/win32-nat.c

   1 /* Target-vector operations for controlling win32 child processes, for GDB.
   2    Copyright 1995, 1996 Free Software Foundation, Inc.
   3    Contributed by Cygnus Support.
   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, Boston, MA 02111-1307, USA.  */
  20
  21 /* by Steve Chamberlain, sac@cygnus.com */
  22
  23 /* We assume we're being built with and will be used for cygwin32.  */
  24
  25 #include "defs.h"
  26 #include "frame.h"              /* required by inferior.h */
  27 #include "inferior.h"
  28 #include "target.h"
  29 #include "wait.h"
  30 #include "gdbcore.h"
  31 #include "command.h"
  32 #include <signal.h>
  33 #include <sys/types.h>
  34 #include <fcntl.h>
  35 #include <windows.h>
  36 #include "buildsym.h"
  37 #include "symfile.h"
  38 #include "objfiles.h"
  39 #include "gdb_string.h"
  40 #include "gdbthread.h"
  41 #include "gdbcmd.h"
  42 #include <sys/param.h>
  43 #include <unistd.h>
  44
  45 #define CHECK(x)        check (x, __FILE__,__LINE__)
  46 #define DEBUG_EXEC(x)   if (debug_exec)         printf x
  47 #define DEBUG_EVENTS(x) if (debug_events)       printf x
  48 #define DEBUG_MEM(x)    if (debug_memory)       printf x
  49 #define DEBUG_EXCEPT(x) if (debug_exceptions)   printf x
  50
  51 /* Forward declaration */
  52 extern struct target_ops child_ops;
  53
  54 /* The most recently read context. Inspect ContextFlags to see what
  55    bits are valid. */
  56
  57 static CONTEXT context;
  58
  59 /* The process and thread handles for the above context. */
  60
  61 static HANDLE current_process;
  62 static HANDLE current_thread;
  63 static int current_process_id;
  64 static int current_thread_id;
  65
  66 /* Counts of things. */
  67 static int exception_count = 0;
  68 static int event_count = 0;
  69
  70 /* User options. */
  71 static int new_console = 0;
  72 static int new_group = 0;
  73 static int debug_exec = 0;              /* show execution */
  74 static int debug_events = 0;            /* show events from kernel */
  75 static int debug_memory = 0;            /* show target memory accesses */
  76 static int debug_exceptions = 0;        /* show target exceptions */
  77
  78 /* This vector maps GDB's idea of a register's number into an address
  79    in the win32 exception context vector.
  80
  81    It also contains the bit mask needed to load the register in question.
  82
  83    One day we could read a reg, we could inspect the context we
  84    already have loaded, if it doesn't have the bit set that we need,
  85    we read that set of registers in using GetThreadContext.  If the
  86    context already contains what we need, we just unpack it. Then to
  87    write a register, first we have to ensure that the context contains
  88    the other regs of the group, and then we copy the info in and set
  89    out bit. */
  90
  91 struct regmappings
  92   {
  93     char *incontext;
  94     int mask;
  95   };
  96
  97
  98 static const struct regmappings  mappings[] =
  99 {
 100 #ifdef __PPC__
 101   {(char *) &context.Gpr0, CONTEXT_INTEGER},
 102   {(char *) &context.Gpr1, CONTEXT_INTEGER},
 103   {(char *) &context.Gpr2, CONTEXT_INTEGER},
 104   {(char *) &context.Gpr3, CONTEXT_INTEGER},
 105   {(char *) &context.Gpr4, CONTEXT_INTEGER},
 106   {(char *) &context.Gpr5, CONTEXT_INTEGER},
 107   {(char *) &context.Gpr6, CONTEXT_INTEGER},
 108   {(char *) &context.Gpr7, CONTEXT_INTEGER},
 109
 110   {(char *) &context.Gpr8, CONTEXT_INTEGER},
 111   {(char *) &context.Gpr9, CONTEXT_INTEGER},
 112   {(char *) &context.Gpr10, CONTEXT_INTEGER},
 113   {(char *) &context.Gpr11, CONTEXT_INTEGER},
 114   {(char *) &context.Gpr12, CONTEXT_INTEGER},
 115   {(char *) &context.Gpr13, CONTEXT_INTEGER},
 116   {(char *) &context.Gpr14, CONTEXT_INTEGER},
 117   {(char *) &context.Gpr15, CONTEXT_INTEGER},
 118
 119   {(char *) &context.Gpr16, CONTEXT_INTEGER},
 120   {(char *) &context.Gpr17, CONTEXT_INTEGER},
 121   {(char *) &context.Gpr18, CONTEXT_INTEGER},
 122   {(char *) &context.Gpr19, CONTEXT_INTEGER},
 123   {(char *) &context.Gpr20, CONTEXT_INTEGER},
 124   {(char *) &context.Gpr21, CONTEXT_INTEGER},
 125   {(char *) &context.Gpr22, CONTEXT_INTEGER},
 126   {(char *) &context.Gpr23, CONTEXT_INTEGER},
 127
 128   {(char *) &context.Gpr24, CONTEXT_INTEGER},
 129   {(char *) &context.Gpr25, CONTEXT_INTEGER},
 130   {(char *) &context.Gpr26, CONTEXT_INTEGER},
 131   {(char *) &context.Gpr27, CONTEXT_INTEGER},
 132   {(char *) &context.Gpr28, CONTEXT_INTEGER},
 133   {(char *) &context.Gpr29, CONTEXT_INTEGER},
 134   {(char *) &context.Gpr30, CONTEXT_INTEGER},
 135   {(char *) &context.Gpr31, CONTEXT_INTEGER},
 136
 137   {(char *) &context.Fpr0, CONTEXT_FLOATING_POINT},
 138   {(char *) &context.Fpr1, CONTEXT_FLOATING_POINT},
 139   {(char *) &context.Fpr2, CONTEXT_FLOATING_POINT},
 140   {(char *) &context.Fpr3, CONTEXT_FLOATING_POINT},
 141   {(char *) &context.Fpr4, CONTEXT_FLOATING_POINT},
 142   {(char *) &context.Fpr5, CONTEXT_FLOATING_POINT},
 143   {(char *) &context.Fpr6, CONTEXT_FLOATING_POINT},
 144   {(char *) &context.Fpr7, CONTEXT_FLOATING_POINT},
 145
 146   {(char *) &context.Fpr8, CONTEXT_FLOATING_POINT},
 147   {(char *) &context.Fpr9, CONTEXT_FLOATING_POINT},
 148   {(char *) &context.Fpr10, CONTEXT_FLOATING_POINT},
 149   {(char *) &context.Fpr11, CONTEXT_FLOATING_POINT},
 150   {(char *) &context.Fpr12, CONTEXT_FLOATING_POINT},
 151   {(char *) &context.Fpr13, CONTEXT_FLOATING_POINT},
 152   {(char *) &context.Fpr14, CONTEXT_FLOATING_POINT},
 153   {(char *) &context.Fpr15, CONTEXT_FLOATING_POINT},
 154
 155   {(char *) &context.Fpr16, CONTEXT_FLOATING_POINT},
 156   {(char *) &context.Fpr17, CONTEXT_FLOATING_POINT},
 157   {(char *) &context.Fpr18, CONTEXT_FLOATING_POINT},
 158   {(char *) &context.Fpr19, CONTEXT_FLOATING_POINT},
 159   {(char *) &context.Fpr20, CONTEXT_FLOATING_POINT},
 160   {(char *) &context.Fpr21, CONTEXT_FLOATING_POINT},
 161   {(char *) &context.Fpr22, CONTEXT_FLOATING_POINT},
 162   {(char *) &context.Fpr23, CONTEXT_FLOATING_POINT},
 163
 164   {(char *) &context.Fpr24, CONTEXT_FLOATING_POINT},
 165   {(char *) &context.Fpr25, CONTEXT_FLOATING_POINT},
 166   {(char *) &context.Fpr26, CONTEXT_FLOATING_POINT},
 167   {(char *) &context.Fpr27, CONTEXT_FLOATING_POINT},
 168   {(char *) &context.Fpr28, CONTEXT_FLOATING_POINT},
 169   {(char *) &context.Fpr29, CONTEXT_FLOATING_POINT},
 170   {(char *) &context.Fpr30, CONTEXT_FLOATING_POINT},
 171   {(char *) &context.Fpr31, CONTEXT_FLOATING_POINT},
 172
 173
 174   {(char *) &context.Iar, CONTEXT_CONTROL},
 175   {(char *) &context.Msr, CONTEXT_CONTROL},
 176   {(char *) &context.Cr,  CONTEXT_INTEGER},
 177   {(char *) &context.Lr,  CONTEXT_CONTROL},
 178   {(char *) &context.Ctr, CONTEXT_CONTROL},
 179
 180   {(char *) &context.Xer, CONTEXT_INTEGER},
 181   {0,0}, /* MQ, but there isn't one */
 182 #else
 183   {(char *) &context.Eax, CONTEXT_INTEGER},
 184   {(char *) &context.Ecx, CONTEXT_INTEGER},
 185   {(char *) &context.Edx, CONTEXT_INTEGER},
 186   {(char *) &context.Ebx, CONTEXT_INTEGER},
 187   {(char *) &context.Esp, CONTEXT_CONTROL},
 188   {(char *) &context.Ebp, CONTEXT_CONTROL},
 189   {(char *) &context.Esi, CONTEXT_INTEGER},
 190   {(char *) &context.Edi, CONTEXT_INTEGER},
 191   {(char *) &context.Eip, CONTEXT_CONTROL},
 192   {(char *) &context.EFlags, CONTEXT_CONTROL},
 193   {(char *) &context.SegCs, CONTEXT_SEGMENTS},
 194   {(char *) &context.SegSs, CONTEXT_SEGMENTS},
 195   {(char *) &context.SegDs, CONTEXT_SEGMENTS},
 196   {(char *) &context.SegEs, CONTEXT_SEGMENTS},
 197   {(char *) &context.SegFs, CONTEXT_SEGMENTS},
 198   {(char *) &context.SegGs, CONTEXT_SEGMENTS},
 199   {&context.FloatSave.RegisterArea[0 * 10], CONTEXT_FLOATING_POINT},
 200   {&context.FloatSave.RegisterArea[1 * 10], CONTEXT_FLOATING_POINT},
 201   {&context.FloatSave.RegisterArea[2 * 10], CONTEXT_FLOATING_POINT},
 202   {&context.FloatSave.RegisterArea[3 * 10], CONTEXT_FLOATING_POINT},
 203   {&context.FloatSave.RegisterArea[4 * 10], CONTEXT_FLOATING_POINT},
 204   {&context.FloatSave.RegisterArea[5 * 10], CONTEXT_FLOATING_POINT},
 205   {&context.FloatSave.RegisterArea[6 * 10], CONTEXT_FLOATING_POINT},
 206   {&context.FloatSave.RegisterArea[7 * 10], CONTEXT_FLOATING_POINT},
 207 #endif
 208 };
 209
 210
 211 /* This vector maps the target's idea of an exception (extracted
 212    from the DEBUG_EVENT structure) to GDB's idea. */
 213
 214 struct xlate_exception
 215   {
 216     int them;
 217     enum target_signal us;
 218   };
 219
 220
 221 static const struct xlate_exception
 222   xlate[] =
 223 {
 224   {EXCEPTION_ACCESS_VIOLATION, TARGET_SIGNAL_SEGV},
 225   {STATUS_STACK_OVERFLOW, TARGET_SIGNAL_SEGV},
 226   {EXCEPTION_BREAKPOINT, TARGET_SIGNAL_TRAP},
 227   {DBG_CONTROL_C, TARGET_SIGNAL_INT},
 228   {EXCEPTION_SINGLE_STEP, TARGET_SIGNAL_TRAP},
 229   {-1, -1}};
 230
 231
 232 static void
 233 check (BOOL ok, const char *file, int line)
 234 {
 235   if (!ok)
 236     printf_filtered ("error return %s:%d was %d\n", file, line, GetLastError ());
 237 }
 238
 239 static void
 240 child_fetch_inferior_registers (int r)
 241 {
 242   if (r < 0)
 243     {
 244       for (r = 0; r < NUM_REGS; r++)
 245         child_fetch_inferior_registers (r);
 246     }
 247   else
 248     {
 249       supply_register (r, mappings[r].incontext);
 250     }
 251 }
 252
 253 static void
 254 child_store_inferior_registers (int r)
 255 {
 256   if (r < 0)
 257     {
 258       for (r = 0; r < NUM_REGS; r++)
 259         child_store_inferior_registers (r);
 260     }
 261   else
 262     {
 263       read_register_gen (r, mappings[r].incontext);
 264     }
 265 }
 266
 267
 268 /* Wait for child to do something.  Return pid of child, or -1 in case
 269    of error; store status through argument pointer OURSTATUS.  */
 270
 271
 272 static int
 273 handle_load_dll (char *eventp)
 274 {
 275   DEBUG_EVENT * event = (DEBUG_EVENT *)eventp;
 276   DWORD dll_name_ptr;
 277   DWORD done;
 278
 279   ReadProcessMemory (current_process,
 280                      (DWORD) event->u.LoadDll.lpImageName,
 281                      (char *) &dll_name_ptr,
 282                      sizeof (dll_name_ptr), &done);
 283
 284   /* See if we could read the address of a string, and that the
 285      address isn't null. */
 286
 287   if (done == sizeof (dll_name_ptr) && dll_name_ptr)
 288     {
 289       char *dll_name, *dll_basename;
 290       struct objfile *objfile;
 291       char unix_dll_name[MAX_PATH];
 292       int size = event->u.LoadDll.fUnicode ? sizeof (WCHAR) : sizeof (char);
 293       int len = 0;
 294       char b[2];
 295       do
 296         {
 297           ReadProcessMemory (current_process,
 298                              dll_name_ptr + len * size,
 299                              &b,
 300                              size,
 301                              &done);
 302           len++;
 303         }
 304       while ((b[0] != 0 || b[size - 1] != 0) && done == size);
 305
 306       dll_name = alloca (len);
 307
 308       if (event->u.LoadDll.fUnicode)
 309         {
 310           WCHAR *unicode_dll_name = (WCHAR *) alloca (len * sizeof (WCHAR));
 311           ReadProcessMemory (current_process,
 312                              dll_name_ptr,
 313                              unicode_dll_name,
 314                              len * sizeof (WCHAR),
 315                              &done);
 316
 317           WideCharToMultiByte (CP_ACP, 0,
 318                                unicode_dll_name, len,
 319                                dll_name, len, 0, 0);
 320         }
 321       else
 322         {
 323           ReadProcessMemory (current_process,
 324                              dll_name_ptr,
 325                              dll_name,
 326                              len,
 327                              &done);
 328         }
 329
 330
 331       dos_path_to_unix_path (dll_name, unix_dll_name);
 332
 333       /* FIXME!! It would be nice to define one symbol which pointed to the
 334          front of the dll if we can't find any symbols. */
 335
 336        if (!(dll_basename = strrchr(dll_name, '\\')))
 337         dll_basename = strrchr(dll_name, '/');
 338
 339        ALL_OBJFILES(objfile)
 340         {
 341           char *objfile_basename;
 342           if (!(objfile_basename = strrchr(objfile->name, '\\')))
 343             objfile_basename = strrchr(objfile->name, '/');
 344
 345           if (dll_basename && objfile_basename &&
 346               strcmp(dll_basename+1, objfile_basename+1) == 0)
 347             {
 348               printf_unfiltered ("%s (symbols previously loaded)\n",
 349                                  dll_basename + 1);
 350               return 1;
 351             }
 352         }
 353
 354
 355       context.ContextFlags = CONTEXT_FULL | CONTEXT_FLOATING_POINT;
 356       GetThreadContext (current_thread, &context);
 357
 358       /* The symbols in a dll are offset by 0x1000, which is the
 359          the offset from 0 of the first byte in an image - because
 360          of the file header and the section alignment.
 361
 362          FIXME: Is this the real reason that we need the 0x1000 ? */
 363
 364
 365       symbol_file_add (unix_dll_name, 0,
 366                        (int) event->u.LoadDll.lpBaseOfDll + 0x1000, 0, 0, 0);
 367
 368       printf_unfiltered ("%x:%s\n", event->u.LoadDll.lpBaseOfDll,
 369                          unix_dll_name);
 370     }
 371   return 1;
 372 }
 373
 374
 375 static void
 376 handle_exception (DEBUG_EVENT * event, struct target_waitstatus *ourstatus)
 377 {
 378   int i;
 379   int done = 0;
 380   ourstatus->kind = TARGET_WAITKIND_STOPPED;
 381
 382
 383   switch (event->u.Exception.ExceptionRecord.ExceptionCode)
 384     {
 385     case EXCEPTION_ACCESS_VIOLATION:
 386       DEBUG_EXCEPT (("gdb: Target exception ACCESS_VIOLATION at 0x%08x\n",
 387                      event->u.Exception.ExceptionRecord.ExceptionAddress));
 388       ourstatus->value.sig = TARGET_SIGNAL_SEGV;
 389       break;
 390     case STATUS_STACK_OVERFLOW:
 391       DEBUG_EXCEPT (("gdb: Target exception STACK_OVERFLOW at 0x%08x\n",
 392                      event->u.Exception.ExceptionRecord.ExceptionAddress));
 393       ourstatus->value.sig = TARGET_SIGNAL_SEGV;
 394       break;
 395     case EXCEPTION_BREAKPOINT:
 396       DEBUG_EXCEPT (("gdb: Target exception BREAKPOINT at 0x%08x\n",
 397                      event->u.Exception.ExceptionRecord.ExceptionAddress));
 398       ourstatus->value.sig = TARGET_SIGNAL_TRAP;
 399       break;
 400     case DBG_CONTROL_C:
 401       DEBUG_EXCEPT (("gdb: Target exception CONTROL_C at 0x%08x\n",
 402                      event->u.Exception.ExceptionRecord.ExceptionAddress));
 403       ourstatus->value.sig = TARGET_SIGNAL_INT;
 404       break;
 405     case EXCEPTION_SINGLE_STEP:
 406       DEBUG_EXCEPT (("gdb: Target exception SINGLE_STEP at 0x%08x\n",
 407                      event->u.Exception.ExceptionRecord.ExceptionAddress));
 408       ourstatus->value.sig = TARGET_SIGNAL_TRAP;
 409       break;
 410     default:
 411       printf_unfiltered ("gdb: unknown target exception 0x%08x at 0x%08x\n",
 412                          event->u.Exception.ExceptionRecord.ExceptionCode,
 413                          event->u.Exception.ExceptionRecord.ExceptionAddress);
 414       ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
 415       break;
 416     }
 417   context.ContextFlags = CONTEXT_FULL | CONTEXT_FLOATING_POINT;
 418   GetThreadContext (current_thread, &context);
 419   exception_count++;
 420 }
 421
 422 static int
 423 child_wait (int pid, struct target_waitstatus *ourstatus)
 424 {
 425   /* We loop when we get a non-standard exception rather than return
 426      with a SPURIOUS because resume can try and step or modify things,
 427      which needs a current_thread.  But some of these exceptions mark
 428      the birth or death of threads, which mean that the current thread
 429      isn't necessarily what you think it is. */
 430
 431   while (1)
 432     {
 433       DEBUG_EVENT event;
 434       BOOL t = WaitForDebugEvent (&event, INFINITE);
 435       char *p;
 436
 437       event_count++;
 438
 439       current_thread_id = event.dwThreadId;
 440       current_process_id = event.dwProcessId;
 441
 442       switch (event.dwDebugEventCode)
 443         {
 444         case CREATE_THREAD_DEBUG_EVENT:
 445           DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
 446                         event.dwProcessId, event.dwThreadId,
 447                         "CREATE_THREAD_DEBUG_EVENT"));
 448           break;
 449         case EXIT_THREAD_DEBUG_EVENT:
 450           DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
 451                         event.dwProcessId, event.dwThreadId,
 452                         "EXIT_THREAD_DEBUG_EVENT"));
 453           break;
 454         case CREATE_PROCESS_DEBUG_EVENT:
 455           DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
 456                         event.dwProcessId, event.dwThreadId,
 457                         "CREATE_PROCESS_DEBUG_EVENT"));
 458           break;
 459
 460         case EXIT_PROCESS_DEBUG_EVENT:
 461           DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
 462                         event.dwProcessId, event.dwThreadId,
 463                         "EXIT_PROCESS_DEBUG_EVENT"));
 464           ourstatus->kind = TARGET_WAITKIND_EXITED;
 465           ourstatus->value.integer = event.u.ExitProcess.dwExitCode;
 466           CloseHandle (current_process);
 467           CloseHandle (current_thread);
 468           return current_process_id;
 469           break;
 470
 471         case LOAD_DLL_DEBUG_EVENT:
 472           DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
 473                         event.dwProcessId, event.dwThreadId,
 474                         "LOAD_DLL_DEBUG_EVENT"));
 475           catch_errors (handle_load_dll,
 476                         (char*) &event,
 477                         "\n[failed reading symbols from DLL]\n",
 478                         RETURN_MASK_ALL);
 479           registers_changed();          /* mark all regs invalid */
 480           break;
 481         case UNLOAD_DLL_DEBUG_EVENT:
 482           DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
 483                         event.dwProcessId, event.dwThreadId,
 484                         "UNLOAD_DLL_DEBUG_EVENT"));
 485           break;        /* FIXME: don't know what to do here */
 486         case EXCEPTION_DEBUG_EVENT:
 487           DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
 488                         event.dwProcessId, event.dwThreadId,
 489                         "EXCEPTION_DEBUG_EVENT"));
 490           handle_exception (&event, ourstatus);
 491           return current_process_id;
 492
 493         case OUTPUT_DEBUG_STRING_EVENT: /* message from the kernel */
 494           DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
 495                         event.dwProcessId, event.dwThreadId,
 496                         "OUTPUT_DEBUG_STRING_EVENT"));
 497           if (target_read_string
 498               ((CORE_ADDR) event.u.DebugString.lpDebugStringData,
 499                &p, 1024, 0) && p && *p)
 500             {
 501               warning(p);
 502               free(p);
 503             }
 504           break;
 505         default:
 506           printf_unfiltered ("gdb: kernel event for pid=%d tid=%d\n",
 507                              event.dwProcessId, event.dwThreadId);
 508           printf_unfiltered ("                 unknown event code %d\n",
 509                              event.dwDebugEventCode);
 510           break;
 511         }
 512       DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=%d, DBG_CONTINUE);\n",
 513                      current_process_id, current_thread_id));
 514       CHECK (ContinueDebugEvent (current_process_id,
 515                                  current_thread_id,
 516                                  DBG_CONTINUE));
 517     }
 518 }
 519
 520
 521 /* Attach to process PID, then initialize for debugging it.  */
 522
 523 static void
 524 child_attach (args, from_tty)
 525      char *args;
 526      int from_tty;
 527 {
 528   BOOL ok;
 529
 530   if (!args)
 531     error_no_arg ("process-id to attach");
 532
 533   current_process_id = strtoul (args, 0, 0);
 534
 535   ok = DebugActiveProcess (current_process_id);
 536
 537   if (!ok)
 538     error ("Can't attach to process.");
 539
 540
 541   exception_count = 0;
 542   event_count = 0;
 543
 544   if (from_tty)
 545     {
 546       char *exec_file = (char *) get_exec_file (0);
 547
 548       if (exec_file)
 549         printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
 550                            target_pid_to_str (current_process_id));
 551       else
 552         printf_unfiltered ("Attaching to %s\n",
 553                            target_pid_to_str (current_process_id));
 554
 555       gdb_flush (gdb_stdout);
 556     }
 557
 558   inferior_pid = current_process_id;
 559   push_target (&child_ops);
 560 }
 561
 562
 563 static void
 564 child_detach (args, from_tty)
 565      char *args;
 566      int from_tty;
 567 {
 568   if (from_tty)
 569     {
 570       char *exec_file = get_exec_file (0);
 571       if (exec_file == 0)
 572         exec_file = "";
 573       printf_unfiltered ("Detaching from program: %s %s\n", exec_file,
 574                          target_pid_to_str (inferior_pid));
 575       gdb_flush (gdb_stdout);
 576     }
 577   inferior_pid = 0;
 578   unpush_target (&child_ops);
 579 }
 580
 581
 582 /* Print status information about what we're accessing.  */
 583
 584 static void
 585 child_files_info (ignore)
 586      struct target_ops *ignore;
 587 {
 588   printf_unfiltered ("\tUsing the running image of %s %s.\n",
 589       attach_flag ? "attached" : "child", target_pid_to_str (inferior_pid));
 590 }
 591
 592 /* ARGSUSED */
 593 static void
 594 child_open (arg, from_tty)
 595      char *arg;
 596      int from_tty;
 597 {
 598   error ("Use the \"run\" command to start a Unix child process.");
 599 }
 600
 601 /* Start an inferior win32 child process and sets inferior_pid to its pid.
 602    EXEC_FILE is the file to run.
 603    ALLARGS is a string containing the arguments to the program.
 604    ENV is the environment vector to pass.  Errors reported with error().  */
 605
 606 static void
 607 child_create_inferior (exec_file, allargs, env)
 608      char *exec_file;
 609      char *allargs;
 610      char **env;
 611 {
 612   char real_path[MAXPATHLEN];
 613   char *winenv;
 614   char *temp;
 615   int  envlen;
 616   int i;
 617
 618   STARTUPINFO si;
 619   PROCESS_INFORMATION pi;
 620   struct target_waitstatus dummy;
 621   BOOL ret;
 622   DWORD flags;
 623   char *args;
 624
 625   if (!exec_file)
 626     {
 627       error ("No executable specified, use `target exec'.\n");
 628     }
 629
 630   memset (&si, 0, sizeof (si));
 631   si.cb = sizeof (si);
 632
 633   unix_path_to_dos_path (exec_file, real_path);
 634
 635   flags = DEBUG_ONLY_THIS_PROCESS;
 636
 637   if (new_group)
 638     flags |= CREATE_NEW_PROCESS_GROUP;
 639
 640   if (new_console)
 641     flags |= CREATE_NEW_CONSOLE;
 642
 643   args = alloca (strlen (real_path) + strlen (allargs) + 2);
 644
 645   strcpy (args, real_path);
 646
 647   strcat (args, " ");
 648   strcat (args, allargs);
 649
 650   /* Prepare the environment vars for CreateProcess.  */
 651   {
 652     /* This code use to assume all env vars were file names and would
 653        translate them all to win32 style.  That obviously doesn't work in the
 654        general case.  The current rule is that the user either works solely
 655        with win32 style path names or with posix style path names and that
 656        all env vars are already set up appropriately.  At any rate it is
 657        wrong for us to willy-nilly change them.
 658
 659        However, we need to handle PATH because we're about to call
 660        CreateProcess and it uses PATH to find DLL's.  Fortunately PATH
 661        has a well-defined value in both posix and win32 environments.
 662        cygwin.dll will change it back to posix style if necessary.  If we're
 663        working with win32 style path names, we don't need to do anything at
 664        all.  */
 665
 666     static const char *conv_path_names[] =
 667       {
 668         "PATH=",
 669         0
 670       };
 671     int posix_rules_p = sysconf (_SC_PATH_RULES) == _PATH_RULES_POSIX;
 672
 673     /* CreateProcess takes the environment list as a null terminated set of
 674        strings (i.e. two nulls terminate the list).  */
 675
 676     /* Get total size for env strings.  */
 677     for (envlen = 0, i = 0; env[i] && *env[i]; i++)
 678       {
 679         if (posix_rules_p)
 680           {
 681             int j, len;
 682
 683             for (j = 0; conv_path_names[j]; j++)
 684               {
 685                 len = strlen (conv_path_names[j]);
 686                 if (strncmp (conv_path_names[j], env[i], len) == 0)
 687                   {
 688                     envlen += len
 689                       + cygwin32_posix_to_win32_path_list_buf_size (env[i] + len);
 690                     break;
 691                   }
 692               }
 693             if (conv_path_names[j] == NULL)
 694               envlen += strlen (env[i]) + 1;
 695           }
 696         else
 697           envlen += strlen (env[i]) + 1;
 698       }
 699
 700     winenv = alloca (envlen + 1);
 701
 702     /* Copy env strings into new buffer.  */
 703     for (temp = winenv, i = 0; env[i] && *env[i]; i++)
 704       {
 705         if (posix_rules_p)
 706           {
 707             int j, len;
 708
 709             for (j = 0; conv_path_names[j]; j++)
 710               {
 711                 len = strlen (conv_path_names[j]);
 712                 if (strncmp (conv_path_names[j], env[i], len) == 0)
 713                   {
 714                     memcpy (temp, env[i], len);
 715                     cygwin32_posix_to_win32_path_list (env[i] + len, temp + len);
 716                     break;
 717                   }
 718               }
 719             if (conv_path_names[j] == NULL)
 720               strcpy (temp, env[i]);
 721           }
 722         else
 723           strcpy (temp, env[i]);
 724         temp += strlen (temp) + 1;
 725       }
 726
 727     /* Final nil string to terminate new env.  */
 728     *temp = 0;
 729   }
 730
 731   ret = CreateProcess (0,
 732                        args,    /* command line */
 733                        NULL,    /* Security */
 734                        NULL,    /* thread */
 735                        TRUE,    /* inherit handles */
 736                        flags,   /* start flags */
 737                        winenv,
 738                        NULL,    /* current directory */
 739                        &si,
 740                        &pi);
 741   if (!ret)
 742     error ("Error creating process %s, (error %d)\n", exec_file, GetLastError());
 743
 744   exception_count = 0;
 745   event_count = 0;
 746
 747   inferior_pid = pi.dwProcessId;
 748   current_process = pi.hProcess;
 749   current_thread = pi.hThread;
 750   current_process_id = pi.dwProcessId;
 751   current_thread_id = pi.dwThreadId;
 752   push_target (&child_ops);
 753   init_thread_list ();
 754   init_wait_for_inferior ();
 755   clear_proceed_status ();
 756   target_terminal_init ();
 757   target_terminal_inferior ();
 758
 759   /* Ignore the first trap */
 760   child_wait (inferior_pid, &dummy);
 761
 762   proceed ((CORE_ADDR) - 1, TARGET_SIGNAL_0, 0);
 763 }
 764
 765 static void
 766 child_mourn_inferior ()
 767 {
 768   unpush_target (&child_ops);
 769   generic_mourn_inferior ();
 770 }
 771
 772
 773 /* Send a SIGINT to the process group.  This acts just like the user typed a
 774    ^C on the controlling terminal. */
 775
 776 void
 777 child_stop ()
 778 {
 779   DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
 780   CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, 0));
 781   registers_changed();          /* refresh register state */
 782 }
 783
 784 int
 785 child_xfer_memory (CORE_ADDR memaddr, char *our, int len,
 786                    int write, struct target_ops *target)
 787 {
 788   DWORD done;
 789   if (write)
 790     {
 791       DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08x\n",
 792                   len, memaddr));
 793       WriteProcessMemory (current_process, memaddr, our, len, &done);
 794       FlushInstructionCache (current_process, memaddr, len);
 795     }
 796   else
 797     {
 798       DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08x\n",
 799                   len, memaddr));
 800       ReadProcessMemory (current_process, memaddr, our, len, &done);
 801     }
 802   return done;
 803 }
 804
 805 void
 806 child_kill_inferior (void)
 807 {
 808   CHECK (TerminateProcess (current_process, 0));
 809   CHECK (CloseHandle (current_process));
 810   CHECK (CloseHandle (current_thread));
 811   target_mourn_inferior();      /* or just child_mourn_inferior? */
 812 }
 813
 814 void
 815 child_resume (int pid, int step, enum target_signal signal)
 816 {
 817   DEBUG_EXEC (("gdb: child_resume (pid=%d, step=%d, signal=%d);\n",
 818                pid, step, signal));
 819
 820   if (step)
 821     {
 822 #ifdef __PPC__
 823       warning ("Single stepping not done.\n");
 824 #endif
 825 #ifdef i386
 826       /* Single step by setting t bit */
 827       child_fetch_inferior_registers (PS_REGNUM);
 828       context.EFlags |= FLAG_TRACE_BIT;
 829 #endif
 830     }
 831
 832   if (context.ContextFlags)
 833     {
 834       CHECK (SetThreadContext (current_thread, &context));
 835       context.ContextFlags = 0;
 836     }
 837
 838   if (signal)
 839     {
 840       fprintf_unfiltered (gdb_stderr, "Can't send signals to the child.\n");
 841     }
 842
 843   DEBUG_EVENTS (("gdb: ContinueDebugEvent (cpid=%d, ctid=%d, DBG_CONTINUE);\n",
 844                  current_process_id, current_thread_id));
 845   CHECK (ContinueDebugEvent (current_process_id,
 846                              current_thread_id,
 847                              DBG_CONTINUE));
 848 }
 849
 850 static void
 851 child_prepare_to_store ()
 852 {
 853   /* Do nothing, since we can store individual regs */
 854 }
 855
 856 static int
 857 child_can_run ()
 858 {
 859   return 1;
 860 }
 861
 862 static void
 863 child_close ()
 864 {
 865   DEBUG_EVENTS (("gdb: child_close, inferior_pid=%d\n", inferior_pid));
 866 }
 867
 868 struct target_ops child_ops =
 869 {
 870   "child",                      /* to_shortname */
 871   "Win32 child process",        /* to_longname */
 872   "Win32 child process (started by the \"run\" command).",      /* to_doc */
 873   child_open,                   /* to_open */
 874   child_close,                  /* to_close */
 875   child_attach,                 /* to_attach */
 876   child_detach,                 /* to_detach */
 877   child_resume,                 /* to_resume */
 878   child_wait,                   /* to_wait */
 879   child_fetch_inferior_registers,/* to_fetch_registers */
 880   child_store_inferior_registers,/* to_store_registers */
 881   child_prepare_to_store,       /* to_child_prepare_to_store */
 882   child_xfer_memory,            /* to_xfer_memory */
 883   child_files_info,             /* to_files_info */
 884   memory_insert_breakpoint,     /* to_insert_breakpoint */
 885   memory_remove_breakpoint,     /* to_remove_breakpoint */
 886   terminal_init_inferior,       /* to_terminal_init */
 887   terminal_inferior,            /* to_terminal_inferior */
 888   terminal_ours_for_output,     /* to_terminal_ours_for_output */
 889   terminal_ours,                /* to_terminal_ours */
 890   child_terminal_info,          /* to_terminal_info */
 891   child_kill_inferior,          /* to_kill */
 892   0,                            /* to_load */
 893   0,                            /* to_lookup_symbol */
 894   child_create_inferior,        /* to_create_inferior */
 895   child_mourn_inferior,         /* to_mourn_inferior */
 896   child_can_run,                /* to_can_run */
 897   0,                            /* to_notice_signals */
 898   0,                            /* to_thread_alive */
 899   child_stop,                   /* to_stop */
 900   process_stratum,              /* to_stratum */
 901   0,                            /* to_next */
 902   1,                            /* to_has_all_memory */
 903   1,                            /* to_has_memory */
 904   1,                            /* to_has_stack */
 905   1,                            /* to_has_registers */
 906   1,                            /* to_has_execution */
 907   0,                            /* to_sections */
 908   0,                            /* to_sections_end */
 909   OPS_MAGIC                     /* to_magic */
 910 };
 911
 912 void
 913 _initialize_inftarg ()
 914 {
 915   struct cmd_list_element *c;
 916
 917   add_show_from_set
 918     (add_set_cmd ("new-console", class_support, var_boolean,
 919                   (char *) &new_console,
 920                   "Set creation of new console when creating child process.",
 921                   &setlist),
 922      &showlist);
 923
 924   add_show_from_set
 925     (add_set_cmd ("new-group", class_support, var_boolean,
 926                   (char *) &new_group,
 927                   "Set creation of new group when creating child process.",
 928                   &setlist),
 929      &showlist);
 930
 931   add_show_from_set
 932     (add_set_cmd ("debugexec", class_support, var_boolean,
 933                   (char *) &debug_exec,
 934                   "Set whether to display execution in child process.",
 935                   &setlist),
 936      &showlist);
 937
 938   add_show_from_set
 939     (add_set_cmd ("debugevents", class_support, var_boolean,
 940                   (char *) &debug_events,
 941                   "Set whether to display kernel events in child process.",
 942                   &setlist),
 943      &showlist);
 944
 945   add_show_from_set
 946     (add_set_cmd ("debugmemory", class_support, var_boolean,
 947                   (char *) &debug_memory,
 948                   "Set whether to display memory accesses in child process.",
 949                   &setlist),
 950      &showlist);
 951
 952   add_show_from_set
 953     (add_set_cmd ("debugexceptions", class_support, var_boolean,
 954                   (char *) &debug_exceptions,
 955                   "Set whether to display kernel exceptions in child process.",
 956                   &setlist),
 957      &showlist);
 958
 959   add_target (&child_ops);
 960 }