1 /* Target-vector operations for controlling Windows CE child processes, for GDB.
2 Copyright 1999, 2000 Free Software Foundation, Inc.
3 Contributed by Cygnus Solutions, A Red Hat Company.
5 This file is part of GDB.
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.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
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.
23 /* by Christopher Faylor (cgf@cygnus.com) */
25 /* We assume we're being built with and will be used for cygwin. */
29 #define SH4 /* Just to get all of the CONTEXT defines. */
33 #include "frame.h" /* required by inferior.h */
39 #include <sys/types.h>
46 #include <cygwin/in.h>
47 #include <cygwin/socket.h>
52 #include "gdb_string.h"
53 #include "gdbthread.h"
55 #include <sys/param.h>
56 #include "wince-stub.h"
59 /* The ui's event loop. */
60 extern int (*ui_loop_hook
) (int signo
);
62 /* If we're not using the old Cygwin header file set, define the
63 following which never should have been in the generic Win32 API
64 headers in the first place since they were our own invention... */
65 #ifndef _GNU_H_WINDOWS_H
66 #define FLAG_TRACE_BIT 0x100
67 #ifdef CONTEXT_FLOATING_POINT
68 #define CONTEXT_DEBUGGER0 (CONTEXT_FULL | CONTEXT_FLOATING_POINT)
70 #define CONTEXT_DEBUGGER0 (CONTEXT_FULL)
75 #define CONTEXT_DEBUGGER ((CONTEXT_DEBUGGER0 & ~(CONTEXT_SH4 | CONTEXT_FLOATING_POINT)) | CONTEXT_SH3)
77 #define CONTEXT_DEBUGGER CONTEXT_DEBUGGER0
79 /* The string sent by cygwin when it processes a signal.
80 FIXME: This should be in a cygwin include file. */
81 #define CYGWIN_SIGNAL_STRING "cygwin: signal"
83 #define CHECK(x) check (x, __FILE__,__LINE__)
84 #define DEBUG_EXEC(x) if (debug_exec) printf x
85 #define DEBUG_EVENTS(x) if (debug_events) printf x
86 #define DEBUG_MEM(x) if (debug_memory) printf x
87 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf x
89 static int connection_initialized
= 0; /* True if we've initialized a RAPI session. */
91 /* The directory where the stub and executable files are uploaded. */
92 static const char *remote_directory
= "\\gdb";
94 /* The types automatic upload available. */
101 upload_when
= UPLOAD_NEWER
;
103 /* Valid options for 'set remoteupload'. Note that options
104 must track upload_when enum. */
125 static char *remote_upload
= NULL
; /* Set by set remoteupload */
126 static int remote_add_host
= 0;
128 /* Forward declaration */
129 extern struct target_ops child_ops
;
131 static int win32_child_thread_alive (int);
132 void child_kill_inferior (void);
134 static int last_sig
= 0; /* Set if a signal was received from the
137 /* Thread information structure used to track information that is
138 not available in gdb's thread structure. */
139 typedef struct thread_info_struct
141 struct thread_info_struct
*next
;
146 int stepped
; /* True if stepped. */
148 unsigned long step_prev
;
153 static thread_info thread_head
=
155 static thread_info
* thread_rec (DWORD id
, int get_context
);
157 /* The process and thread handles for the above context. */
159 static DEBUG_EVENT current_event
; /* The current debug event from
161 static HANDLE current_process_handle
; /* Currently executing process */
162 static thread_info
*current_thread
; /* Info on currently selected thread */
163 static thread_info
*this_thread
; /* Info on thread returned by wait_for_debug_event */
164 static DWORD main_thread_id
; /* Thread ID of the main thread */
166 /* Counts of things. */
167 static int exception_count
= 0;
168 static int event_count
= 0;
171 static int debug_exec
= 0; /* show execution */
172 static int debug_events
= 0; /* show events from kernel */
173 static int debug_memory
= 0; /* show target memory accesses */
174 static int debug_exceptions
= 0; /* show target exceptions */
176 /* An array of offset mappings into a Win32 Context structure.
177 This is a one-to-one mapping which is indexed by gdb's register
178 numbers. It retrieves an offset into the context structure where
179 the 4 byte register is located.
180 An offset value of -1 indicates that Win32 does not provide this
181 register in it's CONTEXT structure. regptr will return zero for this
184 This is used by the regptr function. */
185 #define context_offset(x) ((int)&(((PCONTEXT)NULL)->x))
186 static const int mappings
[NUM_REGS
+ 1] =
189 context_offset (Eax
),
190 context_offset (Ecx
),
191 context_offset (Edx
),
192 context_offset (Ebx
),
193 context_offset (Esp
),
194 context_offset (Ebp
),
195 context_offset (Esi
),
196 context_offset (Edi
),
197 context_offset (Eip
),
198 context_offset (EFlags
),
199 context_offset (SegCs
),
200 context_offset (SegSs
),
201 context_offset (SegDs
),
202 context_offset (SegEs
),
203 context_offset (SegFs
),
204 context_offset (SegGs
),
205 context_offset (FloatSave
.RegisterArea
[0 * 10]),
206 context_offset (FloatSave
.RegisterArea
[1 * 10]),
207 context_offset (FloatSave
.RegisterArea
[2 * 10]),
208 context_offset (FloatSave
.RegisterArea
[3 * 10]),
209 context_offset (FloatSave
.RegisterArea
[4 * 10]),
210 context_offset (FloatSave
.RegisterArea
[5 * 10]),
211 context_offset (FloatSave
.RegisterArea
[6 * 10]),
212 context_offset (FloatSave
.RegisterArea
[7 * 10]),
224 context_offset (R10
),
225 context_offset (R11
),
226 context_offset (R12
),
227 context_offset (R13
),
228 context_offset (R14
),
229 context_offset (R15
),
230 context_offset (Fir
),
231 context_offset (PR
), /* Procedure Register */
232 context_offset (GBR
), /* Global Base Register */
233 context_offset (MACH
), /* Accumulate */
234 context_offset (MACL
), /* Multiply */
235 context_offset (Psr
),
236 context_offset (Fpul
),
237 context_offset (Fpscr
),
238 context_offset (FRegs
[0]),
239 context_offset (FRegs
[1]),
240 context_offset (FRegs
[2]),
241 context_offset (FRegs
[3]),
242 context_offset (FRegs
[4]),
243 context_offset (FRegs
[5]),
244 context_offset (FRegs
[6]),
245 context_offset (FRegs
[7]),
246 context_offset (FRegs
[8]),
247 context_offset (FRegs
[9]),
248 context_offset (FRegs
[10]),
249 context_offset (FRegs
[11]),
250 context_offset (FRegs
[12]),
251 context_offset (FRegs
[13]),
252 context_offset (FRegs
[14]),
253 context_offset (FRegs
[15]),
254 context_offset (xFRegs
[0]),
255 context_offset (xFRegs
[1]),
256 context_offset (xFRegs
[2]),
257 context_offset (xFRegs
[3]),
258 context_offset (xFRegs
[4]),
259 context_offset (xFRegs
[5]),
260 context_offset (xFRegs
[6]),
261 context_offset (xFRegs
[7]),
262 context_offset (xFRegs
[8]),
263 context_offset (xFRegs
[9]),
264 context_offset (xFRegs
[10]),
265 context_offset (xFRegs
[11]),
266 context_offset (xFRegs
[12]),
267 context_offset (xFRegs
[13]),
268 context_offset (xFRegs
[14]),
269 context_offset (xFRegs
[15]),
271 context_offset (IntZero
),
272 context_offset (IntAt
),
273 context_offset (IntV0
),
274 context_offset (IntV1
),
275 context_offset (IntA0
),
276 context_offset (IntA1
),
277 context_offset (IntA2
),
278 context_offset (IntA3
),
279 context_offset (IntT0
),
280 context_offset (IntT1
),
281 context_offset (IntT2
),
282 context_offset (IntT3
),
283 context_offset (IntT4
),
284 context_offset (IntT5
),
285 context_offset (IntT6
),
286 context_offset (IntT7
),
287 context_offset (IntS0
),
288 context_offset (IntS1
),
289 context_offset (IntS2
),
290 context_offset (IntS3
),
291 context_offset (IntS4
),
292 context_offset (IntS5
),
293 context_offset (IntS6
),
294 context_offset (IntS7
),
295 context_offset (IntT8
),
296 context_offset (IntT9
),
297 context_offset (IntK0
),
298 context_offset (IntK1
),
299 context_offset (IntGp
),
300 context_offset (IntSp
),
301 context_offset (IntS8
),
302 context_offset (IntRa
),
303 context_offset (Psr
),
304 context_offset (IntLo
),
305 context_offset (IntHi
),
308 context_offset (Fir
),
309 context_offset (FltF0
),
310 context_offset (FltF1
),
311 context_offset (FltF2
),
312 context_offset (FltF3
),
313 context_offset (FltF4
),
314 context_offset (FltF5
),
315 context_offset (FltF6
),
316 context_offset (FltF7
),
317 context_offset (FltF8
),
318 context_offset (FltF9
),
319 context_offset (FltF10
),
320 context_offset (FltF11
),
321 context_offset (FltF12
),
322 context_offset (FltF13
),
323 context_offset (FltF14
),
324 context_offset (FltF15
),
325 context_offset (FltF16
),
326 context_offset (FltF17
),
327 context_offset (FltF18
),
328 context_offset (FltF19
),
329 context_offset (FltF20
),
330 context_offset (FltF21
),
331 context_offset (FltF22
),
332 context_offset (FltF23
),
333 context_offset (FltF24
),
334 context_offset (FltF25
),
335 context_offset (FltF26
),
336 context_offset (FltF27
),
337 context_offset (FltF28
),
338 context_offset (FltF29
),
339 context_offset (FltF30
),
340 context_offset (FltF31
),
341 context_offset (Fsr
),
342 context_offset (Fir
),
355 context_offset (R10
),
356 context_offset (R11
),
357 context_offset (R12
),
370 context_offset (Psr
),
375 /* Return a pointer into a CONTEXT field indexed by gdb register number.
376 Return a pointer to an address pointing to zero if there is no
377 corresponding CONTEXT field for the given register number.
380 regptr (LPCONTEXT c
, int r
)
382 static ULONG zero
= 0;
387 p
= (ULONG
*) (((char *) c
) + mappings
[r
]);
391 /******************** Beginning of stub interface ********************/
393 /* Stub interface description:
395 The Windows CE stub implements a crude RPC. The hand-held device
396 connects to gdb using port 7000. gdb and the stub then communicate
399 byte 0: command id (e.g. Create Process)
406 byte 3-n: arbitrary memory.
408 The interface is deterministic, i.e., if the stub expects a DWORD then
409 the gdb server should send a DWORD.
412 /* Note: In the functions below, the `huh' parameter is a string passed from the
413 function containing a descriptive string concerning the current operation.
414 This is used for error reporting.
416 The 'what' parameter is a command id as found in wince-stub.h.
418 Hopefully, the rest of the parameters are self-explanatory.
421 static int s
; /* communication socket */
423 /* v-style interface for handling varying argyment list error messages.
424 Displays the error message in a dialog box and exits when user clicks
427 vstub_error (LPCSTR fmt
, va_list * args
)
430 vsprintf (buf
, fmt
, args
);
435 /* The standard way to display an error message and exit. */
437 stub_error (LPCSTR fmt
,...)
440 va_start (args
, fmt
);
441 vstub_error (fmt
, args
);
444 /* Standard "oh well" can't communicate error. Someday this might attempt
447 attempt_resync (LPCSTR huh
, int s
)
449 stub_error ("lost synchronization with target attempting %s", huh
);
452 /* Read arbitrary stuff from a socket. */
454 sockread (LPCSTR huh
, int s
, void *str
, size_t n
)
458 if (recv (s
, str
, n
, 0) == n
)
460 attempt_resync (huh
, s
);
464 /* Write arbitrary stuff to a socket. */
466 sockwrite (LPCSTR huh
, const void *str
, size_t n
)
470 if (send (s
, str
, n
, 0) == n
)
472 attempt_resync (huh
, s
);
476 /* Output an id/dword to the host */
478 putdword (LPCSTR huh
, gdb_wince_id what
, DWORD n
)
480 if (sockwrite (huh
, &what
, sizeof (what
)) != sizeof (what
))
481 stub_error ("error writing record id to host for %s", huh
);
482 if (sockwrite (huh
, &n
, sizeof (n
)) != sizeof (n
))
483 stub_error ("error writing %s to host.", huh
);
486 /* Output an id/word to the host */
488 putword (LPCSTR huh
, gdb_wince_id what
, WORD n
)
490 if (sockwrite (huh
, &what
, sizeof (what
)) != sizeof (what
))
491 stub_error ("error writing record id to host for %s", huh
);
492 if (sockwrite (huh
, &n
, sizeof (n
)) != sizeof (n
))
493 stub_error ("error writing %s host.", huh
);
496 /* Convenience define for outputting a "gdb_wince_len" type. */
497 #define putlen(huh, what, n) putword((huh), (what), (gdb_wince_len) (n))
499 /* Put an arbitrary block of memory to the gdb host. This comes in
500 two chunks an id/dword representing the length and the stream of memory
503 putmemory (LPCSTR huh
, gdb_wince_id what
, const void *mem
, gdb_wince_len len
)
505 putlen (huh
, what
, len
);
506 if (((short) len
> 0) && sockwrite (huh
, mem
, len
) != len
)
507 stub_error ("error writing %s to host.", huh
);
510 /* Output the result of an operation to the host. If res != 0, sends a block of
511 memory starting at mem of len bytes. If res == 0, sends -GetLastError () and
512 avoids sending the mem. */
514 getdword (LPCSTR huh
, gdb_wince_id what_this
)
519 if (sockread (huh
, s
, &what
, sizeof (what
)) != sizeof (what
))
520 stub_error ("error getting record type from host - %s.", huh
);
521 while (what_this
!= what
);
523 if (sockread (huh
, s
, &n
, sizeof (n
)) != sizeof (n
))
524 stub_error ("error getting %s from host.", huh
);
529 /* Get a an ID (possibly) and a WORD from the host gdb.
530 Don't bother with the id if the main loop has already
533 getword (LPCSTR huh
, gdb_wince_id what_this
)
538 if (sockread (huh
, s
, &what
, sizeof (what
)) != sizeof (what
))
539 stub_error ("error getting record type from host - %s.", huh
);
540 while (what_this
!= what
);
542 if (sockread (huh
, s
, &n
, sizeof (n
)) != sizeof (n
))
543 stub_error ("error getting %s from host.", huh
);
548 /* Handy defines for getting/putting various types of values. */
549 #define gethandle(huh, what) (HANDLE) getdword ((huh), (what))
550 #define getpvoid(huh, what) (LPVOID) getdword ((huh), (what))
551 #define getlen(huh, what) (gdb_wince_len) getword ((huh), (what))
552 #define puthandle(huh, what, h) putdword ((huh), (what), (DWORD) (h))
553 #define putpvoid(huh, what, p) putdword ((huh), (what), (DWORD) (p))
555 /* Retrieve the result of an operation from the stub. If nbytes < 0) then nbytes
556 is actually an error and nothing else follows. Use SetLastError to remember this.
557 if nbytes > 0, retrieve a block of *nbytes into buf.
560 getresult (LPCSTR huh
, gdb_wince_id what
, LPVOID buf
, gdb_wince_len
* nbytes
)
566 *nbytes
= getlen (huh
, what
);
568 if ((short) *nbytes
< 0)
570 SetLastError (-(short) *nbytes
);
574 if ((gdb_wince_len
) sockread (huh
, s
, buf
, *nbytes
) != *nbytes
)
575 stub_error ("couldn't read information from wince stub - %s", huh
);
580 /* Convert "narrow" string to "wide". Manipulates a buffer ring of 8
581 buffers which hold the translated string. This is an arbitrary limit
582 but it is approximately double the current needs of this module.
585 towide (const char *s
, gdb_wince_len
* out_len
)
588 static LPWSTR outs
[8] =
589 {NULL
/*, NULL, etc. */ };
595 /* First determine the length required to hold the converted string. */
596 *out_len
= sizeof (WCHAR
) * MultiByteToWideChar (CP_ACP
, 0, s
, -1, NULL
, 0);
598 return NULL
; /* The conversion failed */
600 if (++n
>= (sizeof (outs
) / sizeof (outs
[0])))
603 /* Allocate space for the converted string, reusing any previously allocated
604 space, if applicable. Note that if outs[n] is NULL, realloc will act as
605 a malloc (under cygwin, at least).
607 outs
[n
] = (LPWSTR
) realloc (outs
[n
], *out_len
);
608 memset (outs
[n
], 0, *out_len
);
609 (void) MultiByteToWideChar (CP_ACP
, 0, s
, -1, outs
[n
], *out_len
);
613 /******************** Emulation routines start here. ********************
615 The functions below are modelled after their Win32 counterparts. They are named
616 similarly to Win32 and take exactly the same arguments except where otherwise noted.
617 They communicate with the stub on the hand-held device by sending their arguments
618 over the socket and waiting for results from the socket.
620 There is one universal change. In cases where a length is expected to be returned
621 in a DWORD, we use a gdb_wince_len type instead. Currently this is an unsigned short
622 which is smaller than the standard Win32 DWORD. This is done to minimize unnecessary
623 traffic since the connection to Windows CE can be slow. To change this, modify the
624 typedef in wince-stub.h and change the putlen/getlen macros in this file and in
629 create_process (LPSTR exec_file
, LPSTR args
, DWORD flags
, PROCESS_INFORMATION
* pi
)
634 buf
= towide (exec_file
, &len
);
635 putmemory ("CreateProcess exec_file", GDB_CREATEPROCESS
, buf
, len
);
636 buf
= towide (args
, &len
);
637 putmemory ("CreateProcess args", GDB_CREATEPROCESS
, buf
, len
);
638 putdword ("CreateProcess flags", GDB_CREATEPROCESS
, flags
);
639 return getresult ("CreateProcess result", GDB_CREATEPROCESS
, pi
, NULL
);
642 /* Emulate TerminateProcess. Don't bother with the second argument since CE
646 terminate_process (HANDLE h
)
648 gdb_wince_result res
;
651 puthandle ("TerminateProcess handle", GDB_TERMINATEPROCESS
, h
);
652 return getresult ("TerminateProcess result", GDB_TERMINATEPROCESS
, &res
, NULL
);
656 wait_for_debug_event (DEBUG_EVENT
* ev
, DWORD ms
)
660 putdword ("WaitForDebugEvent ms", GDB_WAITFORDEBUGEVENT
, ms
);
661 return getresult ("WaitForDebugEvent event", GDB_WAITFORDEBUGEVENT
, ev
, NULL
);
665 get_thread_context (HANDLE h
, CONTEXT
* c
)
669 puthandle ("GetThreadContext handle", GDB_GETTHREADCONTEXT
, h
);
670 putdword ("GetThreadContext flags", GDB_GETTHREADCONTEXT
, c
->ContextFlags
);
671 return getresult ("GetThreadContext context", GDB_GETTHREADCONTEXT
, c
, NULL
);
675 set_thread_context (HANDLE h
, CONTEXT
* c
)
677 gdb_wince_result res
;
680 puthandle ("SetThreadContext handle", GDB_SETTHREADCONTEXT
, h
);
681 putmemory ("SetThreadContext context", GDB_SETTHREADCONTEXT
, c
, sizeof (*c
));
682 return getresult ("SetThreadContext context", GDB_SETTHREADCONTEXT
, &res
, NULL
);
686 read_process_memory (HANDLE h
, LPCVOID where
, LPVOID buf
, gdb_wince_len len
, gdb_wince_len
* nbytes
)
690 puthandle ("ReadProcessMemory handle", GDB_READPROCESSMEMORY
, h
);
691 putpvoid ("ReadProcessMemory location", GDB_READPROCESSMEMORY
, where
);
692 putlen ("ReadProcessMemory size", GDB_READPROCESSMEMORY
, len
);
694 return getresult ("ReadProcessMemory buf", GDB_READPROCESSMEMORY
, buf
, nbytes
);
698 write_process_memory (HANDLE h
, LPCVOID where
, LPCVOID buf
, gdb_wince_len len
, gdb_wince_len
* nbytes
)
702 puthandle ("WriteProcessMemory handle", GDB_WRITEPROCESSMEMORY
, h
);
703 putpvoid ("WriteProcessMemory location", GDB_WRITEPROCESSMEMORY
, where
);
704 putmemory ("WriteProcProcessMemory buf", GDB_WRITEPROCESSMEMORY
, buf
, len
);
706 return getresult ("WriteProcessMemory result", GDB_WRITEPROCESSMEMORY
, nbytes
, NULL
);
710 remote_read_bytes (CORE_ADDR memaddr
, char *myaddr
, int len
)
712 gdb_wince_len nbytes
;
713 if (!read_process_memory (current_process_handle
, (LPCVOID
) memaddr
,
714 (LPVOID
) myaddr
, len
, &nbytes
))
720 remote_write_bytes (CORE_ADDR memaddr
, char *myaddr
, int len
)
722 gdb_wince_len nbytes
;
723 if (!write_process_memory (current_process_handle
, (LPCVOID
) memaddr
,
724 (LPCVOID
) myaddr
, len
, &nbytes
))
729 /* This is not a standard Win32 function. It instructs the stub to return TRUE
730 if the thread referenced by HANDLE h is alive.
733 thread_alive (HANDLE h
)
735 gdb_wince_result res
;
738 puthandle ("ThreadAlive handle", GDB_THREADALIVE
, h
);
739 return getresult ("ThreadAlive result", GDB_THREADALIVE
, &res
, NULL
);
743 suspend_thread (HANDLE h
)
747 puthandle ("SuspendThread handle", GDB_SUSPENDTHREAD
, h
);
748 return (int) getdword ("SuspendThread result", GDB_SUSPENDTHREAD
);
752 resume_thread (HANDLE h
)
756 puthandle ("ResumeThread handle", GDB_RESUMETHREAD
, h
);
757 return (int) getdword ("SuspendThread result", GDB_RESUMETHREAD
);
761 continue_debug_event (DWORD pid
, DWORD tid
, DWORD status
)
763 gdb_wince_result res
;
766 putdword ("ContinueDebugEvent pid", GDB_CONTINUEDEBUGEVENT
, pid
);
767 putdword ("ContinueDebugEvent tid", GDB_CONTINUEDEBUGEVENT
, tid
);
768 putdword ("ContinueDebugEvent status", GDB_CONTINUEDEBUGEVENT
, status
);
769 return getresult ("ContinueDebugEvent result", GDB_CONTINUEDEBUGEVENT
, &res
, NULL
);
773 close_handle (HANDLE h
)
775 gdb_wince_result res
;
778 puthandle ("CloseHandle handle", GDB_CLOSEHANDLE
, h
);
779 return (int) getresult ("CloseHandle result", GDB_CLOSEHANDLE
, &res
, NULL
);
782 /* This is not a standard Win32 interface. This function tells the stub
790 (void) putdword ("Stopping gdb stub", GDB_STOPSTUB
, 0);
794 /******************** End of emulation routines. ********************/
795 /******************** End of stub interface ********************/
797 #define check_for_step(a, x) (x)
801 undoSStep (thread_info
* th
)
805 memory_remove_breakpoint (th
->step_pc
, (void *) &th
->step_prev
);
811 wince_software_single_step (unsigned int ignore
, int insert_breakpoints_p
)
814 thread_info
*th
= current_thread
; /* Info on currently selected thread */
815 CORE_ADDR
mips_next_pc (CORE_ADDR pc
);
817 if (!insert_breakpoints_p
)
824 pc
= read_register (PC_REGNUM
);
825 th
->step_pc
= mips_next_pc (pc
);
827 memory_insert_breakpoint (th
->step_pc
, (void *) &th
->step_prev
);
831 /* Hitachi SH architecture instruction encoding masks */
833 #define COND_BR_MASK 0xff00
834 #define UCOND_DBR_MASK 0xe000
835 #define UCOND_RBR_MASK 0xf0df
836 #define TRAPA_MASK 0xff00
838 #define COND_DISP 0x00ff
839 #define UCOND_DISP 0x0fff
840 #define UCOND_REG 0x0f00
842 /* Hitachi SH instruction opcodes */
844 #define BF_INSTR 0x8b00
845 #define BT_INSTR 0x8900
846 #define BRA_INSTR 0xa000
847 #define BSR_INSTR 0xb000
848 #define JMP_INSTR 0x402b
849 #define JSR_INSTR 0x400b
850 #define RTS_INSTR 0x000b
851 #define RTE_INSTR 0x002b
852 #define TRAPA_INSTR 0xc300
853 #define SSTEP_INSTR 0xc3ff
856 #define T_BIT_MASK 0x0001
859 sh_get_next_pc (CONTEXT
*c
)
864 unsigned short opcode
;
866 instrMem
= (short *) c
->Fir
;
868 opcode
= read_memory_integer ((CORE_ADDR
) c
->Fir
, sizeof (opcode
));
870 if ((opcode
& COND_BR_MASK
) == BT_INSTR
)
872 if (c
->Psr
& T_BIT_MASK
)
874 displacement
= (opcode
& COND_DISP
) << 1;
875 if (displacement
& 0x80)
876 displacement
|= 0xffffff00;
878 * Remember PC points to second instr.
879 * after PC of branch ... so add 4
881 instrMem
= (short *) (c
->Fir
+ displacement
+ 4);
886 else if ((opcode
& COND_BR_MASK
) == BF_INSTR
)
888 if (c
->Psr
& T_BIT_MASK
)
892 displacement
= (opcode
& COND_DISP
) << 1;
893 if (displacement
& 0x80)
894 displacement
|= 0xffffff00;
896 * Remember PC points to second instr.
897 * after PC of branch ... so add 4
899 instrMem
= (short *) (c
->Fir
+ displacement
+ 4);
902 else if ((opcode
& UCOND_DBR_MASK
) == BRA_INSTR
)
904 displacement
= (opcode
& UCOND_DISP
) << 1;
905 if (displacement
& 0x0800)
906 displacement
|= 0xfffff000;
909 * Remember PC points to second instr.
910 * after PC of branch ... so add 4
912 instrMem
= (short *) (c
->Fir
+ displacement
+ 4);
914 else if ((opcode
& UCOND_RBR_MASK
) == JSR_INSTR
)
916 reg
= (char) ((opcode
& UCOND_REG
) >> 8);
918 instrMem
= (short *) *regptr (c
, reg
);
920 else if (opcode
== RTS_INSTR
)
921 instrMem
= (short *) c
->PR
;
922 else if (opcode
== RTE_INSTR
)
923 instrMem
= (short *) *regptr (c
, 15);
924 else if ((opcode
& TRAPA_MASK
) == TRAPA_INSTR
)
925 instrMem
= (short *) ((opcode
& ~TRAPA_MASK
) << 2);
929 return (CORE_ADDR
) instrMem
;
931 /* Single step (in a painstaking fashion) by inspecting the current
932 instruction and setting a breakpoint on the "next" instruction
933 which would be executed. This code hails from sh-stub.c.
936 undoSStep (thread_info
* th
)
940 memory_remove_breakpoint (th
->step_pc
, (void *) &th
->step_prev
);
946 /* Single step (in a painstaking fashion) by inspecting the current
947 instruction and setting a breakpoint on the "next" instruction
948 which would be executed. This code hails from sh-stub.c.
951 wince_software_single_step (unsigned int ignore
, int insert_breakpoints_p
)
953 thread_info
*th
= current_thread
; /* Info on currently selected thread */
955 if (!insert_breakpoints_p
)
962 th
->step_pc
= sh_get_next_pc (&th
->context
);
964 memory_insert_breakpoint (th
->step_pc
, (void *) &th
->step_prev
);
968 #undef check_for_step
970 static enum target_signal
971 check_for_step (DEBUG_EVENT
*ev
, enum target_signal x
)
973 thread_info
*th
= thread_rec (ev
->dwThreadId
, 1);
976 th
->step_pc
== (CORE_ADDR
) ev
->u
.Exception
.ExceptionRecord
.ExceptionAddress
)
977 return TARGET_SIGNAL_TRAP
;
982 /* Single step (in a painstaking fashion) by inspecting the current
983 instruction and setting a breakpoint on the "next" instruction
984 which would be executed. This code hails from sh-stub.c.
987 undoSStep (thread_info
* th
)
991 memory_remove_breakpoint (th
->step_pc
, (void *) &th
->step_prev
);
997 wince_software_single_step (unsigned int ignore
, int insert_breakpoints_p
)
1000 thread_info
*th
= current_thread
; /* Info on currently selected thread */
1001 CORE_ADDR
mips_next_pc (CORE_ADDR pc
);
1003 if (!insert_breakpoints_p
)
1010 pc
= read_register (PC_REGNUM
);
1011 th
->step_pc
= arm_get_next_pc (pc
);
1013 memory_insert_breakpoint (th
->step_pc
, (void *) &th
->step_prev
);
1018 /* Find a thread record given a thread id.
1019 If get_context then also retrieve the context for this
1021 static thread_info
*
1022 thread_rec (DWORD id
, int get_context
)
1026 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1029 if (!th
->suspend_count
&& get_context
)
1031 if (get_context
> 0 && th
!= this_thread
)
1032 th
->suspend_count
= suspend_thread (th
->h
) + 1;
1033 else if (get_context
< 0)
1034 th
->suspend_count
= -1;
1036 th
->context
.ContextFlags
= CONTEXT_DEBUGGER
;
1037 get_thread_context (th
->h
, &th
->context
);
1045 /* Add a thread to the thread list */
1046 static thread_info
*
1047 child_add_thread (DWORD id
, HANDLE h
)
1051 if ((th
= thread_rec (id
, FALSE
)))
1054 th
= (thread_info
*) xmalloc (sizeof (*th
));
1055 memset (th
, 0, sizeof (*th
));
1058 th
->next
= thread_head
.next
;
1059 thread_head
.next
= th
;
1064 /* Clear out any old thread list and reintialize it to a
1067 child_init_thread_list (void)
1069 thread_info
*th
= &thread_head
;
1071 DEBUG_EVENTS (("gdb: child_init_thread_list\n"));
1072 init_thread_list ();
1073 while (th
->next
!= NULL
)
1075 thread_info
*here
= th
->next
;
1076 th
->next
= here
->next
;
1077 (void) close_handle (here
->h
);
1082 /* Delete a thread from the list of threads */
1084 child_delete_thread (DWORD id
)
1089 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (id
));
1092 for (th
= &thread_head
;
1093 th
->next
!= NULL
&& th
->next
->id
!= id
;
1097 if (th
->next
!= NULL
)
1099 thread_info
*here
= th
->next
;
1100 th
->next
= here
->next
;
1101 close_handle (here
->h
);
1107 check (BOOL ok
, const char *file
, int line
)
1110 printf_filtered ("error return %s:%d was %d\n", file
, line
, GetLastError ());
1114 do_child_fetch_inferior_registers (int r
)
1118 supply_register (r
, (char *) regptr (¤t_thread
->context
, r
));
1122 for (r
= 0; r
< NUM_REGS
; r
++)
1123 do_child_fetch_inferior_registers (r
);
1128 child_fetch_inferior_registers (int r
)
1130 current_thread
= thread_rec (inferior_pid
, TRUE
);
1131 do_child_fetch_inferior_registers (r
);
1135 do_child_store_inferior_registers (int r
)
1138 read_register_gen (r
, ((char *) ¤t_thread
->context
) + mappings
[r
]);
1141 for (r
= 0; r
< NUM_REGS
; r
++)
1142 do_child_store_inferior_registers (r
);
1146 /* Store a new register value into the current thread context */
1148 child_store_inferior_registers (int r
)
1150 current_thread
= thread_rec (inferior_pid
, TRUE
);
1151 do_child_store_inferior_registers (r
);
1154 /* Wait for child to do something. Return pid of child, or -1 in case
1155 of error; store status through argument pointer OURSTATUS. */
1158 handle_load_dll (PTR dummy
)
1160 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
1161 char dll_buf
[MAX_PATH
+ 1];
1162 char *p
, *bufp
, *imgp
, *dll_name
, *dll_basename
;
1165 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
1166 if (!event
->lpImageName
)
1170 for (bufp
= dll_buf
, imgp
= event
->lpImageName
;
1171 bufp
< dll_buf
+ sizeof (dll_buf
);
1172 bufp
+= 16, imgp
+= 16)
1174 gdb_wince_len nbytes
= 0;
1175 (void) read_process_memory (current_process_handle
,
1176 imgp
, bufp
, 16, &nbytes
);
1178 if (!nbytes
&& bufp
== dll_buf
)
1179 return 1; /* couldn't read it */
1180 for (p
= bufp
; p
< bufp
+ nbytes
; p
++)
1185 if (event
->fUnicode
)
1196 dll_buf
[len
] = '\0';
1198 dll_name
= alloca (len
);
1203 if (!event
->fUnicode
)
1204 memcpy (dll_name
, dll_buf
, len
);
1206 WideCharToMultiByte (CP_ACP
, 0, (LPCWSTR
) dll_buf
, len
,
1207 dll_name
, len
, 0, 0);
1209 while ((p
= strchr (dll_name
, '\\')))
1212 /* FIXME!! It would be nice to define one symbol which pointed to the
1213 front of the dll if we can't find any symbols. */
1215 if (!(dll_basename
= strrchr (dll_name
, '/')))
1216 dll_basename
= dll_name
;
1220 /* The symbols in a dll are offset by 0x1000, which is the
1221 the offset from 0 of the first byte in an image - because
1222 of the file header and the section alignment.
1224 FIXME: Is this the real reason that we need the 0x1000 ? */
1226 printf_unfiltered ("%x:%s", event
->lpBaseOfDll
, dll_name
);
1227 printf_unfiltered ("\n");
1232 /* Handle DEBUG_STRING output from child process. */
1234 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
1239 gdb_wince_len nbytes_read
;
1240 gdb_wince_len nbytes
= current_event
.u
.DebugString
.nDebugStringLength
;
1245 memset (p
, 0, sizeof (p
));
1246 if (!read_process_memory (current_process_handle
,
1247 current_event
.u
.DebugString
.lpDebugStringData
,
1248 &p
, nbytes
, &nbytes_read
)
1252 memset (s
, 0, sizeof (s
));
1253 WideCharToMultiByte (CP_ACP
, 0, (LPCWSTR
) p
, (int) nbytes_read
, s
,
1254 sizeof (s
) - 1, NULL
, NULL
);
1255 q
= strchr (s
, '\n');
1268 /* Handle target exceptions. */
1270 handle_exception (struct target_waitstatus
*ourstatus
)
1273 if (current_event
.u
.Exception
.dwFirstChance
)
1277 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1279 switch (current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
)
1281 case EXCEPTION_ACCESS_VIOLATION
:
1282 DEBUG_EXCEPT (("gdb: Target exception ACCESS_VIOLATION at 0x%08x\n",
1283 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1284 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1286 case STATUS_STACK_OVERFLOW
:
1287 DEBUG_EXCEPT (("gdb: Target exception STACK_OVERFLOW at 0x%08x\n",
1288 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1289 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1291 case EXCEPTION_BREAKPOINT
:
1292 DEBUG_EXCEPT (("gdb: Target exception BREAKPOINT at 0x%08x\n",
1293 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1294 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1297 DEBUG_EXCEPT (("gdb: Target exception CONTROL_C at 0x%08x\n",
1298 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1299 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1300 /* User typed CTRL-C. Continue with this status */
1301 last_sig
= SIGINT
; /* FIXME - should check pass state */
1303 case EXCEPTION_SINGLE_STEP
:
1304 DEBUG_EXCEPT (("gdb: Target exception SINGLE_STEP at 0x%08x\n",
1305 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1306 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1308 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1309 DEBUG_EXCEPT (("gdb: Target exception SINGLE_ILL at 0x%08x\n",
1310 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1311 ourstatus
->value
.sig
= check_for_step (¤t_event
, TARGET_SIGNAL_ILL
);
1314 /* This may be a structured exception handling exception. In
1315 that case, we want to let the program try to handle it, and
1316 only break if we see the exception a second time. */
1318 printf_unfiltered ("gdb: unknown target exception 0x%08x at 0x%08x\n",
1319 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1320 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
);
1321 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
1328 /* Resume all artificially suspended threads if we are continuing
1331 child_continue (DWORD continue_status
, int id
)
1337 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=%d, DBG_CONTINUE);\n",
1338 (unsigned) current_event
.dwProcessId
, (unsigned) current_event
.dwThreadId
));
1339 res
= continue_debug_event (current_event
.dwProcessId
,
1340 current_event
.dwThreadId
,
1343 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1344 if (((id
== -1) || (id
== th
->id
)) && th
->suspend_count
)
1346 for (i
= 0; i
< th
->suspend_count
; i
++)
1347 (void) resume_thread (th
->h
);
1348 th
->suspend_count
= 0;
1354 /* Get the next event from the child. Return 1 if the event requires
1355 handling by WFI (or whatever).
1358 get_child_debug_event (int pid
, struct target_waitstatus
*ourstatus
,
1359 DWORD target_event_code
, int *retval
)
1363 DWORD continue_status
, event_code
;
1364 thread_info
*th
= NULL
;
1365 static thread_info dummy_thread_info
;
1367 if (!(debug_event
= wait_for_debug_event (¤t_event
, 1000)))
1374 continue_status
= DBG_CONTINUE
;
1377 event_code
= current_event
.dwDebugEventCode
;
1378 breakout
= event_code
== target_event_code
;
1382 case CREATE_THREAD_DEBUG_EVENT
:
1383 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1384 (unsigned) current_event
.dwProcessId
,
1385 (unsigned) current_event
.dwThreadId
,
1386 "CREATE_THREAD_DEBUG_EVENT"));
1387 /* Record the existence of this thread */
1388 th
= child_add_thread (current_event
.dwThreadId
,
1389 current_event
.u
.CreateThread
.hThread
);
1391 printf_unfiltered ("[New %s]\n",
1392 target_pid_to_str (current_event
.dwThreadId
));
1395 case EXIT_THREAD_DEBUG_EVENT
:
1396 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1397 (unsigned) current_event
.dwProcessId
,
1398 (unsigned) current_event
.dwThreadId
,
1399 "EXIT_THREAD_DEBUG_EVENT"));
1400 child_delete_thread (current_event
.dwThreadId
);
1401 th
= &dummy_thread_info
;
1404 case CREATE_PROCESS_DEBUG_EVENT
:
1405 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1406 (unsigned) current_event
.dwProcessId
,
1407 (unsigned) current_event
.dwThreadId
,
1408 "CREATE_PROCESS_DEBUG_EVENT"));
1409 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1411 main_thread_id
= inferior_pid
= current_event
.dwThreadId
;
1412 /* Add the main thread */
1413 th
= child_add_thread (inferior_pid
,
1414 current_event
.u
.CreateProcessInfo
.hThread
);
1417 case EXIT_PROCESS_DEBUG_EVENT
:
1418 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1419 (unsigned) current_event
.dwProcessId
,
1420 (unsigned) current_event
.dwThreadId
,
1421 "EXIT_PROCESS_DEBUG_EVENT"));
1422 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1423 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1424 close_handle (current_process_handle
);
1425 *retval
= current_event
.dwProcessId
;
1429 case LOAD_DLL_DEBUG_EVENT
:
1430 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1431 (unsigned) current_event
.dwProcessId
,
1432 (unsigned) current_event
.dwThreadId
,
1433 "LOAD_DLL_DEBUG_EVENT"));
1434 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1435 registers_changed (); /* mark all regs invalid */
1438 case UNLOAD_DLL_DEBUG_EVENT
:
1439 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1440 (unsigned) current_event
.dwProcessId
,
1441 (unsigned) current_event
.dwThreadId
,
1442 "UNLOAD_DLL_DEBUG_EVENT"));
1443 break; /* FIXME: don't know what to do here */
1445 case EXCEPTION_DEBUG_EVENT
:
1446 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1447 (unsigned) current_event
.dwProcessId
,
1448 (unsigned) current_event
.dwThreadId
,
1449 "EXCEPTION_DEBUG_EVENT"));
1450 if (handle_exception (ourstatus
))
1451 *retval
= current_event
.dwThreadId
;
1454 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1459 case OUTPUT_DEBUG_STRING_EVENT
: /* message from the kernel */
1460 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1461 (unsigned) current_event
.dwProcessId
,
1462 (unsigned) current_event
.dwThreadId
,
1463 "OUTPUT_DEBUG_STRING_EVENT"));
1464 handle_output_debug_string ( ourstatus
);
1467 printf_unfiltered ("gdb: kernel event for pid=%d tid=%d\n",
1468 current_event
.dwProcessId
,
1469 current_event
.dwThreadId
);
1470 printf_unfiltered (" unknown event code %d\n",
1471 current_event
.dwDebugEventCode
);
1476 this_thread
= current_thread
= th
?: thread_rec (current_event
.dwThreadId
, TRUE
);
1478 CHECK (child_continue (continue_status
, -1));
1484 /* Wait for interesting events to occur in the target process. */
1486 child_wait (int pid
, struct target_waitstatus
*ourstatus
)
1491 /* We loop when we get a non-standard exception rather than return
1492 with a SPURIOUS because resume can try and step or modify things,
1493 which needs a current_thread->h. But some of these exceptions mark
1494 the birth or death of threads, which mean that the current thread
1495 isn't necessarily what you think it is. */
1498 if (get_child_debug_event (pid
, ourstatus
, EXCEPTION_DEBUG_EVENT
, &retval
))
1504 if (ui_loop_hook
!= NULL
)
1505 detach
= ui_loop_hook (0);
1508 child_kill_inferior ();
1512 /* Print status information about what we're accessing. */
1515 child_files_info (struct target_ops
*ignore
)
1517 printf_unfiltered ("\tUsing the running image of child %s.\n",
1518 target_pid_to_str (inferior_pid
));
1523 child_open (char *arg
, int from_tty
)
1525 error ("Use the \"run\" command to start a child process.");
1528 #define FACTOR (0x19db1ded53ea710LL)
1529 #define NSPERSEC 10000000
1531 /* Convert a Win32 time to "UNIX" format. */
1533 to_time_t (FILETIME
* ptr
)
1535 /* A file time is the number of 100ns since jan 1 1601
1536 stuffed into two long words.
1537 A time_t is the number of seconds since jan 1 1970. */
1540 long long x
= ((long long) ptr
->dwHighDateTime
<< 32) + ((unsigned) ptr
->dwLowDateTime
);
1541 x
-= FACTOR
; /* number of 100ns between 1601 and 1970 */
1542 rem
= x
% ((long long) NSPERSEC
);
1543 rem
+= (NSPERSEC
/ 2);
1544 x
/= (long long) NSPERSEC
; /* number of 100ns in a second */
1545 x
+= (long long) (rem
/ NSPERSEC
);
1549 /* Upload a file to the remote device depending on the user's
1550 'set remoteupload' specification. */
1552 upload_to_device (const char *to
, const char *from
)
1555 const char *dir
= remote_directory
?: "\\gdb";
1557 static char *remotefile
= NULL
;
1561 const char *in_to
= to
;
1562 FILETIME crtime
, actime
, wrtime
;
1567 /* Look for a path separator and only use trailing part. */
1568 while ((p
= strpbrk (to
, "/\\")) != NULL
)
1572 error ("no filename found to upload - %s.", in_to
);
1574 len
= strlen (dir
) + strlen (to
) + 2;
1575 remotefile
= (char *) realloc (remotefile
, len
);
1576 strcpy (remotefile
, dir
);
1577 strcat (remotefile
, "\\");
1578 strcat (remotefile
, to
);
1580 if (upload_when
== UPLOAD_NEVER
)
1581 return remotefile
; /* Don't bother uploading. */
1583 /* Open the source. */
1584 if ((fd
= openp (getenv ("PATH"), TRUE
, (char *) from
, O_RDONLY
, 0, NULL
)) < 0)
1585 error ("couldn't open %s", from
);
1587 /* Get the time for later comparison. */
1588 if (fstat (fd
, &st
))
1589 st
.st_mtime
= (time_t) - 1;
1591 /* Always attempt to create the directory on the remote system. */
1592 wstr
= towide (dir
, NULL
);
1593 (void) CeCreateDirectory (wstr
, NULL
);
1595 /* Attempt to open the remote file, creating it if it doesn't exist. */
1596 wstr
= towide (remotefile
, NULL
);
1597 h
= CeCreateFile (wstr
, GENERIC_READ
| GENERIC_WRITE
, 0, NULL
,
1598 OPEN_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
1600 /* Some kind of problem? */
1601 err
= CeGetLastError ();
1602 if (h
== NULL
|| h
== INVALID_HANDLE_VALUE
)
1603 error ("error opening file \"%s\". Windows error %d.",
1606 CeGetFileTime (h
, &crtime
, &actime
, &wrtime
);
1607 utime
= to_time_t (&wrtime
);
1609 if (utime
< st
.st_mtime
)
1612 strcpy (buf
, ctime(&utime
));
1613 printf ("%s < %s\n", buf
, ctime(&st
.st_mtime
));
1616 /* See if we need to upload the file. */
1617 if (upload_when
== UPLOAD_ALWAYS
||
1618 err
!= ERROR_ALREADY_EXISTS
||
1619 !CeGetFileTime (h
, &crtime
, &actime
, &wrtime
) ||
1620 to_time_t (&wrtime
) < st
.st_mtime
)
1626 /* Upload the file. */
1627 while ((n
= read (fd
, buf
, sizeof (buf
))) > 0)
1628 if (!CeWriteFile (h
, buf
, (DWORD
) n
, &nbytes
, NULL
))
1629 error ("error writing to remote device - %d.",
1634 if (!CeCloseHandle (h
))
1635 error ("error closing remote file - %d.", CeGetLastError ());
1640 /* Initialize the connection to the remote device. */
1642 wince_initialize (void)
1647 struct sockaddr_in sin
;
1648 char *stub_file_name
;
1650 PROCESS_INFORMATION pi
;
1652 if (!connection_initialized
)
1653 switch (CeRapiInit ())
1656 connection_initialized
= 1;
1660 error ("Can't initialize connection to remote device.\n");
1664 /* Upload the stub to the handheld device. */
1665 stub_file_name
= upload_to_device ("wince-stub.exe", WINCE_STUB
);
1666 strcpy (args
, stub_file_name
);
1668 if (remote_add_host
)
1671 hostname
= strchr (args
, '\0');
1672 if (gethostname (hostname
, sizeof (args
) - strlen (args
)))
1673 error ("couldn't get hostname of this system.");
1677 if ((s0
= socket (AF_INET
, SOCK_STREAM
, 0)) < 0)
1678 stub_error ("Couldn't connect to host system.");
1680 /* Allow rapid reuse of the port. */
1682 (void) setsockopt (s0
, SOL_SOCKET
, SO_REUSEADDR
, (char *) &tmp
, sizeof (tmp
));
1685 /* Set up the information for connecting to the host gdb process. */
1686 memset (&sin
, 0, sizeof (sin
));
1687 sin
.sin_family
= AF_INET
;
1688 sin
.sin_port
= htons (7000); /* FIXME: This should be configurable */
1690 if (bind (s0
, (struct sockaddr
*) &sin
, sizeof (sin
)))
1691 error ("couldn't bind socket");
1694 error ("Couldn't open socket for listening.\n");
1696 /* Start up the stub on the remote device. */
1697 if (!CeCreateProcess (towide (stub_file_name
, NULL
), towide (args
, NULL
),
1698 NULL
, NULL
, 0, 0, NULL
, NULL
, NULL
, &pi
))
1699 error ("Unable to start remote stub '%s'. Windows CE error %d.",
1700 stub_file_name
, CeGetLastError ());
1702 /* Wait for a connection */
1704 if ((s
= accept (s0
, NULL
, NULL
)) < 0)
1705 error ("couldn't set up server for connection.");
1710 /* Start an inferior win32 child process and sets inferior_pid to its pid.
1711 EXEC_FILE is the file to run.
1712 ALLARGS is a string containing the arguments to the program.
1713 ENV is the environment vector to pass. Errors reported with error(). */
1715 child_create_inferior (char *exec_file
, char *args
, char **env
)
1717 PROCESS_INFORMATION pi
;
1718 struct target_waitstatus dummy
;
1720 DWORD flags
, event_code
;
1721 char *exec_and_args
;
1724 error ("No executable specified, use `target exec'.\n");
1726 flags
= DEBUG_PROCESS
;
1728 wince_initialize (); /* Make sure we've got a connection. */
1730 exec_file
= upload_to_device (exec_file
, exec_file
);
1732 while (*args
== ' ')
1735 /* Allocate space for "command<sp>args" */
1738 exec_and_args
= alloca (strlen (exec_file
) + 1);
1739 strcpy (exec_and_args
, exec_file
);
1743 exec_and_args
= alloca (strlen (exec_file
+ strlen (args
) + 2));
1744 sprintf (exec_and_args
, "%s %s", exec_file
, args
);
1747 memset (&pi
, 0, sizeof (pi
));
1748 /* Execute the process */
1749 if (!create_process (exec_file
, exec_and_args
, flags
, &pi
))
1750 error ("Error creating process %s, (error %d)\n", exec_file
, GetLastError ());
1752 exception_count
= 0;
1755 current_process_handle
= pi
.hProcess
;
1756 current_event
.dwProcessId
= pi
.dwProcessId
;
1757 memset (¤t_event
, 0, sizeof (current_event
));
1758 inferior_pid
= current_event
.dwThreadId
= pi
.dwThreadId
;
1759 push_target (&child_ops
);
1760 child_init_thread_list ();
1761 child_add_thread (pi
.dwThreadId
, pi
.hThread
);
1762 init_wait_for_inferior ();
1763 clear_proceed_status ();
1764 target_terminal_init ();
1765 target_terminal_inferior ();
1767 /* Run until process and threads are loaded */
1768 while (!get_child_debug_event (inferior_pid
, &dummy
,
1769 CREATE_PROCESS_DEBUG_EVENT
, &ret
))
1772 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_0
, 0);
1775 /* Chile has gone bye-bye. */
1777 child_mourn_inferior (void)
1779 (void) child_continue (DBG_CONTINUE
, -1);
1780 unpush_target (&child_ops
);
1783 connection_initialized
= 0;
1784 generic_mourn_inferior ();
1787 /* Move memory from child to/from gdb. */
1789 child_xfer_memory (CORE_ADDR memaddr
, char *our
, int len
,
1790 int write
, struct target_ops
*target
)
1796 res
= remote_write_bytes (memaddr
, our
, len
);
1798 res
= remote_read_bytes (memaddr
, our
, len
);
1803 /* Terminate the process and wait for child to tell us it has completed. */
1805 child_kill_inferior (void)
1807 CHECK (terminate_process (current_process_handle
));
1811 if (!child_continue (DBG_CONTINUE
, -1))
1813 if (!wait_for_debug_event (¤t_event
, INFINITE
))
1815 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
1819 CHECK (close_handle (current_process_handle
));
1820 close_handle (current_thread
->h
);
1821 target_mourn_inferior (); /* or just child_mourn_inferior? */
1824 /* Resume the child after an exception. */
1826 child_resume (int pid
, int step
, enum target_signal sig
)
1829 DWORD continue_status
= last_sig
> 0 && last_sig
< NSIG
?
1830 DBG_EXCEPTION_NOT_HANDLED
: DBG_CONTINUE
;
1832 DEBUG_EXEC (("gdb: child_resume (pid=%d, step=%d, sig=%d);\n",
1835 /* Get context for currently selected thread */
1836 th
= thread_rec (current_event
.dwThreadId
, FALSE
);
1838 if (th
->context
.ContextFlags
)
1840 CHECK (set_thread_context (th
->h
, &th
->context
));
1841 th
->context
.ContextFlags
= 0;
1844 /* Allow continuing with the same signal that interrupted us.
1845 Otherwise complain. */
1846 if (sig
&& sig
!= last_sig
)
1847 fprintf_unfiltered (gdb_stderr
, "Can't send signals to the child. signal %d\n", sig
);
1850 child_continue (continue_status
, pid
);
1854 child_prepare_to_store (void)
1856 /* Do nothing, since we can store individual regs */
1860 child_can_run (void)
1868 DEBUG_EVENTS (("gdb: child_close, inferior_pid=%d\n", inferior_pid
));
1871 /* Explicitly upload file to remotedir */
1874 child_load (char *file
, int from_tty
)
1876 upload_to_device (file
, file
);
1879 struct target_ops child_ops
;
1882 init_child_ops (void)
1884 memset (&child_ops
, 0, sizeof (child_ops
));
1885 child_ops
.to_shortname
= (char *) "child";
1886 child_ops
.to_longname
= (char *) "Windows CE process";
1887 child_ops
.to_doc
= (char *) "Windows CE process (started by the \"run\" command).";
1888 child_ops
.to_open
= child_open
;
1889 child_ops
.to_close
= child_close
;
1890 child_ops
.to_resume
= child_resume
;
1891 child_ops
.to_wait
= child_wait
;
1892 child_ops
.to_fetch_registers
= child_fetch_inferior_registers
;
1893 child_ops
.to_store_registers
= child_store_inferior_registers
;
1894 child_ops
.to_prepare_to_store
= child_prepare_to_store
;
1895 child_ops
.to_xfer_memory
= child_xfer_memory
;
1896 child_ops
.to_files_info
= child_files_info
;
1897 child_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
1898 child_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
1899 child_ops
.to_terminal_init
= terminal_init_inferior
;
1900 child_ops
.to_terminal_inferior
= terminal_inferior
;
1901 child_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
1902 child_ops
.to_terminal_ours
= terminal_ours
;
1903 child_ops
.to_terminal_info
= child_terminal_info
;
1904 child_ops
.to_kill
= child_kill_inferior
;
1905 child_ops
.to_load
= child_load
;
1906 child_ops
.to_create_inferior
= child_create_inferior
;
1907 child_ops
.to_mourn_inferior
= child_mourn_inferior
;
1908 child_ops
.to_can_run
= child_can_run
;
1909 child_ops
.to_thread_alive
= win32_child_thread_alive
;
1910 child_ops
.to_stratum
= process_stratum
;
1911 child_ops
.to_has_all_memory
= 1;
1912 child_ops
.to_has_memory
= 1;
1913 child_ops
.to_has_stack
= 1;
1914 child_ops
.to_has_registers
= 1;
1915 child_ops
.to_has_execution
= 1;
1916 child_ops
.to_sections
= 0;
1917 child_ops
.to_sections_end
= 0;
1918 child_ops
.to_magic
= OPS_MAGIC
;
1922 /* Handle 'set remoteupload' parameter. */
1924 #define replace_upload(what) \
1925 upload_when = what; \
1926 remote_upload = realloc (remote_upload, strlen (upload_options[upload_when].name) + 1); \
1927 strcpy (remote_upload, upload_options[upload_when].name);
1930 set_upload_type (char *ignore
, int from_tty
)
1935 if (!remote_upload
|| !remote_upload
[0])
1937 replace_upload (UPLOAD_NEWER
);
1939 printf_unfiltered ("Upload upload_options are: always, newer, never.\n");
1943 len
= strlen (remote_upload
);
1944 for (i
= 0; i
< (sizeof (upload_options
) / sizeof (upload_options
[0])); i
++)
1945 if (len
>= upload_options
[i
].abbrev
&&
1946 strncasecmp (remote_upload
, upload_options
[i
].name
, len
) == 0)
1952 bad_option
= remote_upload
;
1953 replace_upload (UPLOAD_NEWER
);
1954 error ("Unknown upload type: %s.", bad_option
);
1958 _initialize_inftarg (void)
1960 struct cmd_list_element
*set
;
1964 (add_set_cmd ((char *) "remotedirectory", no_class
,
1965 var_string_noescape
, (char *) &remote_directory
,
1966 (char *) "Set directory for remote upload.\n",
1969 remote_directory
= xstrdup (remote_directory
);
1971 set
= add_set_cmd ((char *) "remoteupload", no_class
,
1972 var_string_noescape
, (char *) &remote_upload
,
1973 (char *) "Set how to upload executables to remote device.\n",
1975 add_show_from_set (set
, &showlist
);
1976 set
->function
.cfunc
= set_upload_type
;
1977 set_upload_type (NULL
, 0);
1978 set_dcache_state (1);
1981 (add_set_cmd ((char *) "debugexec", class_support
, var_boolean
,
1982 (char *) &debug_exec
,
1983 (char *) "Set whether to display execution in child process.",
1988 (add_set_cmd ((char *) "remoteaddhost", class_support
, var_boolean
,
1989 (char *) &remote_add_host
,
1990 (char *) "Set whether to add this host to remote stub arguments for\n
1991 debugging over a network.", &setlist
),
1995 (add_set_cmd ((char *) "debugevents", class_support
, var_boolean
,
1996 (char *) &debug_events
,
1997 (char *) "Set whether to display kernel events in child process.",
2002 (add_set_cmd ((char *) "debugmemory", class_support
, var_boolean
,
2003 (char *) &debug_memory
,
2004 (char *) "Set whether to display memory accesses in child process.",
2009 (add_set_cmd ((char *) "debugexceptions", class_support
, var_boolean
,
2010 (char *) &debug_exceptions
,
2011 (char *) "Set whether to display kernel exceptions in child process.",
2015 add_target (&child_ops
);
2018 /* Determine if the thread referenced by "pid" is alive
2019 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
2020 it means that the pid has died. Otherwise it is assumed to be alive. */
2022 win32_child_thread_alive (int pid
)
2024 return thread_alive (thread_rec (pid
, FALSE
)->h
);
2027 /* Convert pid to printable format. */
2029 cygwin_pid_to_str (int pid
)
2031 static char buf
[80];
2032 if (pid
== current_event
.dwProcessId
)
2033 sprintf (buf
, "process %d", pid
);
2035 sprintf (buf
, "thread %d.0x%x", (unsigned) current_event
.dwProcessId
, pid
);