Subversion Repositories openrisc

/* Low level interface to Windows debugging, for gdbserver.

   Copyright (C) 2006, 2007, 2008 Free Software Foundation, Inc.

   Contributed by Leo Zayas.  Based on "win32-nat.c" from GDB.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3 of the License, or

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#include "server.h"

#include "regcache.h"

#include "gdb/signals.h"

#include "gdb/fileio.h"

#include "mem-break.h"

#include "win32-low.h"

#include <windows.h>

#include <winnt.h>

#include <imagehlp.h>

#include <tlhelp32.h>

#include <psapi.h>

#include <sys/param.h>

#include <malloc.h>

#include <process.h>

#ifndef USE_WIN32API

#include <sys/cygwin.h>

#endif

#define LOG 0

#define OUTMSG(X) do { printf X; fflush (stdout); } while (0)

#if LOG

#define OUTMSG2(X) do { printf X; fflush (stdout); } while (0)

#else

#define OUTMSG2(X) do ; while (0)

#endif

#ifndef _T

#define _T(x) TEXT (x)

#endif

#ifndef COUNTOF

#define COUNTOF(STR) (sizeof (STR) / sizeof ((STR)[0]))

#endif

#ifdef _WIN32_WCE

# define GETPROCADDRESS(DLL, PROC) \

  ((winapi_ ## PROC) GetProcAddress (DLL, TEXT (#PROC)))

#else

# define GETPROCADDRESS(DLL, PROC) \

  ((winapi_ ## PROC) GetProcAddress (DLL, #PROC))

#endif

int using_threads = 1;

/* Globals.  */

static int attaching = 0;

static HANDLE current_process_handle = NULL;

static DWORD current_process_id = 0;

static DWORD main_thread_id = 0;

static enum target_signal last_sig = TARGET_SIGNAL_0;

/* The current debug event from WaitForDebugEvent.  */

static DEBUG_EVENT current_event;

/* Non zero if an interrupt request is to be satisfied by suspending

   all threads.  */

static int soft_interrupt_requested = 0;

/* Non zero if the inferior is stopped in a simulated breakpoint done

   by suspending all the threads.  */

static int faked_breakpoint = 0;

#define NUM_REGS (the_low_target.num_regs)

typedef BOOL WINAPI (*winapi_DebugActiveProcessStop) (DWORD dwProcessId);

typedef BOOL WINAPI (*winapi_DebugSetProcessKillOnExit) (BOOL KillOnExit);

typedef BOOL WINAPI (*winapi_DebugBreakProcess) (HANDLE);

typedef BOOL WINAPI (*winapi_GenerateConsoleCtrlEvent) (DWORD, DWORD);

static void win32_resume (struct thread_resume *resume_info);

/* Get the thread ID from the current selected inferior (the current

   thread).  */

static DWORD

current_inferior_tid (void)

{

  win32_thread_info *th = inferior_target_data (current_inferior);

  return th->tid;

}

/* Get the thread context of the thread associated with TH.  */

static void

win32_get_thread_context (win32_thread_info *th)

{

  memset (&th->context, 0, sizeof (CONTEXT));

  (*the_low_target.get_thread_context) (th, &current_event);

#ifdef _WIN32_WCE

  memcpy (&th->base_context, &th->context, sizeof (CONTEXT));

#endif

}

/* Set the thread context of the thread associated with TH.  */

static void

win32_set_thread_context (win32_thread_info *th)

{

#ifdef _WIN32_WCE

  /* Calling SuspendThread on a thread that is running kernel code

     will report that the suspending was successful, but in fact, that

     will often not be true.  In those cases, the context returned by

     GetThreadContext will not be correct by the time the thread

     stops, hence we can't set that context back into the thread when

     resuming - it will most likelly crash the inferior.

     Unfortunately, there is no way to know when the thread will

     really stop.  To work around it, we'll only write the context

     back to the thread when either the user or GDB explicitly change

     it between stopping and resuming.  */

  if (memcmp (&th->context, &th->base_context, sizeof (CONTEXT)) != 0)

#endif

    (*the_low_target.set_thread_context) (th, &current_event);

}

