#include <winsock.h>
#include "wince-stub.h"
-#define MALLOC(n) (void *) LocalAlloc (LMEM_MOVEABLE, (UINT)(n))
+#define MALLOC(n) (void *) LocalAlloc (LMEM_MOVEABLE | LMEM_ZEROINIT, (UINT)(n))
#define REALLOC(s, n) (void *) LocalReAlloc ((HLOCAL)(s), (UINT)(n), LMEM_MOVEABLE)
+#define FREE(s) LocalFree ((HLOCAL)(s))
static int skip_next_id = 0; /* Don't read next API code from socket */
-/* v-style interface for handling varying argyment list error messages.
+/* v-style interface for handling varying argument list error messages.
Displays the error message in a dialog box and exits when user clicks
on OK. */
static void
vstub_error (fmt, args);
}
+/* Allocate a limited pool of memory, reallocating over unused
+ buffers. This assumes that there will never be more than four
+ "buffers" required which, so far, is a safe assumption. */
+static LPVOID
+mempool (unsigned int len)
+{
+ static int outn = -1;
+ static LPWSTR outs[4] = {NULL, NULL, NULL, NULL};
+
+ if (++outn >= (sizeof (outs) / sizeof (outs[0])))
+ outn = 0;
+
+ /* Allocate space for the converted string, reusing any previously allocated
+ space, if applicable. */
+ if (outs[outn])
+ FREE (outs[outn]);
+ outs[outn] = (LPWSTR) MALLOC (len);
+
+ return outs[outn];
+}
+
/* Standard "oh well" can't communicate error. Someday this might attempt
synchronization. */
static void
}
}
-/* Allocate a limited pool of memory, reallocating over unused
- buffers. This assumes that there will never be more than four
- "buffers" required which, so far, is a safe assumption. */
-static LPVOID
-mempool (gdb_wince_len len)
-{
- static int n = -1;
- static LPWSTR outs[4] = {NULL /*, NULL, etc. */};
-
- if (++n >= (sizeof (outs) / sizeof (outs[0])))
- n = 0;
-
- /* Allocate space for the converted string, reusing any previously allocated
- space, if applicable. */
- if (outs[n])
- outs[n] = (LPWSTR) REALLOC (outs[n], len);
- else
- outs[n] = (LPWSTR) MALLOC (len);
-
- return outs[n];
-}
-
/* Get a an ID (possibly) and a DWORD from the host gdb.
Don't bother with the id if the main loop has already
read it. */
*inlen = getlen (huh, s, what);
- p = mempool (*inlen); /* FIXME: check for error */
+ p = mempool ((unsigned int) *inlen); /* FIXME: check for error */
if ((gdb_wince_len) sockread (huh, s, p, *inlen) != *inlen)
stub_error (L"error getting string from host.");
&res, sizeof (res));
}
+static int stepped = 0;
+/* Handle single step instruction. FIXME: unneded? */
+static void
+flag_single_step (int s)
+{
+ stepped = 1;
+ skip_next_id = 0;
+}
+
+struct skipper
+{
+ wchar_t *s;
+ int nskip;
+} skippy[] =
+{
+ {L"Undefined Instruction:", 1},
+ {L"Data Abort:", 2},
+ {NULL, 0}
+};
+
+static int
+skip_message (DEBUG_EVENT *ev)
+{
+ char s[80];
+ DWORD nread;
+ struct skipper *skp;
+ int nbytes = ev->u.DebugString.nDebugStringLength;
+
+ if (nbytes > sizeof(s))
+ nbytes = sizeof(s);
+
+ memset (s, 0, sizeof (s));
+ if (!ReadProcessMemory (curproc, ev->u.DebugString.lpDebugStringData,
+ s, nbytes, &nread))
+ return 0;
+
+ for (skp = skippy; skp->s != NULL; skp++)
+ if (wcsncmp ((wchar_t *) s, skp->s, wcslen (skp->s)) == 0)
+ return skp->nskip;
+
+ return 0;
+}
+
/* Emulate WaitForDebugEvent. Returns the debug event on success. */
static void
wait_for_debug_event (int s)
DWORD ms = getdword (L"WaitForDebugEvent ms", s, GDB_WAITFORDEBUGEVENT);
gdb_wince_result res;
DEBUG_EVENT ev;
+ static int skip_next = 0;
+
+ for (;;)
+ {
+ res = WaitForDebugEvent (&ev, ms);
+
+ if (ev.dwDebugEventCode == OUTPUT_DEBUG_STRING_EVENT)
+ {
+ if (skip_next)
+ {
+ skip_next--;
+ goto ignore;
+ }
+ if (skip_next = skip_message (&ev))
+ goto ignore;
+ }
+
+ putresult (L"WaitForDebugEvent event", res, s, GDB_WAITFORDEBUGEVENT,
+ &ev, sizeof (ev));
+ break;
+
+ ignore:
+ ContinueDebugEvent (ev.dwProcessId, ev.dwThreadId, DBG_CONTINUE);
+ }
- res = WaitForDebugEvent (&ev, ms);
- putresult (L"WaitForDebugEvent event", res, s, GDB_WAITFORDEBUGEVENT,
- &ev, sizeof (ev));
+ return;
}
/* Emulate GetThreadContext. Returns CONTEXT structure on success. */
gdb_wince_result res;
memset (&c, 0, sizeof (c));
- c.ContextFlags = getdword (L"GetThreadContext handle", s, GDB_GETTHREADCONTEXT);
+ c.ContextFlags = getdword (L"GetThreadContext flags", s, GDB_GETTHREADCONTEXT);
res = (gdb_wince_result) GetThreadContext (h, &c);
putresult (L"GetThreadContext data", res, s, GDB_GETTHREADCONTEXT,
HANDLE h = gethandle (L"ReadProcessMemory handle", s, GDB_READPROCESSMEMORY);
LPVOID p = getpvoid (L"ReadProcessMemory base", s, GDB_READPROCESSMEMORY);
gdb_wince_len len = getlen (L"ReadProcessMemory size", s, GDB_READPROCESSMEMORY);
- LPVOID buf = mempool ((gdb_wince_len) len);
+ LPVOID buf = mempool ((unsigned int) len);
DWORD outlen;
gdb_wince_result res;
putresult (L"CloseHandle result", res, s, GDB_CLOSEHANDLE, &res, sizeof (res));
}
-/* Handle single step instruction */
-static void
-single_step (int s)
-{
-}
-
/* Main loop for reading requests from gdb host on the socket. */
static void
dispatch (int s)
terminate_process (s);
return;
case GDB_SINGLESTEP:
- single_step (s);
- return;
+ flag_single_step (s);
+ break;
default:
{
WCHAR buf[80];
wcstombs (host, whost, 80); /* Convert from UNICODE to ascii */
}
- MessageBoxW (NULL, whost, L"GDB", MB_ICONERROR);
-
/* Winsock initialization. */
if (WSAStartup (MAKEWORD (1, 1), &wd))
stub_error (L"Couldn't initialize WINSOCK.");
#include <sys/param.h>
#include "wince-stub.h"
#include "dcache.h"
+#include <time.h>
/* The ui's event loop. */
extern int (*ui_loop_hook) PARAMS ((int signo));
int suspend_count;
int stepped; /* True if stepped. */
CORE_ADDR step_pc;
- unsigned long step_instr;
unsigned long step_prev;
CONTEXT context;
}
static thread_info thread_head =
{NULL};
+static thread_info * thread_rec (DWORD id, int get_context);
/* The process and thread handles for the above context. */
-1
};
-/* This vector maps the target's idea of an exception (extracted
- from the DEBUG_EVENT structure) to GDB's idea. */
-
-struct xlate_exception
- {
- int them;
- enum target_signal us;
- };
-
-static const struct xlate_exception
- xlate[] =
+/* Return a pointer into a CONTEXT field indexed by gdb register number.
+ Return a pointer to an address pointing to zero if there is no
+ corresponding CONTEXT field for the given register number.
+ */
+static ULONG *
+regptr (LPCONTEXT c, int r)
{
- {EXCEPTION_ACCESS_VIOLATION, TARGET_SIGNAL_SEGV},
- {STATUS_STACK_OVERFLOW, TARGET_SIGNAL_SEGV},
- {EXCEPTION_BREAKPOINT, TARGET_SIGNAL_TRAP},
- {DBG_CONTROL_C, TARGET_SIGNAL_INT},
- {EXCEPTION_SINGLE_STEP, TARGET_SIGNAL_TRAP},
- {-1, -1}};
+ static ULONG zero = 0;
+ ULONG *p;
+ if (mappings[r] < 0)
+ p = &zero;
+ else
+ p = (ULONG *) (((char *) c) + mappings[r]);
+ return p;
+}
/******************** Beginning of stub interface ********************/
typedef in wince-stub.h and change the putlen/getlen macros in this file and in
the stub.
*/
+
static int
create_process (LPSTR exec_file, LPSTR args, DWORD flags, PROCESS_INFORMATION * pi)
{
/******************** End of emulation routines. ********************/
/******************** End of stub interface ********************/
+#define check_for_step(a, x) (x)
+
+#ifdef MIPS
+static void
+undoSStep (thread_info * th)
+{
+ if (th->stepped)
+ {
+ memory_remove_breakpoint (th->step_pc, (void *) &th->step_prev);
+ th->stepped = 0;
+ }
+}
+
+void
+wince_software_single_step (unsigned int ignore, int insert_breakpoints_p)
+{
+ unsigned long pc;
+ thread_info *th = current_thread; /* Info on currently selected thread */
+ CORE_ADDR mips_next_pc (CORE_ADDR pc);
+
+ if (!insert_breakpoints_p)
+ {
+ undoSStep (th);
+ return;
+ }
+
+ th->stepped = 1;
+ pc = read_register (PC_REGNUM);
+ th->step_pc = mips_next_pc (pc);
+ th->step_prev = 0;
+ memory_insert_breakpoint (th->step_pc, (void *) &th->step_prev);
+ return;
+}
+#elif SHx
+/* Hitachi SH architecture instruction encoding masks */
+
+#define COND_BR_MASK 0xff00
+#define UCOND_DBR_MASK 0xe000
+#define UCOND_RBR_MASK 0xf0df
+#define TRAPA_MASK 0xff00
+
+#define COND_DISP 0x00ff
+#define UCOND_DISP 0x0fff
+#define UCOND_REG 0x0f00
+
+/* Hitachi SH instruction opcodes */
+
+#define BF_INSTR 0x8b00
+#define BT_INSTR 0x8900
+#define BRA_INSTR 0xa000
+#define BSR_INSTR 0xb000
+#define JMP_INSTR 0x402b
+#define JSR_INSTR 0x400b
+#define RTS_INSTR 0x000b
+#define RTE_INSTR 0x002b
+#define TRAPA_INSTR 0xc300
+#define SSTEP_INSTR 0xc3ff
+
+
+#define T_BIT_MASK 0x0001
+
+static CORE_ADDR
+sh_get_next_pc (CONTEXT *c)
+{
+ short *instrMem;
+ int displacement;
+ int reg;
+ unsigned short opcode;
+
+ instrMem = (short *) c->Fir;
+
+ opcode = read_memory_integer ((CORE_ADDR) c->Fir, sizeof (opcode));
+
+ if ((opcode & COND_BR_MASK) == BT_INSTR)
+ {
+ if (c->Psr & T_BIT_MASK)
+ {
+ displacement = (opcode & COND_DISP) << 1;
+ if (displacement & 0x80)
+ displacement |= 0xffffff00;
+ /*
+ * Remember PC points to second instr.
+ * after PC of branch ... so add 4
+ */
+ instrMem = (short *) (c->Fir + displacement + 4);
+ }
+ else
+ instrMem += 1;
+ }
+ else if ((opcode & COND_BR_MASK) == BF_INSTR)
+ {
+ if (c->Psr & T_BIT_MASK)
+ instrMem += 1;
+ else
+ {
+ displacement = (opcode & COND_DISP) << 1;
+ if (displacement & 0x80)
+ displacement |= 0xffffff00;
+ /*
+ * Remember PC points to second instr.
+ * after PC of branch ... so add 4
+ */
+ instrMem = (short *) (c->Fir + displacement + 4);
+ }
+ }
+ else if ((opcode & UCOND_DBR_MASK) == BRA_INSTR)
+ {
+ displacement = (opcode & UCOND_DISP) << 1;
+ if (displacement & 0x0800)
+ displacement |= 0xfffff000;
+
+ /*
+ * Remember PC points to second instr.
+ * after PC of branch ... so add 4
+ */
+ instrMem = (short *) (c->Fir + displacement + 4);
+ }
+ else if ((opcode & UCOND_RBR_MASK) == JSR_INSTR)
+ {
+ reg = (char) ((opcode & UCOND_REG) >> 8);
+
+ instrMem = (short *) *regptr (c, reg);
+ }
+ else if (opcode == RTS_INSTR)
+ instrMem = (short *) c->PR;
+ else if (opcode == RTE_INSTR)
+ instrMem = (short *) *regptr (c, 15);
+ else if ((opcode & TRAPA_MASK) == TRAPA_INSTR)
+ instrMem = (short *) ((opcode & ~TRAPA_MASK) << 2);
+ else
+ instrMem += 1;
+
+ return (CORE_ADDR) instrMem;
+}
+/* Single step (in a painstaking fashion) by inspecting the current
+ instruction and setting a breakpoint on the "next" instruction
+ which would be executed. This code hails from sh-stub.c.
+ */
+static void
+undoSStep (thread_info * th)
+{
+ if (th->stepped)
+ {
+ memory_remove_breakpoint (th->step_pc, (void *) &th->step_prev);
+ th->stepped = 0;
+ }
+ return;
+}
+
+/* Single step (in a painstaking fashion) by inspecting the current
+ instruction and setting a breakpoint on the "next" instruction
+ which would be executed. This code hails from sh-stub.c.
+ */
+void
+wince_software_single_step (unsigned int ignore, int insert_breakpoints_p)
+{
+ thread_info *th = current_thread; /* Info on currently selected thread */
+
+ if (!insert_breakpoints_p)
+ {
+ undoSStep (th);
+ return;
+ }
+
+ th->stepped = 1;
+ th->step_pc = sh_get_next_pc (&th->context);
+ th->step_prev = 0;
+ memory_insert_breakpoint (th->step_pc, (void *) &th->step_prev);
+ return;
+}
+#elif defined (ARM)
+#undef check_for_step
+
+static enum target_signal
+check_for_step (DEBUG_EVENT *ev, enum target_signal x)
+{
+ thread_info *th = thread_rec (ev->dwThreadId, 1);
+
+ if (th->stepped &&
+ th->step_pc == (CORE_ADDR) ev->u.Exception.ExceptionRecord.ExceptionAddress)
+ return TARGET_SIGNAL_TRAP;
+ else
+ return x;
+}
+
+/* Single step (in a painstaking fashion) by inspecting the current
+ instruction and setting a breakpoint on the "next" instruction
+ which would be executed. This code hails from sh-stub.c.
+ */
+static void
+undoSStep (thread_info * th)
+{
+ if (th->stepped)
+ {
+ memory_remove_breakpoint (th->step_pc, (void *) &th->step_prev);
+ th->stepped = 0;
+ }
+}
+
+void
+wince_software_single_step (unsigned int ignore, int insert_breakpoints_p)
+{
+ unsigned long pc;
+ thread_info *th = current_thread; /* Info on currently selected thread */
+ CORE_ADDR mips_next_pc (CORE_ADDR pc);
+
+ if (!insert_breakpoints_p)
+ {
+ undoSStep (th);
+ return;
+ }
+
+ th->stepped = 1;
+ pc = read_register (PC_REGNUM);
+ th->step_pc = arm_get_next_pc (pc);
+ th->step_prev = 0;
+ memory_insert_breakpoint (th->step_pc, (void *) &th->step_prev);
+ return;
+}
+#endif
+
/* Find a thread record given a thread id.
If get_context then also retrieve the context for this
thread. */
printf_filtered ("error return %s:%d was %d\n", file, line, GetLastError ());
}
-/* Return a pointer into a CONTEXT field indexed by gdb register number.
- Return a pointer to an address pointing to zero if there is no
- corresponding CONTEXT field for the given register number.
- */
-static ULONG *
-regptr (LPCONTEXT c, int r)
-{
- static ULONG zero = 0;
- ULONG *p;
- if (mappings[r] < 0)
- p = &zero;
- else
- p = (ULONG *) (((char *) c) + mappings[r]);
- return p;
-}
-
static void
do_child_fetch_inferior_registers (int r)
{
out:
if (!len)
return 1;
+#if 0
dll_buf[len] = '\0';
+#endif
dll_name = alloca (len);
if (!dll_name)
FIXME: Is this the real reason that we need the 0x1000 ? */
printf_unfiltered ("%x:%s", event->lpBaseOfDll, dll_name);
-#if 0 /* FIXME: Need to use RAPI stuff to read the file someday. */
- {
- struct section_addr_info section_addrs;
- memset (§ion_addrs, 0, sizeof (section_addrs));
- section_addrs.text_addr = (int) event->lpBaseOfDll + 0x1000;
- symbol_file_add (dll_name, 0, §ion_addrs, 0, OBJF_SHARED);
- }
-#endif
printf_unfiltered ("\n");
return 1;
}
-/* Handle DEBUG_STRING output from child process.
- Cygwin prepends its messages with a "cygwin:". Interpret this as
- a Cygwin signal. Otherwise just print the string as a warning. */
+/* Handle DEBUG_STRING output from child process. */
static void
handle_output_debug_string (struct target_waitstatus *ourstatus)
{
}
warning (s);
+
return;
}
static int
handle_exception (struct target_waitstatus *ourstatus)
{
- thread_info *th;
-
+#if 0
if (current_event.u.Exception.dwFirstChance)
return 0;
+#endif
ourstatus->kind = TARGET_WAITKIND_STOPPED;
- /* Record the context of the current thread */
- th = thread_rec (current_event.dwThreadId, -1);
-
switch (current_event.u.Exception.ExceptionRecord.ExceptionCode)
{
case EXCEPTION_ACCESS_VIOLATION:
(unsigned) current_event.u.Exception.ExceptionRecord.ExceptionAddress));
ourstatus->value.sig = TARGET_SIGNAL_TRAP;
break;
+ case EXCEPTION_ILLEGAL_INSTRUCTION:
+ DEBUG_EXCEPT (("gdb: Target exception SINGLE_ILL at 0x%08x\n",
+ current_event.u.Exception.ExceptionRecord.ExceptionAddress));
+ ourstatus->value.sig = check_for_step (¤t_event, TARGET_SIGNAL_ILL);
+ break;
default:
/* This may be a structured exception handling exception. In
- that case, we want to let the program try to handle it, and
- only break if we see the exception a second time. */
+ that case, we want to let the program try to handle it, and
+ only break if we see the exception a second time. */
printf_unfiltered ("gdb: unknown target exception 0x%08x at 0x%08x\n",
current_event.u.Exception.ExceptionRecord.ExceptionCode,
handling by WFI (or whatever).
*/
static int
-get_child_debug_event (int pid, struct target_waitstatus *ourstatus, DWORD * event_code, int *retval)
+get_child_debug_event (int pid, struct target_waitstatus *ourstatus,
+ DWORD target_event_code, int *retval)
{
+ int breakout = 0;
BOOL debug_event;
- DWORD continue_status;
- int breakout = 1;
+ DWORD continue_status, event_code;
+ thread_info *th = NULL;
+ static thread_info dummy_thread_info;
if (!(debug_event = wait_for_debug_event (¤t_event, 1000)))
{
- breakout = *retval = *event_code = 0;
+ *retval = 0;
goto out;
}
- this_thread = thread_rec (current_event.dwThreadId, FALSE);
event_count++;
continue_status = DBG_CONTINUE;
*retval = 0;
- switch (*event_code = current_event.dwDebugEventCode)
+
+ event_code = current_event.dwDebugEventCode;
+ breakout = event_code == target_event_code;
+
+ switch (event_code)
{
case CREATE_THREAD_DEBUG_EVENT:
DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
(unsigned) current_event.dwThreadId,
"CREATE_THREAD_DEBUG_EVENT"));
/* Record the existence of this thread */
- child_add_thread (current_event.dwThreadId,
- current_event.u.CreateThread.hThread);
+ th = child_add_thread (current_event.dwThreadId,
+ current_event.u.CreateThread.hThread);
if (info_verbose)
printf_unfiltered ("[New %s]\n",
target_pid_to_str (current_event.dwThreadId));
(unsigned) current_event.dwThreadId,
"EXIT_THREAD_DEBUG_EVENT"));
child_delete_thread (current_event.dwThreadId);
+ th = &dummy_thread_info;
break;
case CREATE_PROCESS_DEBUG_EVENT:
main_thread_id = inferior_pid = current_event.dwThreadId;
/* Add the main thread */
- current_thread = child_add_thread (inferior_pid,
- current_event.u.CreateProcessInfo.hThread);
+ th = child_add_thread (inferior_pid,
+ current_event.u.CreateProcessInfo.hThread);
break;
case EXIT_PROCESS_DEBUG_EVENT:
ourstatus->value.integer = current_event.u.ExitProcess.dwExitCode;
close_handle (current_process_handle);
*retval = current_event.dwProcessId;
- goto out;
+ breakout = 1;
+ break;
case LOAD_DLL_DEBUG_EVENT:
DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
(unsigned) current_event.dwThreadId,
"EXCEPTION_DEBUG_EVENT"));
if (handle_exception (ourstatus))
+ *retval = current_event.dwThreadId;
+ else
{
- char buf[32];
- *retval = current_event.dwThreadId;
- remote_read_bytes (read_pc (), buf, sizeof (buf));
- dcache_xfer_memory (remote_dcache, read_pc (), buf, sizeof (buf), 0);
- goto out;
+ continue_status = DBG_EXCEPTION_NOT_HANDLED;
+ breakout = 0;
}
- continue_status = DBG_EXCEPTION_NOT_HANDLED;
break;
case OUTPUT_DEBUG_STRING_EVENT: /* message from the kernel */
(unsigned) current_event.dwProcessId,
(unsigned) current_event.dwThreadId,
"OUTPUT_DEBUG_STRING_EVENT"));
- handle_output_debug_string (ourstatus);
+ handle_output_debug_string ( ourstatus);
break;
default:
printf_unfiltered ("gdb: kernel event for pid=%d tid=%d\n",
break;
}
- breakout = 0;
- CHECK (child_continue (continue_status, -1));
+ if (breakout)
+ this_thread = current_thread = th ?: thread_rec (current_event.dwThreadId, TRUE);
+ else
+ CHECK (child_continue (continue_status, -1));
out:
return breakout;
isn't necessarily what you think it is. */
while (1)
- if (get_child_debug_event (pid, ourstatus, &event_code, &retval))
+ if (get_child_debug_event (pid, ourstatus, EXCEPTION_DEBUG_EVENT, &retval))
return retval;
else
{
upload_to_device (const char *to, const char *from)
{
HANDLE h;
- const char *dir = remote_directory ? : "\\gdb";
+ const char *dir = remote_directory ?: "\\gdb";
int len;
static char *remotefile = NULL;
LPWSTR wstr;
char *p;
DWORD err;
const char *in_to = to;
- FILETIME ctime, atime, wtime;
+ FILETIME crtime, actime, wrtime;
+ time_t utime;
struct stat st;
int fd;
/* Some kind of problem? */
err = CeGetLastError ();
- if (h == NULL)
- error ("error creating file to \"%s\". Windows error %d.",
+ if (h == NULL || h == INVALID_HANDLE_VALUE)
+ error ("error opening file \"%s\". Windows error %d.",
remotefile, err);
+ CeGetFileTime (h, &crtime, &actime, &wrtime);
+ utime = to_time_t (&wrtime);
+#if 0
+ if (utime < st.st_mtime)
+ {
+ char buf[80];
+ strcpy (buf, ctime(&utime));
+ printf ("%s < %s\n", buf, ctime(&st.st_mtime));
+ }
+#endif
/* See if we need to upload the file. */
if (upload_when == UPLOAD_ALWAYS ||
err != ERROR_ALREADY_EXISTS ||
- !CeGetFileTime (h, &ctime, &atime, &wtime) ||
- to_time_t (&wtime) < st.st_mtime)
+ !CeGetFileTime (h, &crtime, &actime, &wrtime) ||
+ to_time_t (&wrtime) < st.st_mtime)
{
DWORD nbytes;
char buf[4096];
}
close (fd);
- CeCloseHandle (h);
+ if (!CeCloseHandle (h))
+ error ("error closing remote file - %d.", CeGetLastError ());
return remotefile;
}
target_terminal_init ();
target_terminal_inferior ();
-
/* Run until process and threads are loaded */
- do
- get_child_debug_event (inferior_pid, &dummy, &event_code, &ret);
- while (event_code != CREATE_PROCESS_DEBUG_EVENT);
+ while (!get_child_debug_event (inferior_pid, &dummy,
+ CREATE_PROCESS_DEBUG_EVENT, &ret))
+ continue;
proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0);
}
target_mourn_inferior (); /* or just child_mourn_inferior? */
}
-#ifdef MIPS
-static void
-undoSStep (thread_info * th)
-{
- if (th->stepped)
- {
- memory_remove_breakpoint (th->step_pc, (void *) &th->step_prev);
- th->stepped = 0;
- }
-}
-
-void
-wince_software_single_step (unsigned int ignore, int insert_breakpoints_p)
-{
- unsigned long pc;
- thread_info *th = current_thread; /* Info on currently selected thread */
- CORE_ADDR mips_next_pc (CORE_ADDR pc);
-
- if (!insert_breakpoints_p)
- {
- undoSStep (th);
- return;
- }
-
- th->stepped = 1;
- pc = read_register (PC_REGNUM);
- th->step_pc = mips_next_pc (pc);
- th->step_prev = 0;
- memory_insert_breakpoint (th->step_pc, (void *) &th->step_prev);
-}
-#elif SHx
-/* Hitachi SH architecture instruction encoding masks */
-
-#define COND_BR_MASK 0xff00
-#define UCOND_DBR_MASK 0xe000
-#define UCOND_RBR_MASK 0xf0df
-#define TRAPA_MASK 0xff00
-
-#define COND_DISP 0x00ff
-#define UCOND_DISP 0x0fff
-#define UCOND_REG 0x0f00
-
-/* Hitachi SH instruction opcodes */
-
-#define BF_INSTR 0x8b00
-#define BT_INSTR 0x8900
-#define BRA_INSTR 0xa000
-#define BSR_INSTR 0xb000
-#define JMP_INSTR 0x402b
-#define JSR_INSTR 0x400b
-#define RTS_INSTR 0x000b
-#define RTE_INSTR 0x002b
-#define TRAPA_INSTR 0xc300
-#define SSTEP_INSTR 0xc3ff
-
-
-#define T_BIT_MASK 0x0001
-
-/* Undo the effect of a previous doSStep. If we single stepped,
- restore the old instruction. */
-
-static void
-undoSStep (thread_info * th)
-{
- if (th->stepped)
- {
- gdb_wince_len done;
- write_process_memory (current_process_handle, (LPVOID) th->step_pc,
- (LPVOID) & th->step_instr, sizeof (short), &done);
- if (done != sizeof (short))
- error ("error unsetting single step.");
- th->stepped = 0;
- }
-}
-
-/* Single step (in a painstaking fashion) by inspecting the current
- instruction and setting a breakpoint on the "next" instruction
- which would be executed. This code hails from sh-stub.c.
- */
-void
-wince_software_single_step (unsigned int ignore, int insert_breakpoints_p)
-{
- thread_info *th = current_thread; /* Info on currently selected thread */
-
- if (!insert_breakpoints_p)
- undoSStep (th);
- else
- {
- short *instrMem;
- int displacement;
- int reg;
- unsigned short opcode;
- gdb_wince_len done;
- LPCONTEXT c = &th->context;
-
- instrMem = (short *) c->Fir;
-
- read_process_memory (current_process_handle, (LPCVOID) c->Fir, &opcode,
- sizeof (opcode), &done);
- if (done != sizeof (opcode))
- error ("couldn't retrieve opcode");
- th->stepped = 1;
-
- if ((opcode & COND_BR_MASK) == BT_INSTR)
- {
- if (c->Psr & T_BIT_MASK)
- {
- displacement = (opcode & COND_DISP) << 1;
- if (displacement & 0x80)
- displacement |= 0xffffff00;
- /*
- * Remember PC points to second instr.
- * after PC of branch ... so add 4
- */
- instrMem = (short *) (c->Fir + displacement + 4);
- }
- else
- instrMem += 1;
- }
- else if ((opcode & COND_BR_MASK) == BF_INSTR)
- {
- if (c->Psr & T_BIT_MASK)
- instrMem += 1;
- else
- {
- displacement = (opcode & COND_DISP) << 1;
- if (displacement & 0x80)
- displacement |= 0xffffff00;
- /*
- * Remember PC points to second instr.
- * after PC of branch ... so add 4
- */
- instrMem = (short *) (c->Fir + displacement + 4);
- }
- }
- else if ((opcode & UCOND_DBR_MASK) == BRA_INSTR)
- {
- displacement = (opcode & UCOND_DISP) << 1;
- if (displacement & 0x0800)
- displacement |= 0xfffff000;
-
- /*
- * Remember PC points to second instr.
- * after PC of branch ... so add 4
- */
- instrMem = (short *) (c->Fir + displacement + 4);
- }
- else if ((opcode & UCOND_RBR_MASK) == JSR_INSTR)
- {
- reg = (char) ((opcode & UCOND_REG) >> 8);
-
- instrMem = (short *) *regptr (c, reg);
- }
- else if (opcode == RTS_INSTR)
- instrMem = (short *) c->PR;
- else if (opcode == RTE_INSTR)
- instrMem = (short *) *regptr (c, 15);
- else if ((opcode & TRAPA_MASK) == TRAPA_INSTR)
- instrMem = (short *) ((opcode & ~TRAPA_MASK) << 2);
- else
- instrMem += 1;
-
- th->step_pc = (CORE_ADDR) instrMem;
-
- read_process_memory (current_process_handle, (LPVOID) instrMem,
- (LPVOID) & th->step_instr, sizeof (short), &done);
- opcode = SSTEP_INSTR;
- write_process_memory (current_process_handle, (LPVOID) instrMem,
- (LPVOID) & opcode, sizeof (short), &done);
- }
-}
-#elif defined (ARM)
-/* Single step (in a painstaking fashion) by inspecting the current
- instruction and setting a breakpoint on the "next" instruction
- which would be executed. This code hails from sh-stub.c.
- */
-static void
-undoSStep (thread_info * th)
-{
- if (th->stepped)
- {
- memory_remove_breakpoint (th->step_pc, (void *) &th->step_prev);
- th->stepped = 0;
- }
-}
-
-void
-wince_software_single_step (unsigned int ignore, int insert_breakpoints_p)
-{
- unsigned long pc;
- thread_info *th = current_thread; /* Info on currently selected thread */
- CORE_ADDR mips_next_pc (CORE_ADDR pc);
-
- if (!insert_breakpoints_p)
- {
- undoSStep (th);
- return;
- }
-
- th->stepped = 1;
- pc = read_register (PC_REGNUM);
- th->step_pc = arm_get_next_pc (pc);
- th->step_prev = 0;
- memory_insert_breakpoint (th->step_pc, (void *) &th->step_prev);
-}
-#endif
-
/* Resume the child after an exception. */
void
child_resume (int pid, int step, enum target_signal sig)
/* Handle 'set remoteupload' parameter. */
#define replace_upload(what) \
- upload_when = UPLOAD_NEWER; \
- remote_upload = realloc (remote_upload, strlen (upload_options[upload_when].name)); \
+ upload_when = what; \
+ remote_upload = realloc (remote_upload, strlen (upload_options[upload_when].name) + 1); \
strcpy (remote_upload, upload_options[upload_when].name);
static void
if (len >= upload_options[i].abbrev &&
strncasecmp (remote_upload, upload_options[i].name, len) == 0)
{
- remote_upload = (char *) upload_options[i].name;
- upload_when = i;
+ replace_upload (i);
return;
}
projects / binutils-gdb.git / commitdiff