1
2
/*
* gdb server stub
ths
authored
18 years ago
3
*
4
* Copyright ( c ) 2003 - 2005 Fabrice Bellard
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
*
* This library is free software ; you can redistribute it and / or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation ; either
* version 2 of the License , or ( at your option ) any later version .
*
* This library is distributed in the hope that it will be useful ,
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the GNU
* Lesser General Public License for more details .
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library ; if not , write to the Free Software
* Foundation , Inc ., 59 Temple Place , Suite 330 , Boston , MA 02111 - 1307 USA
*/
20
# include "config.h"
21
22
23
24
25
26
27
# ifdef CONFIG_USER_ONLY
# include < stdlib . h >
# include < stdio . h >
# include < stdarg . h >
# include < string . h >
# include < errno . h >
# include < unistd . h >
28
# include < fcntl . h >
29
30
31
# include "qemu.h"
# else
32
33
34
35
# include "qemu-common.h"
# include "qemu-char.h"
# include "sysemu.h"
# include "gdbstub.h"
36
# endif
37
38
39
40
41
42
43
44
45
46
47
# include "qemu_socket.h"
# ifdef _WIN32
/* XXX: these constants may be independent of the host ones even for Unix */
# ifndef SIGTRAP
# define SIGTRAP 5
# endif
# ifndef SIGINT
# define SIGINT 2
# endif
# else
48
# include < signal . h >
49
# endif
50
51
// # define DEBUG_GDB
52
53
54
55
56
57
enum RSState {
RS_IDLE ,
RS_GETLINE ,
RS_CHKSUM1 ,
RS_CHKSUM2 ,
58
RS_SYSCALL ,
59
60
};
typedef struct GDBState {
61
CPUState * env ; /* current CPU */
62
enum RSState state ; /* parsing state */
63
64
65
char line_buf [ 4096 ];
int line_buf_index ;
int line_csum ;
ths
authored
17 years ago
66
uint8_t last_packet [ 4100 ];
67
int last_packet_len ;
68
int signal ;
69
# ifdef CONFIG_USER_ONLY
70
int fd ;
71
int running_state ;
72
73
# else
CharDriverState * chr ;
74
# endif
75
} GDBState ;
76
77
78
79
80
81
/* By default use no IRQs and no timers while single stepping so as to
* make single stepping like an ICE HW step .
*/
static int sstep_flags = SSTEP_ENABLE | SSTEP_NOIRQ | SSTEP_NOTIMER ;
82
# ifdef CONFIG_USER_ONLY
83
84
85
/* XXX: This is not thread safe. Do we care? */
static int gdbserver_fd = - 1 ;
86
87
88
/* XXX: remove this hack. */
static GDBState gdbserver_state ;
89
static int get_char ( GDBState * s )
90
91
92
93
94
{
uint8_t ch ;
int ret ;
for (;;) {
95
ret = recv ( s -> fd , & ch , 1 , 0 );
96
if ( ret < 0 ) {
97
98
if ( errno == ECONNRESET )
s -> fd = - 1 ;
99
100
101
if ( errno != EINTR && errno != EAGAIN )
return - 1 ;
} else if ( ret == 0 ) {
102
103
close ( s -> fd );
s -> fd = - 1 ;
104
105
106
107
108
109
110
return - 1 ;
} else {
break ;
}
}
return ch ;
}
111
# endif
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
/* GDB stub state for use by semihosting syscalls. */
static GDBState * gdb_syscall_state ;
static gdb_syscall_complete_cb gdb_current_syscall_cb ;
enum {
GDB_SYS_UNKNOWN ,
GDB_SYS_ENABLED ,
GDB_SYS_DISABLED ,
} gdb_syscall_mode ;
/* If gdb is connected when the first semihosting syscall occurs then use
remote gdb syscalls . Otherwise use native file IO . */
int use_gdb_syscalls ( void )
{
if ( gdb_syscall_mode == GDB_SYS_UNKNOWN ) {
gdb_syscall_mode = ( gdb_syscall_state ? GDB_SYS_ENABLED
: GDB_SYS_DISABLED );
}
return gdb_syscall_mode == GDB_SYS_ENABLED ;
}
134
135
136
137
138
139
140
141
142
143
/* Resume execution. */
static inline void gdb_continue ( GDBState * s )
{
# ifdef CONFIG_USER_ONLY
s -> running_state = 1 ;
# else
vm_start ();
# endif
}
144
static void put_buffer ( GDBState * s , const uint8_t * buf , int len )
145
{
146
# ifdef CONFIG_USER_ONLY
147
148
149
int ret ;
while ( len > 0 ) {
150
ret = send ( s -> fd , buf , len , 0 );
151
152
153
154
155
156
157
158
if ( ret < 0 ) {
if ( errno != EINTR && errno != EAGAIN )
return ;
} else {
buf += ret ;
len -= ret ;
}
}
159
160
161
# else
qemu_chr_write ( s -> chr , buf , len );
# endif
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
}
static inline int fromhex ( int v )
{
if ( v >= '0' && v <= '9' )
return v - '0' ;
else if ( v >= 'A' && v <= 'F' )
return v - 'A' + 10 ;
else if ( v >= 'a' && v <= 'f' )
return v - 'a' + 10 ;
else
return 0 ;
}
static inline int tohex ( int v )
{
if ( v < 10 )
return v + '0' ;
else
return v - 10 + 'a' ;
}
static void memtohex ( char * buf , const uint8_t * mem , int len )
{
int i , c ;
char * q ;
q = buf ;
for ( i = 0 ; i < len ; i ++ ) {
c = mem [ i ];
* q ++ = tohex ( c >> 4 );
* q ++ = tohex ( c & 0xf );
}
* q = '\0' ;
}
static void hextomem ( uint8_t * mem , const char * buf , int len )
{
int i ;
for ( i = 0 ; i < len ; i ++ ) {
mem [ i ] = ( fromhex ( buf [ 0 ]) << 4 ) | fromhex ( buf [ 1 ]);
buf += 2 ;
}
}
/* return -1 if error, 0 if OK */
208
static int put_packet ( GDBState * s , char * buf )
209
{
210
int len , csum , i ;
ths
authored
17 years ago
211
uint8_t * p ;
212
213
214
215
216
217
# ifdef DEBUG_GDB
printf ( "reply='%s' \n " , buf );
# endif
for (;;) {
218
219
p = s -> last_packet ;
* ( p ++ ) = '$' ;
220
len = strlen ( buf );
221
222
memcpy ( p , buf , len );
p += len ;
223
224
225
226
csum = 0 ;
for ( i = 0 ; i < len ; i ++ ) {
csum += buf [ i ];
}
227
228
229
* ( p ++ ) = '#' ;
* ( p ++ ) = tohex (( csum >> 4 ) & 0xf );
* ( p ++ ) = tohex (( csum ) & 0xf );
230
231
s -> last_packet_len = p - s -> last_packet ;
ths
authored
17 years ago
232
put_buffer ( s , ( uint8_t * ) s -> last_packet , s -> last_packet_len );
233
234
235
236
# ifdef CONFIG_USER_ONLY
i = get_char ( s );
if ( i < 0 )
237
return - 1 ;
238
if ( i == '+' )
239
break ;
240
241
242
# else
break ;
# endif
243
244
245
246
}
return 0 ;
}
247
# if defined ( TARGET_I386 )
248
249
250
251
252
253
254
255
# ifdef TARGET_X86_64
static const uint8_t gdb_x86_64_regs [ 16 ] = {
R_EAX , R_EBX , R_ECX , R_EDX , R_ESI , R_EDI , R_EBP , R_ESP ,
8 , 9 , 10 , 11 , 12 , 13 , 14 , 15 ,
};
# endif
256
257
static int cpu_gdb_read_registers ( CPUState * env , uint8_t * mem_buf )
{
258
259
int i , fpus , nb_regs ;
uint8_t * p ;
260
261
p = mem_buf ;
262
263
# ifdef TARGET_X86_64
if ( env -> hflags & HF_CS64_MASK ) {
264
265
266
267
nb_regs = 16 ;
for ( i = 0 ; i < 16 ; i ++ ) {
* ( uint64_t * ) p = tswap64 ( env -> regs [ gdb_x86_64_regs [ i ]]);
p += 8 ;
268
}
269
270
271
272
273
274
* ( uint64_t * ) p = tswap64 ( env -> eip );
p += 8 ;
} else
# endif
{
nb_regs = 8 ;
275
for ( i = 0 ; i < 8 ; i ++ ) {
276
277
* ( uint32_t * ) p = tswap32 ( env -> regs [ i ]);
p += 4 ;
278
}
279
280
* ( uint32_t * ) p = tswap32 ( env -> eip );
p += 4 ;
281
}
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
* ( uint32_t * ) p = tswap32 ( env -> eflags );
p += 4 ;
* ( uint32_t * ) p = tswap32 ( env -> segs [ R_CS ]. selector );
p += 4 ;
* ( uint32_t * ) p = tswap32 ( env -> segs [ R_SS ]. selector );
p += 4 ;
* ( uint32_t * ) p = tswap32 ( env -> segs [ R_DS ]. selector );
p += 4 ;
* ( uint32_t * ) p = tswap32 ( env -> segs [ R_ES ]. selector );
p += 4 ;
* ( uint32_t * ) p = tswap32 ( env -> segs [ R_FS ]. selector );
p += 4 ;
* ( uint32_t * ) p = tswap32 ( env -> segs [ R_GS ]. selector );
p += 4 ;
297
for ( i = 0 ; i < 8 ; i ++ ) {
298
299
300
301
302
303
304
/* XXX: convert floats */
# ifdef USE_X86LDOUBLE
memcpy ( p , & env -> fpregs [ i ], 10 );
# else
memset ( p , 0 , 10 );
# endif
p += 10 ;
305
}
306
307
* ( uint32_t * ) p = tswap32 ( env -> fpuc ); /* fctrl */
p += 4 ;
308
fpus = ( env -> fpus & ~ 0x3800 ) | ( env -> fpstt & 0x7 ) << 11 ;
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
* ( uint32_t * ) p = tswap32 ( fpus ); /* fstat */
p += 4 ;
* ( uint32_t * ) p = 0 ; /* ftag */
p += 4 ;
* ( uint32_t * ) p = 0 ; /* fiseg */
p += 4 ;
* ( uint32_t * ) p = 0 ; /* fioff */
p += 4 ;
* ( uint32_t * ) p = 0 ; /* foseg */
p += 4 ;
* ( uint32_t * ) p = 0 ; /* fooff */
p += 4 ;
* ( uint32_t * ) p = 0 ; /* fop */
p += 4 ;
for ( i = 0 ; i < nb_regs ; i ++ ) {
* ( uint64_t * ) p = tswap64 ( env -> xmm_regs [ i ]. XMM_Q ( 0 ));
p += 8 ;
* ( uint64_t * ) p = tswap64 ( env -> xmm_regs [ i ]. XMM_Q ( 1 ));
p += 8 ;
}
* ( uint32_t * ) p = tswap32 ( env -> mxcsr );
p += 4 ;
return p - mem_buf ;
}
static inline void cpu_gdb_load_seg ( CPUState * env , const uint8_t ** pp ,
int sreg )
{
const uint8_t * p ;
uint32_t sel ;
p = * pp ;
sel = tswap32 ( * ( uint32_t * ) p );
p += 4 ;
if ( sel != env -> segs [ sreg ]. selector ) {
# if defined ( CONFIG_USER_ONLY )
cpu_x86_load_seg ( env , sreg , sel );
# else
/* XXX : do it with a debug function which does not raise an
exception */
# endif
}
* pp = p ;
351
352
353
354
}
static void cpu_gdb_write_registers ( CPUState * env , uint8_t * mem_buf , int size )
{
355
356
357
const uint8_t * p = mem_buf ;
int i , nb_regs ;
uint16_t fpus ;
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
# ifdef TARGET_X86_64
if ( env -> hflags & HF_CS64_MASK ) {
nb_regs = 16 ;
for ( i = 0 ; i < 16 ; i ++ ) {
env -> regs [ gdb_x86_64_regs [ i ]] = tswap64 ( * ( uint64_t * ) p );
p += 8 ;
}
env -> eip = tswap64 ( * ( uint64_t * ) p );
p += 8 ;
} else
# endif
{
nb_regs = 8 ;
for ( i = 0 ; i < 8 ; i ++ ) {
env -> regs [ i ] = tswap32 ( * ( uint32_t * ) p );
p += 4 ;
}
env -> eip = tswap32 ( * ( uint32_t * ) p );
p += 4 ;
378
}
379
380
381
382
383
384
385
386
387
388
389
390
391
392
env -> eflags = tswap32 ( * ( uint32_t * ) p );
p += 4 ;
cpu_gdb_load_seg ( env , & p , R_CS );
cpu_gdb_load_seg ( env , & p , R_SS );
cpu_gdb_load_seg ( env , & p , R_DS );
cpu_gdb_load_seg ( env , & p , R_ES );
cpu_gdb_load_seg ( env , & p , R_FS );
cpu_gdb_load_seg ( env , & p , R_GS );
/* FPU state */
for ( i = 0 ; i < 8 ; i ++ ) {
/* XXX: convert floats */
# ifdef USE_X86LDOUBLE
memcpy ( & env -> fpregs [ i ], p , 10 );
393
# endif
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
p += 10 ;
}
env -> fpuc = tswap32 ( * ( uint32_t * ) p ); /* fctrl */
p += 4 ;
fpus = tswap32 ( * ( uint32_t * ) p );
p += 4 ;
env -> fpstt = ( fpus >> 11 ) & 7 ;
env -> fpus = fpus & ~ 0x3800 ;
p += 4 * 6 ;
if ( size >= (( p - mem_buf ) + 16 * nb_regs + 4 )) {
/* SSE state */
for ( i = 0 ; i < nb_regs ; i ++ ) {
env -> xmm_regs [ i ]. XMM_Q ( 0 ) = tswap64 ( * ( uint64_t * ) p );
p += 8 ;
env -> xmm_regs [ i ]. XMM_Q ( 1 ) = tswap64 ( * ( uint64_t * ) p );
p += 8 ;
}
env -> mxcsr = tswap32 ( * ( uint32_t * ) p );
p += 4 ;
}
415
416
}
417
418
419
# elif defined ( TARGET_PPC )
static int cpu_gdb_read_registers ( CPUState * env , uint8_t * mem_buf )
{
420
uint32_t * registers = ( uint32_t * ) mem_buf , tmp ;
421
422
423
int i ;
/* fill in gprs */
424
for ( i = 0 ; i < 32 ; i ++ ) {
425
registers [ i ] = tswapl ( env -> gpr [ i ]);
426
427
428
}
/* fill in fprs */
for ( i = 0 ; i < 32 ; i ++ ) {
429
430
registers [( i * 2 ) + 32 ] = tswapl ( * (( uint32_t * ) & env -> fpr [ i ]));
registers [( i * 2 ) + 33 ] = tswapl ( * (( uint32_t * ) & env -> fpr [ i ] + 1 ));
431
432
}
/* nip, msr, ccr, lnk, ctr, xer, mq */
433
registers [ 96 ] = tswapl ( env -> nip );
434
registers [ 97 ] = tswapl ( env -> msr );
435
436
tmp = 0 ;
for ( i = 0 ; i < 8 ; i ++ )
437
tmp |= env -> crf [ i ] << ( 32 - (( i + 1 ) * 4 ));
438
439
440
registers [ 98 ] = tswapl ( tmp );
registers [ 99 ] = tswapl ( env -> lr );
registers [ 100 ] = tswapl ( env -> ctr );
441
registers [ 101 ] = tswapl ( ppc_load_xer ( env ));
442
registers [ 102 ] = 0 ;
443
444
return 103 * 4 ;
445
446
447
448
449
450
451
452
453
}
static void cpu_gdb_write_registers ( CPUState * env , uint8_t * mem_buf , int size )
{
uint32_t * registers = ( uint32_t * ) mem_buf ;
int i ;
/* fill in gprs */
for ( i = 0 ; i < 32 ; i ++ ) {
454
env -> gpr [ i ] = tswapl ( registers [ i ]);
455
456
457
}
/* fill in fprs */
for ( i = 0 ; i < 32 ; i ++ ) {
458
459
* (( uint32_t * ) & env -> fpr [ i ]) = tswapl ( registers [( i * 2 ) + 32 ]);
* (( uint32_t * ) & env -> fpr [ i ] + 1 ) = tswapl ( registers [( i * 2 ) + 33 ]);
460
461
}
/* nip, msr, ccr, lnk, ctr, xer, mq */
462
env -> nip = tswapl ( registers [ 96 ]);
463
ppc_store_msr ( env , tswapl ( registers [ 97 ]));
464
registers [ 98 ] = tswapl ( registers [ 98 ]);
465
for ( i = 0 ; i < 8 ; i ++ )
466
env -> crf [ i ] = ( registers [ 98 ] >> ( 32 - (( i + 1 ) * 4 ))) & 0xF ;
467
468
env -> lr = tswapl ( registers [ 99 ]);
env -> ctr = tswapl ( registers [ 100 ]);
469
ppc_store_xer ( env , tswapl ( registers [ 101 ]));
470
471
}
# elif defined ( TARGET_SPARC )
472
473
474
475
476
# ifdef TARGET_ABI32
# define tswap_abi ( val ) tswap32 ( val & 0xffffffff )
# else
# define tswap_abi ( val ) tswapl ( val )
# endif
477
478
static int cpu_gdb_read_registers ( CPUState * env , uint8_t * mem_buf )
{
479
480
481
# ifdef TARGET_ABI32
abi_ulong * registers = ( abi_ulong * ) mem_buf ;
# else
482
target_ulong * registers = ( target_ulong * ) mem_buf ;
483
# endif
484
485
486
int i ;
/* fill in g0..g7 */
487
for ( i = 0 ; i < 8 ; i ++ ) {
488
registers [ i ] = tswap_abi ( env -> gregs [ i ]);
489
490
491
}
/* fill in register window */
for ( i = 0 ; i < 24 ; i ++ ) {
492
registers [ i + 8 ] = tswap_abi ( env -> regwptr [ i ]);
493
}
494
# if ! defined ( TARGET_SPARC64 ) || defined ( TARGET_ABI32 )
495
496
/* fill in fprs */
for ( i = 0 ; i < 32 ; i ++ ) {
497
registers [ i + 32 ] = tswap_abi ( * (( uint32_t * ) & env -> fpr [ i ]));
498
499
}
/* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
500
registers [ 64 ] = tswap_abi ( env -> y );
501
{
502
uint32_t tmp ;
503
504
505
tmp = GET_PSR ( env );
registers [ 65 ] = tswap32 ( tmp );
506
}
507
508
509
510
511
registers [ 66 ] = tswap_abi ( env -> wim );
registers [ 67 ] = tswap_abi ( env -> tbr );
registers [ 68 ] = tswap_abi ( env -> pc );
registers [ 69 ] = tswap_abi ( env -> npc );
registers [ 70 ] = tswap_abi ( env -> fsr );
512
513
registers [ 71 ] = 0 ; /* csr */
registers [ 72 ] = 0 ;
514
return 73 * sizeof ( uint32_t );
515
# else
516
517
518
519
/* fill in fprs */
for ( i = 0 ; i < 64 ; i += 2 ) {
uint64_t tmp ;
520
521
522
tmp = (( uint64_t ) * ( uint32_t * ) & env -> fpr [ i ]) << 32 ;
tmp |= * ( uint32_t * ) & env -> fpr [ i + 1 ];
registers [ i / 2 + 32 ] = tswap64 ( tmp );
523
}
524
525
registers [ 64 ] = tswapl ( env -> pc );
registers [ 65 ] = tswapl ( env -> npc );
526
527
528
529
registers [ 66 ] = tswapl ((( uint64_t ) GET_CCR ( env ) << 32 ) |
(( env -> asi & 0xff ) << 24 ) |
(( env -> pstate & 0xfff ) << 8 ) |
GET_CWP64 ( env ));
530
531
532
533
registers [ 67 ] = tswapl ( env -> fsr );
registers [ 68 ] = tswapl ( env -> fprs );
registers [ 69 ] = tswapl ( env -> y );
return 70 * sizeof ( target_ulong );
534
# endif
535
536
537
538
}
static void cpu_gdb_write_registers ( CPUState * env , uint8_t * mem_buf , int size )
{
539
540
541
# ifdef TARGET_ABI32
abi_ulong * registers = ( abi_ulong * ) mem_buf ;
# else
542
target_ulong * registers = ( target_ulong * ) mem_buf ;
543
# endif
544
545
546
547
int i ;
/* fill in g0..g7 */
for ( i = 0 ; i < 7 ; i ++ ) {
548
env -> gregs [ i ] = tswap_abi ( registers [ i ]);
549
550
551
}
/* fill in register window */
for ( i = 0 ; i < 24 ; i ++ ) {
552
env -> regwptr [ i ] = tswap_abi ( registers [ i + 8 ]);
553
}
554
# if ! defined ( TARGET_SPARC64 ) || defined ( TARGET_ABI32 )
555
556
/* fill in fprs */
for ( i = 0 ; i < 32 ; i ++ ) {
557
* (( uint32_t * ) & env -> fpr [ i ]) = tswap_abi ( registers [ i + 32 ]);
558
559
}
/* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
560
561
562
563
564
565
566
env -> y = tswap_abi ( registers [ 64 ]);
PUT_PSR ( env , tswap_abi ( registers [ 65 ]));
env -> wim = tswap_abi ( registers [ 66 ]);
env -> tbr = tswap_abi ( registers [ 67 ]);
env -> pc = tswap_abi ( registers [ 68 ]);
env -> npc = tswap_abi ( registers [ 69 ]);
env -> fsr = tswap_abi ( registers [ 70 ]);
567
# else
568
for ( i = 0 ; i < 64 ; i += 2 ) {
569
570
571
572
573
uint64_t tmp ;
tmp = tswap64 ( registers [ i / 2 + 32 ]);
* (( uint32_t * ) & env -> fpr [ i ]) = tmp >> 32 ;
* (( uint32_t * ) & env -> fpr [ i + 1 ]) = tmp & 0xffffffff ;
574
}
575
576
env -> pc = tswapl ( registers [ 64 ]);
env -> npc = tswapl ( registers [ 65 ]);
577
578
579
580
581
582
583
584
{
uint64_t tmp = tswapl ( registers [ 66 ]);
PUT_CCR ( env , tmp >> 32 );
env -> asi = ( tmp >> 24 ) & 0xff ;
env -> pstate = ( tmp >> 8 ) & 0xfff ;
PUT_CWP64 ( env , tmp & 0xff );
}
585
586
587
env -> fsr = tswapl ( registers [ 67 ]);
env -> fprs = tswapl ( registers [ 68 ]);
env -> y = tswapl ( registers [ 69 ]);
588
# endif
589
}
590
# undef tswap_abi
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
# elif defined ( TARGET_ARM )
static int cpu_gdb_read_registers ( CPUState * env , uint8_t * mem_buf )
{
int i ;
uint8_t * ptr ;
ptr = mem_buf ;
/* 16 core integer registers (4 bytes each). */
for ( i = 0 ; i < 16 ; i ++ )
{
* ( uint32_t * ) ptr = tswapl ( env -> regs [ i ]);
ptr += 4 ;
}
/* 8 FPA registers ( 12 bytes each ), FPS ( 4 bytes ).
Not yet implemented . */
memset ( ptr , 0 , 8 * 12 + 4 );
ptr += 8 * 12 + 4 ;
/* CPSR (4 bytes). */
609
* ( uint32_t * ) ptr = tswapl ( cpsr_read ( env ));
610
611
612
613
ptr += 4 ;
return ptr - mem_buf ;
}
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
static void cpu_gdb_write_registers ( CPUState * env , uint8_t * mem_buf , int size )
{
int i ;
uint8_t * ptr ;
ptr = mem_buf ;
/* Core integer registers. */
for ( i = 0 ; i < 16 ; i ++ )
{
env -> regs [ i ] = tswapl ( * ( uint32_t * ) ptr );
ptr += 4 ;
}
/* Ignore FPA regs and scr. */
ptr += 8 * 12 + 4 ;
629
cpsr_write ( env , tswapl ( * ( uint32_t * ) ptr ), 0xffffffff );
630
}
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
# elif defined ( TARGET_M68K )
static int cpu_gdb_read_registers ( CPUState * env , uint8_t * mem_buf )
{
int i ;
uint8_t * ptr ;
CPU_DoubleU u ;
ptr = mem_buf ;
/* D0-D7 */
for ( i = 0 ; i < 8 ; i ++ ) {
* ( uint32_t * ) ptr = tswapl ( env -> dregs [ i ]);
ptr += 4 ;
}
/* A0-A7 */
for ( i = 0 ; i < 8 ; i ++ ) {
* ( uint32_t * ) ptr = tswapl ( env -> aregs [ i ]);
ptr += 4 ;
}
* ( uint32_t * ) ptr = tswapl ( env -> sr );
ptr += 4 ;
* ( uint32_t * ) ptr = tswapl ( env -> pc );
ptr += 4 ;
/* F0 - F7 . The 68881 / 68040 have 12 - bit extended precision registers .
ColdFire has 8 - bit double precision registers . */
for ( i = 0 ; i < 8 ; i ++ ) {
u . d = env -> fregs [ i ];
* ( uint32_t * ) ptr = tswap32 ( u . l . upper );
* ( uint32_t * ) ptr = tswap32 ( u . l . lower );
}
/* FP control regs (not implemented). */
memset ( ptr , 0 , 3 * 4 );
ptr += 3 * 4 ;
return ptr - mem_buf ;
}
static void cpu_gdb_write_registers ( CPUState * env , uint8_t * mem_buf , int size )
{
int i ;
uint8_t * ptr ;
CPU_DoubleU u ;
ptr = mem_buf ;
/* D0-D7 */
for ( i = 0 ; i < 8 ; i ++ ) {
env -> dregs [ i ] = tswapl ( * ( uint32_t * ) ptr );
ptr += 4 ;
}
/* A0-A7 */
for ( i = 0 ; i < 8 ; i ++ ) {
env -> aregs [ i ] = tswapl ( * ( uint32_t * ) ptr );
ptr += 4 ;
}
env -> sr = tswapl ( * ( uint32_t * ) ptr );
ptr += 4 ;
env -> pc = tswapl ( * ( uint32_t * ) ptr );
ptr += 4 ;
/* F0 - F7 . The 68881 / 68040 have 12 - bit extended precision registers .
ColdFire has 8 - bit double precision registers . */
for ( i = 0 ; i < 8 ; i ++ ) {
ths
authored
18 years ago
691
u . l . upper = tswap32 ( * ( uint32_t * ) ptr );
692
693
694
695
696
697
u . l . lower = tswap32 ( * ( uint32_t * ) ptr );
env -> fregs [ i ] = u . d ;
}
/* FP control regs (not implemented). */
ptr += 3 * 4 ;
}
698
699
700
701
702
703
704
705
706
# elif defined ( TARGET_MIPS )
static int cpu_gdb_read_registers ( CPUState * env , uint8_t * mem_buf )
{
int i ;
uint8_t * ptr ;
ptr = mem_buf ;
for ( i = 0 ; i < 32 ; i ++ )
{
ths
authored
17 years ago
707
* ( target_ulong * ) ptr = tswapl ( env -> active_tc . gpr [ i ]);
ths
authored
18 years ago
708
ptr += sizeof ( target_ulong );
709
710
}
ths
authored
17 years ago
711
* ( target_ulong * ) ptr = ( int32_t ) tswap32 ( env -> CP0_Status );
ths
authored
18 years ago
712
ptr += sizeof ( target_ulong );
713
ths
authored
17 years ago
714
* ( target_ulong * ) ptr = tswapl ( env -> active_tc . LO [ 0 ]);
ths
authored
18 years ago
715
ptr += sizeof ( target_ulong );
716
ths
authored
17 years ago
717
* ( target_ulong * ) ptr = tswapl ( env -> active_tc . HI [ 0 ]);
ths
authored
18 years ago
718
ptr += sizeof ( target_ulong );
719
ths
authored
18 years ago
720
721
* ( target_ulong * ) ptr = tswapl ( env -> CP0_BadVAddr );
ptr += sizeof ( target_ulong );
722
ths
authored
17 years ago
723
* ( target_ulong * ) ptr = ( int32_t ) tswap32 ( env -> CP0_Cause );
ths
authored
18 years ago
724
ptr += sizeof ( target_ulong );
725
ths
authored
17 years ago
726
* ( target_ulong * ) ptr = tswapl ( env -> active_tc . PC );
ths
authored
18 years ago
727
ptr += sizeof ( target_ulong );
728
ths
authored
18 years ago
729
if ( env -> CP0_Config1 & ( 1 << CP0C1_FP ))
ths
authored
18 years ago
730
{
ths
authored
18 years ago
731
732
for ( i = 0 ; i < 32 ; i ++ )
{
ths
authored
17 years ago
733
734
735
736
if ( env -> CP0_Status & ( 1 << CP0St_FR ))
* ( target_ulong * ) ptr = tswapl ( env -> fpu -> fpr [ i ]. d );
else
* ( target_ulong * ) ptr = tswap32 ( env -> fpu -> fpr [ i ]. w [ FP_ENDIAN_IDX ]);
ths
authored
18 years ago
737
ptr += sizeof ( target_ulong );
ths
authored
18 years ago
738
}
ths
authored
18 years ago
739
ths
authored
17 years ago
740
* ( target_ulong * ) ptr = ( int32_t ) tswap32 ( env -> fpu -> fcr31 );
ths
authored
18 years ago
741
ptr += sizeof ( target_ulong );
ths
authored
18 years ago
742
ths
authored
17 years ago
743
* ( target_ulong * ) ptr = ( int32_t ) tswap32 ( env -> fpu -> fcr0 );
ths
authored
18 years ago
744
ptr += sizeof ( target_ulong );
ths
authored
18 years ago
745
}
ths
authored
18 years ago
746
ths
authored
17 years ago
747
748
749
750
751
752
753
754
755
756
757
758
759
760
/* "fp", pseudo frame pointer. Not yet implemented in gdb. */
* ( target_ulong * ) ptr = 0 ;
ptr += sizeof ( target_ulong );
/* Registers for embedded use, we just pad them. */
for ( i = 0 ; i < 16 ; i ++ )
{
* ( target_ulong * ) ptr = 0 ;
ptr += sizeof ( target_ulong );
}
/* Processor ID. */
* ( target_ulong * ) ptr = ( int32_t ) tswap32 ( env -> CP0_PRid );
ptr += sizeof ( target_ulong );
761
762
763
764
return ptr - mem_buf ;
}
ths
authored
18 years ago
765
766
767
768
769
770
771
772
773
/* convert MIPS rounding mode in FCR31 to IEEE library */
static unsigned int ieee_rm [] =
{
float_round_nearest_even ,
float_round_to_zero ,
float_round_up ,
float_round_down
};
# define RESTORE_ROUNDING_MODE \
ths
authored
18 years ago
774
set_float_rounding_mode ( ieee_rm [ env -> fpu -> fcr31 & 3 ], & env -> fpu -> fp_status )
ths
authored
18 years ago
775
776
777
778
779
780
781
782
783
static void cpu_gdb_write_registers ( CPUState * env , uint8_t * mem_buf , int size )
{
int i ;
uint8_t * ptr ;
ptr = mem_buf ;
for ( i = 0 ; i < 32 ; i ++ )
{
ths
authored
17 years ago
784
env -> active_tc . gpr [ i ] = tswapl ( * ( target_ulong * ) ptr );
ths
authored
18 years ago
785
ptr += sizeof ( target_ulong );
786
787
}
ths
authored
18 years ago
788
789
env -> CP0_Status = tswapl ( * ( target_ulong * ) ptr );
ptr += sizeof ( target_ulong );
790
ths
authored
17 years ago
791
env -> active_tc . LO [ 0 ] = tswapl ( * ( target_ulong * ) ptr );
ths
authored
18 years ago
792
ptr += sizeof ( target_ulong );
793
ths
authored
17 years ago
794
env -> active_tc . HI [ 0 ] = tswapl ( * ( target_ulong * ) ptr );
ths
authored
18 years ago
795
ptr += sizeof ( target_ulong );
796
ths
authored
18 years ago
797
798
env -> CP0_BadVAddr = tswapl ( * ( target_ulong * ) ptr );
ptr += sizeof ( target_ulong );
799
ths
authored
18 years ago
800
801
env -> CP0_Cause = tswapl ( * ( target_ulong * ) ptr );
ptr += sizeof ( target_ulong );
802
ths
authored
17 years ago
803
env -> active_tc . PC = tswapl ( * ( target_ulong * ) ptr );
ths
authored
18 years ago
804
ptr += sizeof ( target_ulong );
ths
authored
18 years ago
805
ths
authored
18 years ago
806
if ( env -> CP0_Config1 & ( 1 << CP0C1_FP ))
ths
authored
18 years ago
807
{
ths
authored
18 years ago
808
809
for ( i = 0 ; i < 32 ; i ++ )
{
ths
authored
17 years ago
810
811
812
813
if ( env -> CP0_Status & ( 1 << CP0St_FR ))
env -> fpu -> fpr [ i ]. d = tswapl ( * ( target_ulong * ) ptr );
else
env -> fpu -> fpr [ i ]. w [ FP_ENDIAN_IDX ] = tswapl ( * ( target_ulong * ) ptr );
ths
authored
18 years ago
814
ptr += sizeof ( target_ulong );
ths
authored
18 years ago
815
}
ths
authored
18 years ago
816
ths
authored
17 years ago
817
env -> fpu -> fcr31 = tswapl ( * ( target_ulong * ) ptr ) & 0xFF83FFFF ;
ths
authored
18 years ago
818
ptr += sizeof ( target_ulong );
ths
authored
18 years ago
819
ths
authored
17 years ago
820
/* The remaining registers are assumed to be read-only. */
ths
authored
18 years ago
821
ths
authored
18 years ago
822
823
/* set rounding mode */
RESTORE_ROUNDING_MODE ;
ths
authored
18 years ago
824
825
# ifndef CONFIG_SOFTFLOAT
ths
authored
18 years ago
826
827
/* no floating point exception for native float */
SET_FP_ENABLE ( env -> fcr31 , 0 );
ths
authored
18 years ago
828
# endif
ths
authored
18 years ago
829
}
830
}
831
# elif defined ( TARGET_SH4 )
ths
authored
18 years ago
832
833
834
/* Hint: Use "set architecture sh4" in GDB to see fpu registers */
835
836
837
838
839
840
static int cpu_gdb_read_registers ( CPUState * env , uint8_t * mem_buf )
{
uint32_t * ptr = ( uint32_t * ) mem_buf ;
int i ;
# define SAVE ( x ) * ptr ++= tswapl ( x )
841
842
843
844
845
846
if (( env -> sr & ( SR_MD | SR_RB )) == ( SR_MD | SR_RB )) {
for ( i = 0 ; i < 8 ; i ++ ) SAVE ( env -> gregs [ i + 16 ]);
} else {
for ( i = 0 ; i < 8 ; i ++ ) SAVE ( env -> gregs [ i ]);
}
for ( i = 8 ; i < 16 ; i ++ ) SAVE ( env -> gregs [ i ]);
847
848
849
850
851
852
853
SAVE ( env -> pc );
SAVE ( env -> pr );
SAVE ( env -> gbr );
SAVE ( env -> vbr );
SAVE ( env -> mach );
SAVE ( env -> macl );
SAVE ( env -> sr );
ths
authored
18 years ago
854
855
856
857
858
859
860
861
SAVE ( env -> fpul );
SAVE ( env -> fpscr );
for ( i = 0 ; i < 16 ; i ++ )
SAVE ( env -> fregs [ i + (( env -> fpscr & FPSCR_FR ) ? 16 : 0 )]);
SAVE ( env -> ssr );
SAVE ( env -> spc );
for ( i = 0 ; i < 8 ; i ++ ) SAVE ( env -> gregs [ i ]);
for ( i = 0 ; i < 8 ; i ++ ) SAVE ( env -> gregs [ i + 16 ]);
862
863
864
865
866
867
868
869
870
return (( uint8_t * ) ptr - mem_buf );
}
static void cpu_gdb_write_registers ( CPUState * env , uint8_t * mem_buf , int size )
{
uint32_t * ptr = ( uint32_t * ) mem_buf ;
int i ;
# define LOAD ( x ) ( x ) =* ptr ++ ;
871
872
873
874
875
876
if (( env -> sr & ( SR_MD | SR_RB )) == ( SR_MD | SR_RB )) {
for ( i = 0 ; i < 8 ; i ++ ) LOAD ( env -> gregs [ i + 16 ]);
} else {
for ( i = 0 ; i < 8 ; i ++ ) LOAD ( env -> gregs [ i ]);
}
for ( i = 8 ; i < 16 ; i ++ ) LOAD ( env -> gregs [ i ]);
877
878
879
880
881
882
883
LOAD ( env -> pc );
LOAD ( env -> pr );
LOAD ( env -> gbr );
LOAD ( env -> vbr );
LOAD ( env -> mach );
LOAD ( env -> macl );
LOAD ( env -> sr );
ths
authored
18 years ago
884
885
886
887
888
889
890
891
LOAD ( env -> fpul );
LOAD ( env -> fpscr );
for ( i = 0 ; i < 16 ; i ++ )
LOAD ( env -> fregs [ i + (( env -> fpscr & FPSCR_FR ) ? 16 : 0 )]);
LOAD ( env -> ssr );
LOAD ( env -> spc );
for ( i = 0 ; i < 8 ; i ++ ) LOAD ( env -> gregs [ i ]);
for ( i = 0 ; i < 8 ; i ++ ) LOAD ( env -> gregs [ i + 16 ]);
892
}
ths
authored
17 years ago
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
# elif defined ( TARGET_CRIS )
static int cris_save_32 ( unsigned char * d , uint32_t value )
{
* d ++ = ( value );
* d ++ = ( value >>= 8 );
* d ++ = ( value >>= 8 );
* d ++ = ( value >>= 8 );
return 4 ;
}
static int cris_save_16 ( unsigned char * d , uint32_t value )
{
* d ++ = ( value );
* d ++ = ( value >>= 8 );
return 2 ;
}
static int cris_save_8 ( unsigned char * d , uint32_t value )
{
* d ++ = ( value );
return 1 ;
}
/* FIXME: this will bug on archs not supporting unaligned word accesses. */
static int cpu_gdb_read_registers ( CPUState * env , uint8_t * mem_buf )
{
uint8_t * ptr = mem_buf ;
uint8_t srs ;
int i ;
for ( i = 0 ; i < 16 ; i ++ )
ptr += cris_save_32 ( ptr , env -> regs [ i ]);
925
srs = env -> pregs [ PR_SRS ];
ths
authored
17 years ago
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
ptr += cris_save_8 ( ptr , env -> pregs [ 0 ]);
ptr += cris_save_8 ( ptr , env -> pregs [ 1 ]);
ptr += cris_save_32 ( ptr , env -> pregs [ 2 ]);
ptr += cris_save_8 ( ptr , srs );
ptr += cris_save_16 ( ptr , env -> pregs [ 4 ]);
for ( i = 5 ; i < 16 ; i ++ )
ptr += cris_save_32 ( ptr , env -> pregs [ i ]);
ptr += cris_save_32 ( ptr , env -> pc );
for ( i = 0 ; i < 16 ; i ++ )
ptr += cris_save_32 ( ptr , env -> sregs [ srs ][ i ]);
return (( uint8_t * ) ptr - mem_buf );
}
static void cpu_gdb_write_registers ( CPUState * env , uint8_t * mem_buf , int size )
{
uint32_t * ptr = ( uint32_t * ) mem_buf ;
int i ;
# define LOAD ( x ) ( x ) =* ptr ++ ;
for ( i = 0 ; i < 16 ; i ++ ) LOAD ( env -> regs [ i ]);
LOAD ( env -> pc );
}
953
# else
954
955
956
957
958
959
960
961
962
963
static int cpu_gdb_read_registers ( CPUState * env , uint8_t * mem_buf )
{
return 0 ;
}
static void cpu_gdb_write_registers ( CPUState * env , uint8_t * mem_buf , int size )
{
}
# endif
964
965
static int gdb_handle_packet ( GDBState * s , CPUState * env , const char * line_buf )
966
967
{
const char * p ;
968
int ch , reg_size , type ;
969
char buf [ 4096 ];
ths
authored
17 years ago
970
uint8_t mem_buf [ 4096 ];
971
uint32_t * registers ;
972
target_ulong addr , len ;
ths
authored
18 years ago
973
974
975
976
977
978
979
980
# ifdef DEBUG_GDB
printf ( "command='%s' \n " , line_buf );
# endif
p = line_buf ;
ch = * p ++ ;
switch ( ch ) {
case '?' :
981
/* TODO: Make this return the correct value for user-mode. */
982
983
snprintf ( buf , sizeof ( buf ), "S%02x" , SIGTRAP );
put_packet ( s , buf );
984
985
986
987
988
989
/* Remove all the breakpoints when this query is issued ,
* because gdb is doing and initial connect and the state
* should be cleaned up .
*/
cpu_breakpoint_remove_all ( env );
cpu_watchpoint_remove_all ( env );
990
991
992
break ;
case 'c' :
if ( * p != '\0' ) {
993
addr = strtoull ( p , ( char ** ) & p , 16 );
994
# if defined ( TARGET_I386 )
995
env -> eip = addr ;
996
# elif defined ( TARGET_PPC )
997
env -> nip = addr ;
998
999
1000
# elif defined ( TARGET_SPARC )
env -> pc = addr ;
env -> npc = addr + 4 ;
1001
1002
# elif defined ( TARGET_ARM )
env -> regs [ 15 ] = addr ;
1003
# elif defined ( TARGET_SH4 )
ths
authored
18 years ago
1004
1005
env -> pc = addr ;
# elif defined ( TARGET_MIPS )
ths
authored
17 years ago
1006
env -> active_tc . PC = addr ;
ths
authored
17 years ago
1007
1008
# elif defined ( TARGET_CRIS )
env -> pc = addr ;
1009
# endif
1010
}
1011
gdb_continue ( s );
1012
return RS_IDLE ;
1013
1014
1015
1016
case 'C' :
s -> signal = strtoul ( p , ( char ** ) & p , 16 );
gdb_continue ( s );
return RS_IDLE ;
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
case 'k' :
/* Kill the target */
fprintf ( stderr , " \n QEMU: Terminated via GDBstub \n " );
exit ( 0 );
case 'D' :
/* Detach packet */
cpu_breakpoint_remove_all ( env );
cpu_watchpoint_remove_all ( env );
gdb_continue ( s );
put_packet ( s , "OK" );
break ;
1028
1029
case 's' :
if ( * p != '\0' ) {
ths
authored
18 years ago
1030
addr = strtoull ( p , ( char ** ) & p , 16 );
1031
# if defined ( TARGET_I386 )
1032
env -> eip = addr ;
1033
# elif defined ( TARGET_PPC )
1034
env -> nip = addr ;
1035
1036
1037
# elif defined ( TARGET_SPARC )
env -> pc = addr ;
env -> npc = addr + 4 ;
1038
1039
# elif defined ( TARGET_ARM )
env -> regs [ 15 ] = addr ;
1040
# elif defined ( TARGET_SH4 )
ths
authored
18 years ago
1041
1042
env -> pc = addr ;
# elif defined ( TARGET_MIPS )
ths
authored
17 years ago
1043
env -> active_tc . PC = addr ;
ths
authored
17 years ago
1044
1045
# elif defined ( TARGET_CRIS )
env -> pc = addr ;
1046
# endif
1047
}
1048
cpu_single_step ( env , sstep_flags );
1049
gdb_continue ( s );
1050
return RS_IDLE ;
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
case 'F' :
{
target_ulong ret ;
target_ulong err ;
ret = strtoull ( p , ( char ** ) & p , 16 );
if ( * p == ',' ) {
p ++ ;
err = strtoull ( p , ( char ** ) & p , 16 );
} else {
err = 0 ;
}
if ( * p == ',' )
p ++ ;
type = * p ;
if ( gdb_current_syscall_cb )
gdb_current_syscall_cb ( s -> env , ret , err );
if ( type == 'C' ) {
put_packet ( s , "T02" );
} else {
1071
gdb_continue ( s );
1072
1073
1074
}
}
break ;
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
case 'g' :
reg_size = cpu_gdb_read_registers ( env , mem_buf );
memtohex ( buf , mem_buf , reg_size );
put_packet ( s , buf );
break ;
case 'G' :
registers = ( void * ) mem_buf ;
len = strlen ( p ) / 2 ;
hextomem (( uint8_t * ) registers , p , len );
cpu_gdb_write_registers ( env , mem_buf , len );
put_packet ( s , "OK" );
break ;
case 'm' :
1088
addr = strtoull ( p , ( char ** ) & p , 16 );
1089
1090
if ( * p == ',' )
p ++ ;
1091
len = strtoull ( p , NULL , 16 );
1092
1093
1094
1095
1096
1097
if ( cpu_memory_rw_debug ( env , addr , mem_buf , len , 0 ) != 0 ) {
put_packet ( s , "E14" );
} else {
memtohex ( buf , mem_buf , len );
put_packet ( s , buf );
}
1098
1099
break ;
case 'M' :
1100
addr = strtoull ( p , ( char ** ) & p , 16 );
1101
1102
if ( * p == ',' )
p ++ ;
1103
len = strtoull ( p , ( char ** ) & p , 16 );
1104
if ( * p == ':' )
1105
1106
1107
p ++ ;
hextomem ( mem_buf , p , len );
if ( cpu_memory_rw_debug ( env , addr , mem_buf , len , 1 ) != 0 )
1108
put_packet ( s , "E14" );
1109
1110
1111
1112
1113
1114
1115
else
put_packet ( s , "OK" );
break ;
case 'Z' :
type = strtoul ( p , ( char ** ) & p , 16 );
if ( * p == ',' )
p ++ ;
1116
addr = strtoull ( p , ( char ** ) & p , 16 );
1117
1118
if ( * p == ',' )
p ++ ;
1119
len = strtoull ( p , ( char ** ) & p , 16 );
1120
1121
1122
switch ( type ) {
case 0 :
case 1 :
1123
1124
1125
if ( cpu_breakpoint_insert ( env , addr ) < 0 )
goto breakpoint_error ;
put_packet ( s , "OK" );
1126
break ;
1127
# ifndef CONFIG_USER_ONLY
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
case 2 :
type = PAGE_WRITE ;
goto insert_watchpoint ;
case 3 :
type = PAGE_READ ;
goto insert_watchpoint ;
case 4 :
type = PAGE_READ | PAGE_WRITE ;
insert_watchpoint :
if ( cpu_watchpoint_insert ( env , addr , type ) < 0 )
1138
1139
goto breakpoint_error ;
put_packet ( s , "OK" );
1140
break ;
1141
# endif
1142
1143
1144
default :
put_packet ( s , "" );
break ;
1145
1146
}
break ;
1147
1148
1149
1150
breakpoint_error :
put_packet ( s , "E22" );
break ;
1151
1152
1153
1154
case 'z' :
type = strtoul ( p , ( char ** ) & p , 16 );
if ( * p == ',' )
p ++ ;
1155
addr = strtoull ( p , ( char ** ) & p , 16 );
1156
1157
if ( * p == ',' )
p ++ ;
1158
len = strtoull ( p , ( char ** ) & p , 16 );
1159
1160
1161
if ( type == 0 || type == 1 ) {
cpu_breakpoint_remove ( env , addr );
put_packet ( s , "OK" );
1162
# ifndef CONFIG_USER_ONLY
1163
} else if ( type >= 2 || type <= 4 ) {
1164
1165
1166
cpu_watchpoint_remove ( env , addr );
put_packet ( s , "OK" );
# endif
1167
} else {
1168
put_packet ( s , "" );
1169
1170
}
break ;
1171
case 'q' :
1172
1173
1174
1175
case 'Q' :
/* parse any 'q' packets here */
if ( ! strcmp ( p , "qemu.sstepbits" )) {
/* Query Breakpoint bit definitions */
1176
1177
1178
1179
snprintf ( buf , sizeof ( buf ), "ENABLE=%x,NOIRQ=%x,NOTIMER=%x" ,
SSTEP_ENABLE ,
SSTEP_NOIRQ ,
SSTEP_NOTIMER );
1180
1181
1182
1183
1184
1185
1186
put_packet ( s , buf );
break ;
} else if ( strncmp ( p , "qemu.sstep" , 10 ) == 0 ) {
/* Display or change the sstep_flags */
p += 10 ;
if ( * p != '=' ) {
/* Display current setting */
1187
snprintf ( buf , sizeof ( buf ), "0x%x" , sstep_flags );
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
put_packet ( s , buf );
break ;
}
p ++ ;
type = strtoul ( p , ( char ** ) & p , 16 );
sstep_flags = type ;
put_packet ( s , "OK" );
break ;
}
# ifdef CONFIG_LINUX_USER
else if ( strncmp ( p , "Offsets" , 7 ) == 0 ) {
1199
1200
TaskState * ts = env -> opaque ;
1201
1202
1203
1204
1205
1206
snprintf ( buf , sizeof ( buf ),
"Text=" TARGET_ABI_FMT_lx ";Data=" TARGET_ABI_FMT_lx
";Bss=" TARGET_ABI_FMT_lx ,
ts -> info -> code_offset ,
ts -> info -> data_offset ,
ts -> info -> data_offset );
1207
1208
1209
1210
put_packet ( s , buf );
break ;
}
# endif
1211
/* Fall through. */
1212
1213
1214
1215
1216
1217
1218
1219
1220
default :
/* put empty packet */
buf [ 0 ] = '\0' ;
put_packet ( s , buf );
break ;
}
return RS_IDLE ;
}
1221
1222
extern void tb_flush ( CPUState * env );
1223
# ifndef CONFIG_USER_ONLY
1224
1225
1226
1227
1228
1229
static void gdb_vm_stopped ( void * opaque , int reason )
{
GDBState * s = opaque ;
char buf [ 256 ];
int ret ;
1230
1231
1232
if ( s -> state == RS_SYSCALL )
return ;
1233
/* disable single step if it was enable */
1234
cpu_single_step ( s -> env , 0 );
1235
1236
if ( reason == EXCP_DEBUG ) {
1237
if ( s -> env -> watchpoint_hit ) {
1238
1239
snprintf ( buf , sizeof ( buf ), "T%02xwatch:" TARGET_FMT_lx ";" ,
SIGTRAP ,
1240
1241
1242
1243
1244
s -> env -> watchpoint [ s -> env -> watchpoint_hit - 1 ]. vaddr );
put_packet ( s , buf );
s -> env -> watchpoint_hit = 0 ;
return ;
}
1245
tb_flush ( s -> env );
1246
ret = SIGTRAP ;
1247
1248
1249
} else if ( reason == EXCP_INTERRUPT ) {
ret = SIGINT ;
} else {
1250
ret = 0 ;
1251
}
1252
1253
1254
snprintf ( buf , sizeof ( buf ), "S%02x" , ret );
put_packet ( s , buf );
}
1255
# endif
1256
1257
1258
/* Send a gdb syscall request .
This accepts limited printf - style format specifiers , specifically :
1259
1260
1261
% x - target_ulong argument printed in hex .
% lx - 64 - bit argument printed in hex .
% s - string pointer ( target_ulong ) and length ( int ) pair . */
1262
1263
1264
1265
1266
1267
void gdb_do_syscall ( gdb_syscall_complete_cb cb , char * fmt , ...)
{
va_list va ;
char buf [ 256 ];
char * p ;
target_ulong addr ;
1268
uint64_t i64 ;
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
GDBState * s ;
s = gdb_syscall_state ;
if ( ! s )
return ;
gdb_current_syscall_cb = cb ;
s -> state = RS_SYSCALL ;
# ifndef CONFIG_USER_ONLY
vm_stop ( EXCP_DEBUG );
# endif
s -> state = RS_IDLE ;
va_start ( va , fmt );
p = buf ;
* ( p ++ ) = 'F' ;
while ( * fmt ) {
if ( * fmt == '%' ) {
fmt ++ ;
switch ( * fmt ++ ) {
case 'x' :
addr = va_arg ( va , target_ulong );
1289
p += snprintf ( p , & buf [ sizeof ( buf )] - p , TARGET_FMT_lx , addr );
1290
break ;
1291
1292
1293
1294
case 'l' :
if ( * ( fmt ++ ) != 'x' )
goto bad_format ;
i64 = va_arg ( va , uint64_t );
1295
p += snprintf ( p , & buf [ sizeof ( buf )] - p , "%" PRIx64 , i64 );
1296
break ;
1297
1298
case 's' :
addr = va_arg ( va , target_ulong );
1299
1300
p += snprintf ( p , & buf [ sizeof ( buf )] - p , TARGET_FMT_lx "/%x" ,
addr , va_arg ( va , int ));
1301
1302
break ;
default :
1303
bad_format :
1304
1305
1306
1307
1308
1309
1310
1311
fprintf ( stderr , "gdbstub: Bad syscall format string '%s' \n " ,
fmt - 1 );
break ;
}
} else {
* ( p ++ ) = * ( fmt ++ );
}
}
1312
* p = 0 ;
1313
1314
1315
1316
1317
1318
1319
1320
1321
va_end ( va );
put_packet ( s , buf );
# ifdef CONFIG_USER_ONLY
gdb_handlesig ( s -> env , 0 );
# else
cpu_interrupt ( s -> env , CPU_INTERRUPT_EXIT );
# endif
}
1322
static void gdb_read_byte ( GDBState * s , int ch )
1323
{
1324
CPUState * env = s -> env ;
1325
int i , csum ;
ths
authored
17 years ago
1326
uint8_t reply ;
1327
1328
# ifndef CONFIG_USER_ONLY
1329
1330
1331
1332
1333
1334
1335
if ( s -> last_packet_len ) {
/* Waiting for a response to the last packet . If we see the start
of a new command then abandon the previous response . */
if ( ch == '-' ) {
# ifdef DEBUG_GDB
printf ( "Got NACK, retransmitting \n " );
# endif
ths
authored
17 years ago
1336
put_buffer ( s , ( uint8_t * ) s -> last_packet , s -> last_packet_len );
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
}
# ifdef DEBUG_GDB
else if ( ch == '+' )
printf ( "Got ACK \n " );
else
printf ( "Got '%c' when expecting ACK/NACK \n " , ch );
# endif
if ( ch == '+' || ch == '$' )
s -> last_packet_len = 0 ;
if ( ch != '$' )
return ;
}
1349
1350
1351
1352
if ( vm_running ) {
/* when the CPU is running , we cannot do anything except stop
it when receiving a char */
vm_stop ( EXCP_INTERRUPT );
ths
authored
18 years ago
1353
} else
1354
# endif
1355
{
1356
1357
1358
1359
1360
switch ( s -> state ) {
case RS_IDLE :
if ( ch == '$' ) {
s -> line_buf_index = 0 ;
s -> state = RS_GETLINE ;
1361
}
1362
break ;
1363
1364
1365
1366
1367
case RS_GETLINE :
if ( ch == '#' ) {
s -> state = RS_CHKSUM1 ;
} else if ( s -> line_buf_index >= sizeof ( s -> line_buf ) - 1 ) {
s -> state = RS_IDLE ;
1368
} else {
1369
s -> line_buf [ s -> line_buf_index ++ ] = ch ;
1370
1371
}
break ;
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
case RS_CHKSUM1 :
s -> line_buf [ s -> line_buf_index ] = '\0' ;
s -> line_csum = fromhex ( ch ) << 4 ;
s -> state = RS_CHKSUM2 ;
break ;
case RS_CHKSUM2 :
s -> line_csum |= fromhex ( ch );
csum = 0 ;
for ( i = 0 ; i < s -> line_buf_index ; i ++ ) {
csum += s -> line_buf [ i ];
}
if ( s -> line_csum != ( csum & 0xff )) {
ths
authored
17 years ago
1384
1385
reply = '-' ;
put_buffer ( s , & reply , 1 );
1386
s -> state = RS_IDLE ;
1387
} else {
ths
authored
17 years ago
1388
1389
reply = '+' ;
put_buffer ( s , & reply , 1 );
1390
s -> state = gdb_handle_packet ( s , env , s -> line_buf );
1391
1392
}
break ;
1393
1394
default :
abort ();
1395
1396
1397
1398
}
}
}
1399
1400
1401
1402
1403
1404
1405
1406
1407
# ifdef CONFIG_USER_ONLY
int
gdb_handlesig ( CPUState * env , int sig )
{
GDBState * s ;
char buf [ 256 ];
int n ;
s = & gdbserver_state ;
1408
1409
if ( gdbserver_fd < 0 || s -> fd < 0 )
return sig ;
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
/* disable single step if it was enabled */
cpu_single_step ( env , 0 );
tb_flush ( env );
if ( sig != 0 )
{
snprintf ( buf , sizeof ( buf ), "S%02x" , sig );
put_packet ( s , buf );
}
1420
1421
1422
1423
/* put_packet () might have detected that the peer terminated the
connection . */
if ( s -> fd < 0 )
return sig ;
1424
1425
1426
sig = 0 ;
s -> state = RS_IDLE ;
1427
1428
s -> running_state = 0 ;
while ( s -> running_state == 0 ) {
1429
1430
1431
1432
1433
1434
n = read ( s -> fd , buf , 256 );
if ( n > 0 )
{
int i ;
for ( i = 0 ; i < n ; i ++ )
1435
gdb_read_byte ( s , buf [ i ]);
1436
1437
1438
1439
1440
1441
1442
}
else if ( n == 0 || errno != EAGAIN )
{
/* XXX : Connection closed . Should probably wait for annother
connection before continuing . */
return sig ;
}
1443
}
1444
1445
sig = s -> signal ;
s -> signal = 0 ;
1446
1447
return sig ;
}
1448
1449
1450
1451
1452
1453
1454
1455
/* Tell the remote gdb that the process has exited. */
void gdb_exit ( CPUState * env , int code )
{
GDBState * s ;
char buf [ 4 ];
s = & gdbserver_state ;
1456
1457
if ( gdbserver_fd < 0 || s -> fd < 0 )
return ;
1458
1459
1460
1461
1462
snprintf ( buf , sizeof ( buf ), "W%02x" , code );
put_packet ( s , buf );
}
1463
1464
static void gdb_accept ( void * opaque )
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
{
GDBState * s ;
struct sockaddr_in sockaddr ;
socklen_t len ;
int val , fd ;
for (;;) {
len = sizeof ( sockaddr );
fd = accept ( gdbserver_fd , ( struct sockaddr * ) & sockaddr , & len );
if ( fd < 0 && errno != EINTR ) {
perror ( "accept" );
return ;
} else if ( fd >= 0 ) {
1478
1479
1480
break ;
}
}
1481
1482
1483
/* set short latency */
val = 1 ;
1484
setsockopt ( fd , IPPROTO_TCP , TCP_NODELAY , ( char * ) & val , sizeof ( val ));
ths
authored
18 years ago
1485
1486
1487
s = & gdbserver_state ;
memset ( s , 0 , sizeof ( GDBState ));
1488
s -> env = first_cpu ; /* XXX: allow to change CPU */
1489
1490
s -> fd = fd ;
1491
1492
gdb_syscall_state = s ;
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
fcntl ( fd , F_SETFL , O_NONBLOCK );
}
static int gdbserver_open ( int port )
{
struct sockaddr_in sockaddr ;
int fd , val , ret ;
fd = socket ( PF_INET , SOCK_STREAM , 0 );
if ( fd < 0 ) {
perror ( "socket" );
return - 1 ;
}
/* allow fast reuse */
val = 1 ;
1509
setsockopt ( fd , SOL_SOCKET , SO_REUSEADDR , ( char * ) & val , sizeof ( val ));
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
sockaddr . sin_family = AF_INET ;
sockaddr . sin_port = htons ( port );
sockaddr . sin_addr . s_addr = 0 ;
ret = bind ( fd , ( struct sockaddr * ) & sockaddr , sizeof ( sockaddr ));
if ( ret < 0 ) {
perror ( "bind" );
return - 1 ;
}
ret = listen ( fd , 0 );
if ( ret < 0 ) {
perror ( "listen" );
return - 1 ;
}
return fd ;
}
int gdbserver_start ( int port )
{
gdbserver_fd = gdbserver_open ( port );
if ( gdbserver_fd < 0 )
return - 1 ;
/* accept connections */
1533
gdb_accept ( NULL );
1534
1535
return 0 ;
}
1536
# else
ths
authored
18 years ago
1537
static int gdb_chr_can_receive ( void * opaque )
1538
1539
1540
1541
{
return 1 ;
}
ths
authored
18 years ago
1542
static void gdb_chr_receive ( void * opaque , const uint8_t * buf , int size )
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
{
GDBState * s = opaque ;
int i ;
for ( i = 0 ; i < size ; i ++ ) {
gdb_read_byte ( s , buf [ i ]);
}
}
static void gdb_chr_event ( void * opaque , int event )
{
switch ( event ) {
case CHR_EVENT_RESET :
vm_stop ( EXCP_INTERRUPT );
1557
gdb_syscall_state = opaque ;
1558
1559
1560
1561
1562
1563
break ;
default :
break ;
}
}
1564
int gdbserver_start ( const char * port )
1565
1566
{
GDBState * s ;
1567
1568
1569
1570
1571
1572
1573
char gdbstub_port_name [ 128 ];
int port_num ;
char * p ;
CharDriverState * chr ;
if ( ! port || !* port )
return - 1 ;
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
port_num = strtol ( port , & p , 10 );
if ( * p == 0 ) {
/* A numeric value is interpreted as a port number. */
snprintf ( gdbstub_port_name , sizeof ( gdbstub_port_name ),
"tcp::%d,nowait,nodelay,server" , port_num );
port = gdbstub_port_name ;
}
chr = qemu_chr_open ( port );
1584
1585
1586
1587
1588
1589
1590
1591
1592
if ( ! chr )
return - 1 ;
s = qemu_mallocz ( sizeof ( GDBState ));
if ( ! s ) {
return - 1 ;
}
s -> env = first_cpu ; /* XXX: allow to change CPU */
s -> chr = chr ;
ths
authored
18 years ago
1593
qemu_chr_add_handlers ( chr , gdb_chr_can_receive , gdb_chr_receive ,
1594
1595
gdb_chr_event , s );
qemu_add_vm_stop_handler ( gdb_vm_stopped , s );
1596
1597
return 0 ;
}
1598
# endif