/* Find a thread record given a thread id.  If GET_CONTEXT is set then

   also retrieve the context for this thread.  */

static win32_thread_info *

thread_rec (DWORD id, int get_context)

{

  struct thread_info *thread;

  win32_thread_info *th;

  thread = (struct thread_info *) find_inferior_id (&all_threads, id);

  if (thread == NULL)

    return NULL;

  th = inferior_target_data (thread);

  if (get_context && th->context.ContextFlags == 0)

    {

      if (!th->suspended)

        {

          if (SuspendThread (th->h) == (DWORD) -1)

            {

              DWORD err = GetLastError ();

              OUTMSG (("warning: SuspendThread failed in thread_rec, "

                       "(error %d): %s\n", (int) err, strwinerror (err)));

            }

          else

            th->suspended = 1;

        }

      win32_get_thread_context (th);

    }

  return th;

}

/* Add a thread to the thread list.  */

static win32_thread_info *

child_add_thread (DWORD tid, HANDLE h)

{

  win32_thread_info *th;

  if ((th = thread_rec (tid, FALSE)))

    return th;

  th = calloc (1, sizeof (*th));

  th->tid = tid;

  th->h = h;

  add_thread (tid, th, (unsigned int) tid);

  set_inferior_regcache_data ((struct thread_info *)

                              find_inferior_id (&all_threads, tid),

                              new_register_cache ());

  if (the_low_target.thread_added != NULL)

    (*the_low_target.thread_added) (th);

  return th;

}

/* Delete a thread from the list of threads.  */

static void

delete_thread_info (struct inferior_list_entry *thread)

{

  win32_thread_info *th = inferior_target_data ((struct thread_info *) thread);

  remove_thread ((struct thread_info *) thread);

  CloseHandle (th->h);

  free (th);

}

/* Delete a thread from the list of threads.  */

static void

child_delete_thread (DWORD id)

{

  struct inferior_list_entry *thread;

  /* If the last thread is exiting, just return.  */

  if (all_threads.head == all_threads.tail)

    return;

  thread = find_inferior_id (&all_threads, id);

  if (thread == NULL)

    return;

  delete_thread_info (thread);

}

/* Transfer memory from/to the debugged process.  */

static int

child_xfer_memory (CORE_ADDR memaddr, char *our, int len,

                   int write, struct target_ops *target)

{

  SIZE_T done;

  long addr = (long) memaddr;

  if (write)

    {

      WriteProcessMemory (current_process_handle, (LPVOID) addr,

                          (LPCVOID) our, len, &done);

      FlushInstructionCache (current_process_handle, (LPCVOID) addr, len);

    }

  else

    {

      ReadProcessMemory (current_process_handle, (LPCVOID) addr, (LPVOID) our,

                         len, &done);

    }

  return done;

}

/* Generally, what has the program done?  */

enum target_waitkind

{

  /* The program has exited.  The exit status is in value.integer.  */

  TARGET_WAITKIND_EXITED,

  /* The program has stopped with a signal.  Which signal is in

     value.sig.  */

  TARGET_WAITKIND_STOPPED,

  /* The program is letting us know that it dynamically loaded

     or unloaded something.  */

  TARGET_WAITKIND_LOADED,

  /* The program has exec'ed a new executable file.  The new file's

     pathname is pointed to by value.execd_pathname.  */

  TARGET_WAITKIND_EXECD,

  /* Nothing interesting happened, but we stopped anyway.  We take the

     chance to check if GDB requested an interrupt.  */

  TARGET_WAITKIND_SPURIOUS,

};

struct target_waitstatus

{

  enum target_waitkind kind;

  /* Forked child pid, execd pathname, exit status or signal number.  */

  union

  {

    int integer;

    enum target_signal sig;

    int related_pid;

    char *execd_pathname;

    int syscall_id;

  }

  value;

};

/* Clear out any old thread list and reinitialize it to a pristine

   state. */

static void

