1 /* Target-vector operations for controlling Windows CE child processes, for GDB.
3 Copyright 1999, 2000, 2001, 2004 Free Software Foundation, Inc.
4 Contributed by Cygnus Solutions, A Red Hat Company.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA.
24 /* by Christopher Faylor (cgf@cygnus.com) */
26 /* We assume we're being built with and will be used for cygwin. */
30 #define SH4 /* Just to get all of the CONTEXT defines. */
34 #include "frame.h" /* required by inferior.h */
37 #include "exceptions.h"
41 #include <sys/types.h>
48 #include <cygwin/in.h>
49 #include <cygwin/socket.h>
54 #include "gdb_string.h"
55 #include "gdbthread.h"
57 #include <sys/param.h>
58 #include "wince-stub.h"
62 #include "mips-tdep.h"
65 /* If we're not using the old Cygwin header file set, define the
66 following which never should have been in the generic Win32 API
67 headers in the first place since they were our own invention... */
68 #ifndef _GNU_H_WINDOWS_H
69 #define FLAG_TRACE_BIT 0x100
70 #ifdef CONTEXT_FLOATING_POINT
71 #define CONTEXT_DEBUGGER0 (CONTEXT_FULL | CONTEXT_FLOATING_POINT)
73 #define CONTEXT_DEBUGGER0 (CONTEXT_FULL)
78 #define CONTEXT_DEBUGGER ((CONTEXT_DEBUGGER0 & ~(CONTEXT_SH4 | CONTEXT_FLOATING_POINT)) | CONTEXT_SH3)
80 #define CONTEXT_DEBUGGER CONTEXT_DEBUGGER0
82 /* The string sent by cygwin when it processes a signal.
83 FIXME: This should be in a cygwin include file. */
84 #define CYGWIN_SIGNAL_STRING "cygwin: signal"
86 #define CHECK(x) check (x, __FILE__,__LINE__)
87 #define DEBUG_EXEC(x) if (debug_exec) printf x
88 #define DEBUG_EVENTS(x) if (debug_events) printf x
89 #define DEBUG_MEM(x) if (debug_memory) printf x
90 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf x
92 static int connection_initialized
= 0; /* True if we've initialized a RAPI session. */
94 /* The directory where the stub and executable files are uploaded. */
95 static const char *remote_directory
= "\\gdb";
97 /* The types automatic upload available. */
104 upload_when
= UPLOAD_NEWER
;
106 /* Valid options for 'set remoteupload'. Note that options
107 must track upload_when enum. */
128 static char *remote_upload
= NULL
; /* Set by set remoteupload */
129 static int remote_add_host
= 0;
131 static int win32_child_thread_alive (ptid_t
);
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, xrealloc will act as
605 a malloc (under cygwin, at least).
607 outs
[n
] = (LPWSTR
) xrealloc (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 (enum target_signal ignore
,
812 int insert_breakpoints_p
)
815 thread_info
*th
= current_thread
; /* Info on currently selected thread */
816 CORE_ADDR
mips_next_pc (CORE_ADDR pc
);
818 if (!insert_breakpoints_p
)
825 pc
= read_register (PC_REGNUM
);
826 th
->step_pc
= mips_next_pc (pc
);
828 memory_insert_breakpoint (th
->step_pc
, (void *) &th
->step_prev
);
832 /* Renesas SH architecture instruction encoding masks */
834 #define COND_BR_MASK 0xff00
835 #define UCOND_DBR_MASK 0xe000
836 #define UCOND_RBR_MASK 0xf0df
837 #define TRAPA_MASK 0xff00
839 #define COND_DISP 0x00ff
840 #define UCOND_DISP 0x0fff
841 #define UCOND_REG 0x0f00
843 /* Renesas SH instruction opcodes */
845 #define BF_INSTR 0x8b00
846 #define BT_INSTR 0x8900
847 #define BRA_INSTR 0xa000
848 #define BSR_INSTR 0xb000
849 #define JMP_INSTR 0x402b
850 #define JSR_INSTR 0x400b
851 #define RTS_INSTR 0x000b
852 #define RTE_INSTR 0x002b
853 #define TRAPA_INSTR 0xc300
854 #define SSTEP_INSTR 0xc3ff
857 #define T_BIT_MASK 0x0001
860 sh_get_next_pc (CONTEXT
*c
)
865 unsigned short opcode
;
867 instrMem
= (short *) c
->Fir
;
869 opcode
= read_memory_integer ((CORE_ADDR
) c
->Fir
, sizeof (opcode
));
871 if ((opcode
& COND_BR_MASK
) == BT_INSTR
)
873 if (c
->Psr
& T_BIT_MASK
)
875 displacement
= (opcode
& COND_DISP
) << 1;
876 if (displacement
& 0x80)
877 displacement
|= 0xffffff00;
879 * Remember PC points to second instr.
880 * after PC of branch ... so add 4
882 instrMem
= (short *) (c
->Fir
+ displacement
+ 4);
887 else if ((opcode
& COND_BR_MASK
) == BF_INSTR
)
889 if (c
->Psr
& T_BIT_MASK
)
893 displacement
= (opcode
& COND_DISP
) << 1;
894 if (displacement
& 0x80)
895 displacement
|= 0xffffff00;
897 * Remember PC points to second instr.
898 * after PC of branch ... so add 4
900 instrMem
= (short *) (c
->Fir
+ displacement
+ 4);
903 else if ((opcode
& UCOND_DBR_MASK
) == BRA_INSTR
)
905 displacement
= (opcode
& UCOND_DISP
) << 1;
906 if (displacement
& 0x0800)
907 displacement
|= 0xfffff000;
910 * Remember PC points to second instr.
911 * after PC of branch ... so add 4
913 instrMem
= (short *) (c
->Fir
+ displacement
+ 4);
915 else if ((opcode
& UCOND_RBR_MASK
) == JSR_INSTR
)
917 reg
= (char) ((opcode
& UCOND_REG
) >> 8);
919 instrMem
= (short *) *regptr (c
, reg
);
921 else if (opcode
== RTS_INSTR
)
922 instrMem
= (short *) c
->PR
;
923 else if (opcode
== RTE_INSTR
)
924 instrMem
= (short *) *regptr (c
, 15);
925 else if ((opcode
& TRAPA_MASK
) == TRAPA_INSTR
)
926 instrMem
= (short *) ((opcode
& ~TRAPA_MASK
) << 2);
930 return (CORE_ADDR
) instrMem
;
932 /* Single step (in a painstaking fashion) by inspecting the current
933 instruction and setting a breakpoint on the "next" instruction
934 which would be executed. This code hails from sh-stub.c.
937 undoSStep (thread_info
* th
)
941 memory_remove_breakpoint (th
->step_pc
, (void *) &th
->step_prev
);
947 /* Single step (in a painstaking fashion) by inspecting the current
948 instruction and setting a breakpoint on the "next" instruction
949 which would be executed. This code hails from sh-stub.c.
952 wince_software_single_step (enum target_signal ignore
,
953 int insert_breakpoints_p
)
955 thread_info
*th
= current_thread
; /* Info on currently selected thread */
957 if (!insert_breakpoints_p
)
964 th
->step_pc
= sh_get_next_pc (&th
->context
);
966 memory_insert_breakpoint (th
->step_pc
, (void *) &th
->step_prev
);
970 #undef check_for_step
972 static enum target_signal
973 check_for_step (DEBUG_EVENT
*ev
, enum target_signal x
)
975 thread_info
*th
= thread_rec (ev
->dwThreadId
, 1);
978 th
->step_pc
== (CORE_ADDR
) ev
->u
.Exception
.ExceptionRecord
.ExceptionAddress
)
979 return TARGET_SIGNAL_TRAP
;
984 /* Single step (in a painstaking fashion) by inspecting the current
985 instruction and setting a breakpoint on the "next" instruction
986 which would be executed. This code hails from sh-stub.c.
989 undoSStep (thread_info
* th
)
993 memory_remove_breakpoint (th
->step_pc
, (void *) &th
->step_prev
);
999 wince_software_single_step (enum target_signal ignore
,
1000 int insert_breakpoints_p
)
1003 thread_info
*th
= current_thread
; /* Info on currently selected thread */
1004 CORE_ADDR
mips_next_pc (CORE_ADDR pc
);
1006 if (!insert_breakpoints_p
)
1013 pc
= read_register (PC_REGNUM
);
1014 th
->step_pc
= arm_get_next_pc (pc
);
1016 memory_insert_breakpoint (th
->step_pc
, (void *) &th
->step_prev
);
1021 /* Find a thread record given a thread id.
1022 If get_context then also retrieve the context for this
1024 static thread_info
*
1025 thread_rec (DWORD id
, int get_context
)
1029 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1032 if (!th
->suspend_count
&& get_context
)
1034 if (get_context
> 0 && th
!= this_thread
)
1035 th
->suspend_count
= suspend_thread (th
->h
) + 1;
1036 else if (get_context
< 0)
1037 th
->suspend_count
= -1;
1039 th
->context
.ContextFlags
= CONTEXT_DEBUGGER
;
1040 get_thread_context (th
->h
, &th
->context
);
1048 /* Add a thread to the thread list */
1049 static thread_info
*
1050 child_add_thread (DWORD id
, HANDLE h
)
1054 if ((th
= thread_rec (id
, FALSE
)))
1057 th
= (thread_info
*) xmalloc (sizeof (*th
));
1058 memset (th
, 0, sizeof (*th
));
1061 th
->next
= thread_head
.next
;
1062 thread_head
.next
= th
;
1067 /* Clear out any old thread list and reintialize it to a
1070 child_init_thread_list (void)
1072 thread_info
*th
= &thread_head
;
1074 DEBUG_EVENTS (("gdb: child_init_thread_list\n"));
1075 init_thread_list ();
1076 while (th
->next
!= NULL
)
1078 thread_info
*here
= th
->next
;
1079 th
->next
= here
->next
;
1080 (void) close_handle (here
->h
);
1085 /* Delete a thread from the list of threads */
1087 child_delete_thread (DWORD id
)
1092 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (id
));
1095 for (th
= &thread_head
;
1096 th
->next
!= NULL
&& th
->next
->id
!= id
;
1100 if (th
->next
!= NULL
)
1102 thread_info
*here
= th
->next
;
1103 th
->next
= here
->next
;
1104 close_handle (here
->h
);
1110 check (BOOL ok
, const char *file
, int line
)
1113 printf_filtered ("error return %s:%d was %d\n", file
, line
, GetLastError ());
1117 do_child_fetch_inferior_registers (int r
)
1121 regcache_raw_supply (current_regcache
, r
,
1122 (char *) regptr (¤t_thread
->context
, r
));
1126 for (r
= 0; r
< NUM_REGS
; r
++)
1127 do_child_fetch_inferior_registers (r
);
1132 child_fetch_inferior_registers (int r
)
1134 current_thread
= thread_rec (PIDGET (inferior_ptid
), TRUE
);
1135 do_child_fetch_inferior_registers (r
);
1139 do_child_store_inferior_registers (int r
)
1142 deprecated_read_register_gen (r
, ((char *) ¤t_thread
->context
) + mappings
[r
]);
1145 for (r
= 0; r
< NUM_REGS
; r
++)
1146 do_child_store_inferior_registers (r
);
1150 /* Store a new register value into the current thread context */
1152 child_store_inferior_registers (int r
)
1154 current_thread
= thread_rec (PIDGET (inferior_ptid
), TRUE
);
1155 do_child_store_inferior_registers (r
);
1158 /* Wait for child to do something. Return pid of child, or -1 in case
1159 of error; store status through argument pointer OURSTATUS. */
1162 handle_load_dll (void *dummy
)
1164 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
1165 char dll_buf
[MAX_PATH
+ 1];
1166 char *p
, *bufp
, *imgp
, *dll_name
, *dll_basename
;
1169 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
1170 if (!event
->lpImageName
)
1174 for (bufp
= dll_buf
, imgp
= event
->lpImageName
;
1175 bufp
< dll_buf
+ sizeof (dll_buf
);
1176 bufp
+= 16, imgp
+= 16)
1178 gdb_wince_len nbytes
= 0;
1179 (void) read_process_memory (current_process_handle
,
1180 imgp
, bufp
, 16, &nbytes
);
1182 if (!nbytes
&& bufp
== dll_buf
)
1183 return 1; /* couldn't read it */
1184 for (p
= bufp
; p
< bufp
+ nbytes
; p
++)
1189 if (event
->fUnicode
)
1200 dll_buf
[len
] = '\0';
1202 dll_name
= alloca (len
);
1207 if (!event
->fUnicode
)
1208 memcpy (dll_name
, dll_buf
, len
);
1210 WideCharToMultiByte (CP_ACP
, 0, (LPCWSTR
) dll_buf
, len
,
1211 dll_name
, len
, 0, 0);
1213 while ((p
= strchr (dll_name
, '\\')))
1216 /* FIXME!! It would be nice to define one symbol which pointed to the
1217 front of the dll if we can't find any symbols. */
1219 if (!(dll_basename
= strrchr (dll_name
, '/')))
1220 dll_basename
= dll_name
;
1224 /* The symbols in a dll are offset by 0x1000, which is the
1225 the offset from 0 of the first byte in an image - because
1226 of the file header and the section alignment.
1228 FIXME: Is this the real reason that we need the 0x1000 ? */
1230 printf_unfiltered ("%x:%s", event
->lpBaseOfDll
, dll_name
);
1231 printf_unfiltered ("\n");
1236 /* Handle DEBUG_STRING output from child process. */
1238 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
1243 gdb_wince_len nbytes_read
;
1244 gdb_wince_len nbytes
= current_event
.u
.DebugString
.nDebugStringLength
;
1249 memset (p
, 0, sizeof (p
));
1250 if (!read_process_memory (current_process_handle
,
1251 current_event
.u
.DebugString
.lpDebugStringData
,
1252 &p
, nbytes
, &nbytes_read
)
1256 memset (s
, 0, sizeof (s
));
1257 WideCharToMultiByte (CP_ACP
, 0, (LPCWSTR
) p
, (int) nbytes_read
, s
,
1258 sizeof (s
) - 1, NULL
, NULL
);
1259 q
= strchr (s
, '\n');
1272 /* Handle target exceptions. */
1274 handle_exception (struct target_waitstatus
*ourstatus
)
1277 if (current_event
.u
.Exception
.dwFirstChance
)
1281 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1283 switch (current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
)
1285 case EXCEPTION_ACCESS_VIOLATION
:
1286 DEBUG_EXCEPT (("gdb: Target exception ACCESS_VIOLATION at 0x%08x\n",
1287 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1288 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1290 case STATUS_STACK_OVERFLOW
:
1291 DEBUG_EXCEPT (("gdb: Target exception STACK_OVERFLOW at 0x%08x\n",
1292 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1293 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1295 case EXCEPTION_BREAKPOINT
:
1296 DEBUG_EXCEPT (("gdb: Target exception BREAKPOINT at 0x%08x\n",
1297 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1298 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1301 DEBUG_EXCEPT (("gdb: Target exception CONTROL_C at 0x%08x\n",
1302 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1303 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1304 /* User typed CTRL-C. Continue with this status */
1305 last_sig
= SIGINT
; /* FIXME - should check pass state */
1307 case EXCEPTION_SINGLE_STEP
:
1308 DEBUG_EXCEPT (("gdb: Target exception SINGLE_STEP at 0x%08x\n",
1309 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1310 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1312 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1313 DEBUG_EXCEPT (("gdb: Target exception SINGLE_ILL at 0x%08x\n",
1314 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1315 ourstatus
->value
.sig
= check_for_step (¤t_event
, TARGET_SIGNAL_ILL
);
1318 /* This may be a structured exception handling exception. In
1319 that case, we want to let the program try to handle it, and
1320 only break if we see the exception a second time. */
1322 printf_unfiltered ("gdb: unknown target exception 0x%08x at 0x%08x\n",
1323 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1324 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
);
1325 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
1332 /* Resume all artificially suspended threads if we are continuing
1335 child_continue (DWORD continue_status
, int id
)
1341 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=%d, DBG_CONTINUE);\n",
1342 (unsigned) current_event
.dwProcessId
, (unsigned) current_event
.dwThreadId
));
1343 res
= continue_debug_event (current_event
.dwProcessId
,
1344 current_event
.dwThreadId
,
1347 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1348 if (((id
== -1) || (id
== th
->id
)) && th
->suspend_count
)
1350 for (i
= 0; i
< th
->suspend_count
; i
++)
1351 (void) resume_thread (th
->h
);
1352 th
->suspend_count
= 0;
1358 /* Get the next event from the child. Return 1 if the event requires
1359 handling by WFI (or whatever).
1362 get_child_debug_event (int pid
, struct target_waitstatus
*ourstatus
,
1363 DWORD target_event_code
, int *retval
)
1367 DWORD continue_status
, event_code
;
1368 thread_info
*th
= NULL
;
1369 static thread_info dummy_thread_info
;
1371 if (!(debug_event
= wait_for_debug_event (¤t_event
, 1000)))
1378 continue_status
= DBG_CONTINUE
;
1381 event_code
= current_event
.dwDebugEventCode
;
1382 breakout
= event_code
== target_event_code
;
1386 case CREATE_THREAD_DEBUG_EVENT
:
1387 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1388 (unsigned) current_event
.dwProcessId
,
1389 (unsigned) current_event
.dwThreadId
,
1390 "CREATE_THREAD_DEBUG_EVENT"));
1391 /* Record the existence of this thread */
1392 th
= child_add_thread (current_event
.dwThreadId
,
1393 current_event
.u
.CreateThread
.hThread
);
1395 printf_unfiltered ("[New %s]\n",
1396 target_pid_to_str (current_event
.dwThreadId
));
1399 case EXIT_THREAD_DEBUG_EVENT
:
1400 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1401 (unsigned) current_event
.dwProcessId
,
1402 (unsigned) current_event
.dwThreadId
,
1403 "EXIT_THREAD_DEBUG_EVENT"));
1404 child_delete_thread (current_event
.dwThreadId
);
1405 th
= &dummy_thread_info
;
1408 case CREATE_PROCESS_DEBUG_EVENT
:
1409 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1410 (unsigned) current_event
.dwProcessId
,
1411 (unsigned) current_event
.dwThreadId
,
1412 "CREATE_PROCESS_DEBUG_EVENT"));
1413 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1415 main_thread_id
= current_event
.dwThreadId
;
1416 inferior_ptid
= pid_to_ptid (main_thread_id
);
1417 /* Add the main thread */
1418 th
= child_add_thread (PIDGET (inferior_ptid
),
1419 current_event
.u
.CreateProcessInfo
.hThread
);
1422 case EXIT_PROCESS_DEBUG_EVENT
:
1423 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1424 (unsigned) current_event
.dwProcessId
,
1425 (unsigned) current_event
.dwThreadId
,
1426 "EXIT_PROCESS_DEBUG_EVENT"));
1427 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1428 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1429 close_handle (current_process_handle
);
1430 *retval
= current_event
.dwProcessId
;
1434 case LOAD_DLL_DEBUG_EVENT
:
1435 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1436 (unsigned) current_event
.dwProcessId
,
1437 (unsigned) current_event
.dwThreadId
,
1438 "LOAD_DLL_DEBUG_EVENT"));
1439 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1440 registers_changed (); /* mark all regs invalid */
1443 case UNLOAD_DLL_DEBUG_EVENT
:
1444 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1445 (unsigned) current_event
.dwProcessId
,
1446 (unsigned) current_event
.dwThreadId
,
1447 "UNLOAD_DLL_DEBUG_EVENT"));
1448 break; /* FIXME: don't know what to do here */
1450 case EXCEPTION_DEBUG_EVENT
:
1451 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1452 (unsigned) current_event
.dwProcessId
,
1453 (unsigned) current_event
.dwThreadId
,
1454 "EXCEPTION_DEBUG_EVENT"));
1455 if (handle_exception (ourstatus
))
1456 *retval
= current_event
.dwThreadId
;
1459 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1464 case OUTPUT_DEBUG_STRING_EVENT
: /* message from the kernel */
1465 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1466 (unsigned) current_event
.dwProcessId
,
1467 (unsigned) current_event
.dwThreadId
,
1468 "OUTPUT_DEBUG_STRING_EVENT"));
1469 handle_output_debug_string ( ourstatus
);
1472 printf_unfiltered ("gdb: kernel event for pid=%d tid=%d\n",
1473 current_event
.dwProcessId
,
1474 current_event
.dwThreadId
);
1475 printf_unfiltered (" unknown event code %d\n",
1476 current_event
.dwDebugEventCode
);
1481 this_thread
= current_thread
= th
?: thread_rec (current_event
.dwThreadId
, TRUE
);
1483 CHECK (child_continue (continue_status
, -1));
1489 /* Wait for interesting events to occur in the target process. */
1491 child_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
1495 int pid
= PIDGET (ptid
);
1497 /* We loop when we get a non-standard exception rather than return
1498 with a SPURIOUS because resume can try and step or modify things,
1499 which needs a current_thread->h. But some of these exceptions mark
1500 the birth or death of threads, which mean that the current thread
1501 isn't necessarily what you think it is. */
1504 if (get_child_debug_event (pid
, ourstatus
, EXCEPTION_DEBUG_EVENT
, &retval
))
1505 return pid_to_ptid (retval
);
1510 if (deprecated_ui_loop_hook
!= NULL
)
1511 detach
= deprecated_ui_loop_hook (0);
1514 child_kill_inferior ();
1518 /* Print status information about what we're accessing. */
1521 child_files_info (struct target_ops
*ignore
)
1523 printf_unfiltered ("\tUsing the running image of child %s.\n",
1524 target_pid_to_str (inferior_ptid
));
1528 child_open (char *arg
, int from_tty
)
1530 error ("Use the \"run\" command to start a child process.");
1533 #define FACTOR (0x19db1ded53ea710LL)
1534 #define NSPERSEC 10000000
1536 /* Convert a Win32 time to "UNIX" format. */
1538 to_time_t (FILETIME
* ptr
)
1540 /* A file time is the number of 100ns since jan 1 1601
1541 stuffed into two long words.
1542 A time_t is the number of seconds since jan 1 1970. */
1545 long long x
= ((long long) ptr
->dwHighDateTime
<< 32) + ((unsigned) ptr
->dwLowDateTime
);
1546 x
-= FACTOR
; /* number of 100ns between 1601 and 1970 */
1547 rem
= x
% ((long long) NSPERSEC
);
1548 rem
+= (NSPERSEC
/ 2);
1549 x
/= (long long) NSPERSEC
; /* number of 100ns in a second */
1550 x
+= (long long) (rem
/ NSPERSEC
);
1554 /* Upload a file to the remote device depending on the user's
1555 'set remoteupload' specification. */
1557 upload_to_device (const char *to
, const char *from
)
1560 const char *dir
= remote_directory
?: "\\gdb";
1562 static char *remotefile
= NULL
;
1566 const char *in_to
= to
;
1567 FILETIME crtime
, actime
, wrtime
;
1572 /* Look for a path separator and only use trailing part. */
1573 while ((p
= strpbrk (to
, "/\\")) != NULL
)
1577 error ("no filename found to upload - %s.", in_to
);
1579 len
= strlen (dir
) + strlen (to
) + 2;
1580 remotefile
= (char *) xrealloc (remotefile
, len
);
1581 strcpy (remotefile
, dir
);
1582 strcat (remotefile
, "\\");
1583 strcat (remotefile
, to
);
1585 if (upload_when
== UPLOAD_NEVER
)
1586 return remotefile
; /* Don't bother uploading. */
1588 /* Open the source. */
1589 if ((fd
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
, (char *) from
, O_RDONLY
,
1591 error ("couldn't open %s", from
);
1593 /* Get the time for later comparison. */
1594 if (fstat (fd
, &st
))
1595 st
.st_mtime
= (time_t) - 1;
1597 /* Always attempt to create the directory on the remote system. */
1598 wstr
= towide (dir
, NULL
);
1599 (void) CeCreateDirectory (wstr
, NULL
);
1601 /* Attempt to open the remote file, creating it if it doesn't exist. */
1602 wstr
= towide (remotefile
, NULL
);
1603 h
= CeCreateFile (wstr
, GENERIC_READ
| GENERIC_WRITE
, 0, NULL
,
1604 OPEN_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
1606 /* Some kind of problem? */
1607 err
= CeGetLastError ();
1608 if (h
== NULL
|| h
== INVALID_HANDLE_VALUE
)
1609 error ("error opening file \"%s\". Windows error %d.",
1612 CeGetFileTime (h
, &crtime
, &actime
, &wrtime
);
1613 utime
= to_time_t (&wrtime
);
1615 if (utime
< st
.st_mtime
)
1618 strcpy (buf
, ctime(&utime
));
1619 printf ("%s < %s\n", buf
, ctime(&st
.st_mtime
));
1622 /* See if we need to upload the file. */
1623 if (upload_when
== UPLOAD_ALWAYS
||
1624 err
!= ERROR_ALREADY_EXISTS
||
1625 !CeGetFileTime (h
, &crtime
, &actime
, &wrtime
) ||
1626 to_time_t (&wrtime
) < st
.st_mtime
)
1632 /* Upload the file. */
1633 while ((n
= read (fd
, buf
, sizeof (buf
))) > 0)
1634 if (!CeWriteFile (h
, buf
, (DWORD
) n
, &nbytes
, NULL
))
1635 error ("error writing to remote device - %d.",
1640 if (!CeCloseHandle (h
))
1641 error ("error closing remote file - %d.", CeGetLastError ());
1646 /* Initialize the connection to the remote device. */
1648 wince_initialize (void)
1653 struct sockaddr_in sin
;
1654 char *stub_file_name
;
1656 PROCESS_INFORMATION pi
;
1658 if (!connection_initialized
)
1659 switch (CeRapiInit ())
1662 connection_initialized
= 1;
1666 error ("Can't initialize connection to remote device.\n");
1670 /* Upload the stub to the handheld device. */
1671 stub_file_name
= upload_to_device ("wince-stub.exe", WINCE_STUB
);
1672 strcpy (args
, stub_file_name
);
1674 if (remote_add_host
)
1677 hostname
= strchr (args
, '\0');
1678 if (gethostname (hostname
, sizeof (args
) - strlen (args
)))
1679 error ("couldn't get hostname of this system.");
1683 if ((s0
= socket (AF_INET
, SOCK_STREAM
, 0)) < 0)
1684 stub_error ("Couldn't connect to host system.");
1686 /* Allow rapid reuse of the port. */
1688 (void) setsockopt (s0
, SOL_SOCKET
, SO_REUSEADDR
, (char *) &tmp
, sizeof (tmp
));
1691 /* Set up the information for connecting to the host gdb process. */
1692 memset (&sin
, 0, sizeof (sin
));
1693 sin
.sin_family
= AF_INET
;
1694 sin
.sin_port
= htons (7000); /* FIXME: This should be configurable */
1696 if (bind (s0
, (struct sockaddr
*) &sin
, sizeof (sin
)))
1697 error ("couldn't bind socket");
1700 error ("Couldn't open socket for listening.\n");
1702 /* Start up the stub on the remote device. */
1703 if (!CeCreateProcess (towide (stub_file_name
, NULL
), towide (args
, NULL
),
1704 NULL
, NULL
, 0, 0, NULL
, NULL
, NULL
, &pi
))
1705 error ("Unable to start remote stub '%s'. Windows CE error %d.",
1706 stub_file_name
, CeGetLastError ());
1708 /* Wait for a connection */
1710 if ((s
= accept (s0
, NULL
, NULL
)) < 0)
1711 error ("couldn't set up server for connection.");
1716 /* Start an inferior win32 child process and sets inferior_ptid to its pid.
1717 EXEC_FILE is the file to run.
1718 ALLARGS is a string containing the arguments to the program.
1719 ENV is the environment vector to pass. Errors reported with error(). */
1721 child_create_inferior (char *exec_file
, char *args
, char **env
,
1724 PROCESS_INFORMATION pi
;
1725 struct target_waitstatus dummy
;
1727 DWORD flags
, event_code
;
1728 char *exec_and_args
;
1731 error ("No executable specified, use `target exec'.\n");
1733 flags
= DEBUG_PROCESS
;
1735 wince_initialize (); /* Make sure we've got a connection. */
1737 exec_file
= upload_to_device (exec_file
, exec_file
);
1739 while (*args
== ' ')
1742 /* Allocate space for "command<sp>args" */
1745 exec_and_args
= alloca (strlen (exec_file
) + 1);
1746 strcpy (exec_and_args
, exec_file
);
1750 exec_and_args
= alloca (strlen (exec_file
+ strlen (args
) + 2));
1751 sprintf (exec_and_args
, "%s %s", exec_file
, args
);
1754 memset (&pi
, 0, sizeof (pi
));
1755 /* Execute the process */
1756 if (!create_process (exec_file
, exec_and_args
, flags
, &pi
))
1757 error ("Error creating process %s, (error %d)\n", exec_file
, GetLastError ());
1759 exception_count
= 0;
1762 current_process_handle
= pi
.hProcess
;
1763 current_event
.dwProcessId
= pi
.dwProcessId
;
1764 memset (¤t_event
, 0, sizeof (current_event
));
1765 current_event
.dwThreadId
= pi
.dwThreadId
;
1766 inferior_ptid
= pid_to_ptid (current_event
.dwThreadId
);
1767 push_target (&deprecated_child_ops
);
1768 child_init_thread_list ();
1769 child_add_thread (pi
.dwThreadId
, pi
.hThread
);
1770 init_wait_for_inferior ();
1771 clear_proceed_status ();
1772 target_terminal_init ();
1773 target_terminal_inferior ();
1775 /* Run until process and threads are loaded */
1776 while (!get_child_debug_event (PIDGET (inferior_ptid
), &dummy
,
1777 CREATE_PROCESS_DEBUG_EVENT
, &ret
))
1780 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_0
, 0);
1783 /* Chile has gone bye-bye. */
1785 child_mourn_inferior (void)
1787 (void) child_continue (DBG_CONTINUE
, -1);
1788 unpush_target (&deprecated_child_ops
);
1791 connection_initialized
= 0;
1792 generic_mourn_inferior ();
1795 /* Move memory from child to/from gdb. */
1797 child_xfer_memory (CORE_ADDR memaddr
, char *our
, int len
, int write
,
1798 struct mem_attrib
*attrib
,
1799 struct target_ops
*target
)
1805 res
= remote_write_bytes (memaddr
, our
, len
);
1807 res
= remote_read_bytes (memaddr
, our
, len
);
1812 /* Terminate the process and wait for child to tell us it has completed. */
1814 child_kill_inferior (void)
1816 CHECK (terminate_process (current_process_handle
));
1820 if (!child_continue (DBG_CONTINUE
, -1))
1822 if (!wait_for_debug_event (¤t_event
, INFINITE
))
1824 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
1828 CHECK (close_handle (current_process_handle
));
1829 close_handle (current_thread
->h
);
1830 target_mourn_inferior (); /* or just child_mourn_inferior? */
1833 /* Resume the child after an exception. */
1835 child_resume (ptid_t ptid
, int step
, enum target_signal sig
)
1838 DWORD continue_status
= last_sig
> 0 && last_sig
< NSIG
?
1839 DBG_EXCEPTION_NOT_HANDLED
: DBG_CONTINUE
;
1840 int pid
= PIDGET (ptid
);
1842 DEBUG_EXEC (("gdb: child_resume (pid=%d, step=%d, sig=%d);\n",
1845 /* Get context for currently selected thread */
1846 th
= thread_rec (current_event
.dwThreadId
, FALSE
);
1848 if (th
->context
.ContextFlags
)
1850 CHECK (set_thread_context (th
->h
, &th
->context
));
1851 th
->context
.ContextFlags
= 0;
1854 /* Allow continuing with the same signal that interrupted us.
1855 Otherwise complain. */
1856 if (sig
&& sig
!= last_sig
)
1857 fprintf_unfiltered (gdb_stderr
, "Can't send signals to the child. signal %d\n", sig
);
1860 child_continue (continue_status
, pid
);
1864 child_prepare_to_store (void)
1866 /* Do nothing, since we can store individual regs */
1870 child_can_run (void)
1878 DEBUG_EVENTS (("gdb: child_close, inferior_ptid=%d\n",
1879 PIDGET (inferior_ptid
)));
1882 /* Explicitly upload file to remotedir */
1885 child_load (char *file
, int from_tty
)
1887 upload_to_device (file
, file
);
1891 init_child_ops (void)
1893 memset (&deprecated_child_ops
, 0, sizeof (deprecated_child_ops
));
1894 deprecated_child_ops
.to_shortname
= (char *) "child";
1895 deprecated_child_ops
.to_longname
= (char *) "Windows CE process";
1896 deprecated_child_ops
.to_doc
= (char *) "Windows CE process (started by the \"run\" command).";
1897 deprecated_child_ops
.to_open
= child_open
;
1898 deprecated_child_ops
.to_close
= child_close
;
1899 deprecated_child_ops
.to_resume
= child_resume
;
1900 deprecated_child_ops
.to_wait
= child_wait
;
1901 deprecated_child_ops
.to_fetch_registers
= child_fetch_inferior_registers
;
1902 deprecated_child_ops
.to_store_registers
= child_store_inferior_registers
;
1903 deprecated_child_ops
.to_prepare_to_store
= child_prepare_to_store
;
1904 deprecated_child_ops
.deprecated_xfer_memory
= child_xfer_memory
;
1905 deprecated_child_ops
.to_files_info
= child_files_info
;
1906 deprecated_child_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
1907 deprecated_child_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
1908 deprecated_child_ops
.to_terminal_init
= terminal_init_inferior
;
1909 deprecated_child_ops
.to_terminal_inferior
= terminal_inferior
;
1910 deprecated_child_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
1911 deprecated_child_ops
.to_terminal_ours
= terminal_ours
;
1912 deprecated_child_ops
.to_terminal_save_ours
= terminal_save_ours
;
1913 deprecated_child_ops
.to_terminal_info
= child_terminal_info
;
1914 deprecated_child_ops
.to_kill
= child_kill_inferior
;
1915 deprecated_child_ops
.to_load
= child_load
;
1916 deprecated_child_ops
.to_create_inferior
= child_create_inferior
;
1917 deprecated_child_ops
.to_mourn_inferior
= child_mourn_inferior
;
1918 deprecated_child_ops
.to_can_run
= child_can_run
;
1919 deprecated_child_ops
.to_thread_alive
= win32_child_thread_alive
;
1920 deprecated_child_ops
.to_stratum
= process_stratum
;
1921 deprecated_child_ops
.to_has_all_memory
= 1;
1922 deprecated_child_ops
.to_has_memory
= 1;
1923 deprecated_child_ops
.to_has_stack
= 1;
1924 deprecated_child_ops
.to_has_registers
= 1;
1925 deprecated_child_ops
.to_has_execution
= 1;
1926 deprecated_child_ops
.to_magic
= OPS_MAGIC
;
1930 /* Handle 'set remoteupload' parameter. */
1932 #define replace_upload(what) \
1933 upload_when = what; \
1934 remote_upload = xrealloc (remote_upload, strlen (upload_options[upload_when].name) + 1); \
1935 strcpy (remote_upload, upload_options[upload_when].name);
1938 set_upload_type (char *ignore
, int from_tty
)
1943 if (!remote_upload
|| !remote_upload
[0])
1945 replace_upload (UPLOAD_NEWER
);
1947 printf_unfiltered ("Upload upload_options are: always, newer, never.\n");
1951 len
= strlen (remote_upload
);
1952 for (i
= 0; i
< (sizeof (upload_options
) / sizeof (upload_options
[0])); i
++)
1953 if (len
>= upload_options
[i
].abbrev
&&
1954 strncasecmp (remote_upload
, upload_options
[i
].name
, len
) == 0)
1960 bad_option
= remote_upload
;
1961 replace_upload (UPLOAD_NEWER
);
1962 error ("Unknown upload type: %s.", bad_option
);
1966 _initialize_wince (void)
1968 struct cmd_list_element
*set
;
1971 deprecated_add_show_from_set
1972 (add_set_cmd ((char *) "remotedirectory", no_class
,
1973 var_string_noescape
, (char *) &remote_directory
,
1974 (char *) "Set directory for remote upload.\n",
1977 remote_directory
= xstrdup (remote_directory
);
1979 set
= add_set_cmd ((char *) "remoteupload", no_class
,
1980 var_string_noescape
, (char *) &remote_upload
,
1981 (char *) "Set how to upload executables to remote device.\n",
1983 deprecated_add_show_from_set (set
, &showlist
);
1984 set_cmd_cfunc (set
, set_upload_type
);
1985 set_upload_type (NULL
, 0);
1987 deprecated_add_show_from_set
1988 (add_set_cmd ((char *) "debugexec", class_support
, var_boolean
,
1989 (char *) &debug_exec
,
1990 (char *) "Set whether to display execution in child process.",
1994 deprecated_add_show_from_set
1995 (add_set_cmd ((char *) "remoteaddhost", class_support
, var_boolean
,
1996 (char *) &remote_add_host
,
1998 Set whether to add this host to remote stub arguments for\n\
1999 debugging over a network.", &setlist
),
2002 deprecated_add_show_from_set
2003 (add_set_cmd ((char *) "debugevents", class_support
, var_boolean
,
2004 (char *) &debug_events
,
2005 (char *) "Set whether to display kernel events in child process.",
2009 deprecated_add_show_from_set
2010 (add_set_cmd ((char *) "debugmemory", class_support
, var_boolean
,
2011 (char *) &debug_memory
,
2012 (char *) "Set whether to display memory accesses in child process.",
2016 deprecated_add_show_from_set
2017 (add_set_cmd ((char *) "debugexceptions", class_support
, var_boolean
,
2018 (char *) &debug_exceptions
,
2019 (char *) "Set whether to display kernel exceptions in child process.",
2023 add_target (&deprecated_child_ops
);
2026 /* Determine if the thread referenced by "pid" is alive
2027 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
2028 it means that the pid has died. Otherwise it is assumed to be alive. */
2030 win32_child_thread_alive (ptid_t ptid
)
2032 int pid
= PIDGET (ptid
);
2033 return thread_alive (thread_rec (pid
, FALSE
)->h
);
2036 /* Convert pid to printable format. */
2038 cygwin_pid_to_str (int pid
)
2040 static char buf
[80];
2041 if (pid
== current_event
.dwProcessId
)
2042 sprintf (buf
, "process %d", pid
);
2044 sprintf (buf
, "thread %d.0x%x", (unsigned) current_event
.dwProcessId
, pid
);