child_init_thread_list (void)

{

  for_each_inferior (&all_threads, delete_thread_info);

}

static void

do_initial_child_stuff (HANDLE proch, DWORD pid)

{

  last_sig = TARGET_SIGNAL_0;

  current_process_handle = proch;

  current_process_id = pid;

  main_thread_id = 0;

  soft_interrupt_requested = 0;

  faked_breakpoint = 0;

  memset (&current_event, 0, sizeof (current_event));

  child_init_thread_list ();

  if (the_low_target.initial_stuff != NULL)

    (*the_low_target.initial_stuff) ();

}

/* Resume all artificially suspended threads if we are continuing

   execution.  */

static int

continue_one_thread (struct inferior_list_entry *this_thread, void *id_ptr)

{

  struct thread_info *thread = (struct thread_info *) this_thread;

  int thread_id = * (int *) id_ptr;

  win32_thread_info *th = inferior_target_data (thread);

  if ((thread_id == -1 || thread_id == th->tid)

      && th->suspended)

    {

      if (th->context.ContextFlags)

        {

          win32_set_thread_context (th);

          th->context.ContextFlags = 0;

        }

      if (ResumeThread (th->h) == (DWORD) -1)

        {

          DWORD err = GetLastError ();

          OUTMSG (("warning: ResumeThread failed in continue_one_thread, "

                   "(error %d): %s\n", (int) err, strwinerror (err)));

        }

      th->suspended = 0;

    }

  return 0;

}

static BOOL

child_continue (DWORD continue_status, int thread_id)

{

  /* The inferior will only continue after the ContinueDebugEvent

     call.  */

  find_inferior (&all_threads, continue_one_thread, &thread_id);

  faked_breakpoint = 0;

  if (!ContinueDebugEvent (current_event.dwProcessId,

                           current_event.dwThreadId,

                           continue_status))

    return FALSE;

  return TRUE;

}

/* Fetch register(s) from the current thread context.  */

static void

child_fetch_inferior_registers (int r)

{

  int regno;

  win32_thread_info *th = thread_rec (current_inferior_tid (), TRUE);

  if (r == -1 || r == 0 || r > NUM_REGS)

    child_fetch_inferior_registers (NUM_REGS);

  else

    for (regno = 0; regno < r; regno++)

      (*the_low_target.fetch_inferior_register) (th, regno);

}

/* Store a new register value into the current thread context.  We don't

   change the program's context until later, when we resume it.  */

static void

child_store_inferior_registers (int r)

{

  int regno;

  win32_thread_info *th = thread_rec (current_inferior_tid (), TRUE);

  if (r == -1 || r == 0 || r > NUM_REGS)

    child_store_inferior_registers (NUM_REGS);

  else

    for (regno = 0; regno < r; regno++)

      (*the_low_target.store_inferior_register) (th, regno);

}

/* Map the Windows error number in ERROR to a locale-dependent error

   message string and return a pointer to it.  Typically, the values

   for ERROR come from GetLastError.

   The string pointed to shall not be modified by the application,

   but may be overwritten by a subsequent call to strwinerror

   The strwinerror function does not change the current setting

   of GetLastError.  */

char *

strwinerror (DWORD error)

{

  static char buf[1024];

  TCHAR *msgbuf;

  DWORD lasterr = GetLastError ();

  DWORD chars = FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM

                               | FORMAT_MESSAGE_ALLOCATE_BUFFER,

                               NULL,

                               error,

                               0, /* Default language */

                               (LPVOID)&msgbuf,

                               0,

                               NULL);

  if (chars != 0)

    {

      /* If there is an \r\n appended, zap it.  */

      if (chars >= 2

          && msgbuf[chars - 2] == '\r'

          && msgbuf[chars - 1] == '\n')

        {

          chars -= 2;

          msgbuf[chars] = 0;

        }

      if (chars > ((COUNTOF (buf)) - 1))

        {

          chars = COUNTOF (buf) - 1;

          msgbuf [chars] = 0;

        }

#ifdef UNICODE

      wcstombs (buf, msgbuf, chars + 1);

#else

      strncpy (buf, msgbuf, chars + 1);

#endif

      LocalFree (msgbuf);

    }

  else

    sprintf (buf, "unknown win32 error (%ld)", error);

  SetLastError (lasterr);

  return buf;

}

static BOOL

create_process (const char *program, char *args,

                DWORD flags, PROCESS_INFORMATION *pi)

{

  BOOL ret;

#ifdef _WIN32_WCE

  wchar_t *p, *wprogram, *wargs;

  size_t argslen;

  wprogram = alloca ((strlen (program) + 1) * sizeof (wchar_t));

  mbstowcs (wprogram, program, strlen (program) + 1);

  for (p = wprogram; *p; ++p)

    if (L'/' == *p)

      *p = L'\\';

  argslen = strlen (args);

  wargs = alloca ((argslen + 1) * sizeof (wchar_t));

  mbstowcs (wargs, args, argslen + 1);

  ret = CreateProcessW (wprogram, /* image name */

                        wargs,    /* command line */

                        NULL,     /* security, not supported */

                        NULL,     /* thread, not supported */

                        FALSE,    /* inherit handles, not supported */

                        flags,    /* start flags */

                        NULL,     /* environment, not supported */

                        NULL,     /* current directory, not supported */

                        NULL,     /* start info, not supported */

                        pi);      /* proc info */

#else

  STARTUPINFOA si = { sizeof (STARTUPINFOA) };

  ret = CreateProcessA (program,  /* image name */

                        args,     /* command line */

                        NULL,     /* security */

                        NULL,     /* thread */

                        TRUE,     /* inherit handles */

                        flags,    /* start flags */

                        NULL,     /* environment */

                        NULL,     /* current directory */

                        &si,      /* start info */

                        pi);      /* proc info */

#endif

  return ret;

}

/* Start a new process.

   PROGRAM is a path to the program to execute.

   ARGS is a standard NULL-terminated array of arguments,

   to be passed to the inferior as ``argv''.

   Returns the new PID on success, -1 on failure.  Registers the new

   process with the process list.  */

static int

win32_create_inferior (char *program, char **program_args)

{

#ifndef USE_WIN32API

  char real_path[MAXPATHLEN];

  char *orig_path, *new_path, *path_ptr;

#endif

  BOOL ret;

  DWORD flags;

  char *args;

  int argslen;

  int argc;

  PROCESS_INFORMATION pi;

  DWORD err;

  /* win32_wait needs to know we're not attaching.  */

  attaching = 0;

  if (!program)

    error ("No executable specified, specify executable to debug.\n");

  flags = DEBUG_PROCESS | DEBUG_ONLY_THIS_PROCESS;

#ifndef USE_WIN32API

  orig_path = NULL;

  path_ptr = getenv ("PATH");

  if (path_ptr)

    {

      orig_path = alloca (strlen (path_ptr) + 1);

      new_path = alloca (cygwin_posix_to_win32_path_list_buf_size (path_ptr));

      strcpy (orig_path, path_ptr);

      cygwin_posix_to_win32_path_list (path_ptr, new_path);

      setenv ("PATH", new_path, 1);

    }

  cygwin_conv_to_win32_path (program, real_path);

  program = real_path;

#endif

  argslen = 1;

  for (argc = 1; program_args[argc]; argc++)

    argslen += strlen (program_args[argc]) + 1;

  args = alloca (argslen);

  args[0] = '\0';

  for (argc = 1; program_args[argc]; argc++)

    {

      /* FIXME: Can we do better about quoting?  How does Cygwin

         handle this?  */

      strcat (args, " ");

      strcat (args, program_args[argc]);

    }

  OUTMSG2 (("Command line is \"%s\"\n", args));

#ifdef CREATE_NEW_PROCESS_GROUP

  flags |= CREATE_NEW_PROCESS_GROUP;

#endif

  ret = create_process (program, args, flags, &pi);

  err = GetLastError ();

  if (!ret && err == ERROR_FILE_NOT_FOUND)

    {

      char *exename = alloca (strlen (program) + 5);

      strcat (strcpy (exename, program), ".exe");

      ret = create_process (exename, args, flags, &pi);

      err = GetLastError ();

    }

#ifndef USE_WIN32API

  if (orig_path)

    setenv ("PATH", orig_path, 1);

#endif

  if (!ret)

    {

      error ("Error creating process \"%s%s\", (error %d): %s\n",

             program, args, (int) err, strwinerror (err));

    }

  else

    {

      OUTMSG2 (("Process created: %s\n", (char *) args));

    }

#ifndef _WIN32_WCE

  /* On Windows CE this handle can't be closed.  The OS reuses

     it in the debug events, while the 9x/NT versions of Windows

     probably use a DuplicateHandle'd one.  */

  CloseHandle (pi.hThread);

#endif

  do_initial_child_stuff (pi.hProcess, pi.dwProcessId);

  return current_process_id;

}

/* Attach to a running process.

   PID is the process ID to attach to, specified by the user

   or a higher layer.  */

static int

win32_attach (unsigned long pid)

{

  HANDLE h;

  winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit = NULL;

  DWORD err;

#ifdef _WIN32_WCE

  HMODULE dll = GetModuleHandle (_T("COREDLL.DLL"));

#else

  HMODULE dll = GetModuleHandle (_T("KERNEL32.DLL"));

#endif

  DebugSetProcessKillOnExit = GETPROCADDRESS (dll, DebugSetProcessKillOnExit);

  h = OpenProcess (PROCESS_ALL_ACCESS, FALSE, pid);

  if (h != NULL)

    {

      if (DebugActiveProcess (pid))

        {

          if (DebugSetProcessKillOnExit != NULL)

            DebugSetProcessKillOnExit (FALSE);

          /* win32_wait needs to know we're attaching.  */

          attaching = 1;

          do_initial_child_stuff (h, pid);

          return 0;

        }

      CloseHandle (h);

    }

  err = GetLastError ();

  error ("Attach to process failed (error %d): %s\n",

         (int) err, strwinerror (err));

}

/* Handle OUTPUT_DEBUG_STRING_EVENT from child process.  */

static void

handle_output_debug_string (struct target_waitstatus *ourstatus)

{

#define READ_BUFFER_LEN 1024

  CORE_ADDR addr;

  char s[READ_BUFFER_LEN + 1] = { 0 };

  DWORD nbytes = current_event.u.DebugString.nDebugStringLength;

  if (nbytes == 0)

    return;

  if (nbytes > READ_BUFFER_LEN)

    nbytes = READ_BUFFER_LEN;

  addr = (CORE_ADDR) (size_t) current_event.u.DebugString.lpDebugStringData;

  if (current_event.u.DebugString.fUnicode)

    {

      /* The event tells us how many bytes, not chars, even

         in Unicode.  */

      WCHAR buffer[(READ_BUFFER_LEN + 1) / sizeof (WCHAR)] = { 0 };

      if (read_inferior_memory (addr, (unsigned char *) buffer, nbytes) != 0)

        return;

      wcstombs (s, buffer, (nbytes + 1) / sizeof (WCHAR));

    }

  else

    {

      if (read_inferior_memory (addr, (unsigned char *) s, nbytes) != 0)

        return;

    }

  if (strncmp (s, "cYg", 3) != 0)

    {

      if (!server_waiting)

        {

          OUTMSG2(("%s", s));

          return;

        }

      monitor_output (s);

    }

#undef READ_BUFFER_LEN

}

static void

win32_clear_inferiors (void)

{

  if (current_process_handle != NULL)

    CloseHandle (current_process_handle);

  for_each_inferior (&all_threads, delete_thread_info);

  clear_inferiors ();

}

/* Kill all inferiors.  */

static void

win32_kill (void)

{

  if (current_process_handle == NULL)

    return;

  TerminateProcess (current_process_handle, 0);

  for (;;)

    {

      if (!child_continue (DBG_CONTINUE, -1))

        break;