Blame view

gdbstub.c 37 KB
bellard authored
1
2
/*
 * gdb server stub
3
 *
bellard authored
4
 * Copyright (c) 2003-2005 Fabrice Bellard
bellard authored
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
pbrook authored
32
33
34
35
#include "qemu-common.h"
#include "qemu-char.h"
#include "sysemu.h"
#include "gdbstub.h"
36
#endif
37
bellard authored
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
bellard authored
48
#include <signal.h>
bellard authored
49
#endif
bellard authored
50
bellard authored
51
//#define DEBUG_GDB
bellard authored
52
53
54
55
56
57
enum RSState {
    RS_IDLE,
    RS_GETLINE,
    RS_CHKSUM1,
    RS_CHKSUM2,
pbrook authored
58
    RS_SYSCALL,
59
60
};
typedef struct GDBState {
bellard authored
61
    CPUState *env; /* current CPU */
bellard authored
62
    enum RSState state; /* parsing state */
63
64
65
    char line_buf[4096];
    int line_buf_index;
    int line_csum;
66
    uint8_t last_packet[4100];
67
    int last_packet_len;
bellard authored
68
#ifdef CONFIG_USER_ONLY
69
    int fd;
bellard authored
70
    int running_state;
71
72
#else
    CharDriverState *chr;
bellard authored
73
#endif
74
} GDBState;
bellard authored
75
76
#ifdef CONFIG_USER_ONLY
77
78
79
/* XXX: This is not thread safe.  Do we care?  */
static int gdbserver_fd = -1;
80
81
82
/* XXX: remove this hack.  */
static GDBState gdbserver_state;
83
static int get_char(GDBState *s)
bellard authored
84
85
86
87
88
{
    uint8_t ch;
    int ret;

    for(;;) {
bellard authored
89
        ret = recv(s->fd, &ch, 1, 0);
bellard authored
90
91
92
93
94
95
96
97
98
99
100
        if (ret < 0) {
            if (errno != EINTR && errno != EAGAIN)
                return -1;
        } else if (ret == 0) {
            return -1;
        } else {
            break;
        }
    }
    return ch;
}
101
#endif
bellard authored
102
pbrook authored
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
/* 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;
}
124
static void put_buffer(GDBState *s, const uint8_t *buf, int len)
bellard authored
125
{
126
#ifdef CONFIG_USER_ONLY
bellard authored
127
128
129
    int ret;

    while (len > 0) {
bellard authored
130
        ret = send(s->fd, buf, len, 0);
bellard authored
131
132
133
134
135
136
137
138
        if (ret < 0) {
            if (errno != EINTR && errno != EAGAIN)
                return;
        } else {
            buf += ret;
            len -= ret;
        }
    }
139
140
141
#else
    qemu_chr_write(s->chr, buf, len);
#endif
bellard authored
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
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
}

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 */
188
static int put_packet(GDBState *s, char *buf)
bellard authored
189
{
190
    int len, csum, i;
191
    uint8_t *p;
bellard authored
192
193
194
195
196
197

#ifdef DEBUG_GDB
    printf("reply='%s'\n", buf);
#endif

    for(;;) {
198
199
        p = s->last_packet;
        *(p++) = '$';
bellard authored
200
        len = strlen(buf);
201
202
        memcpy(p, buf, len);
        p += len;
bellard authored
203
204
205
206
        csum = 0;
        for(i = 0; i < len; i++) {
            csum += buf[i];
        }
207
208
209
        *(p++) = '#';
        *(p++) = tohex((csum >> 4) & 0xf);
        *(p++) = tohex((csum) & 0xf);
bellard authored
210
211
        s->last_packet_len = p - s->last_packet;
212
        put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
bellard authored
213
214
215
216
#ifdef CONFIG_USER_ONLY
        i = get_char(s);
        if (i < 0)
bellard authored
217
            return -1;
218
        if (i == '+')
bellard authored
219
            break;
220
221
222
#else
        break;
#endif
bellard authored
223
224
225
226
    }
    return 0;
}
bellard authored
227
228
229
230
231
#if defined(TARGET_I386)

static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
{
    int i, fpus;
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
    uint32_t *registers = (uint32_t *)mem_buf;

#ifdef TARGET_X86_64
    /* This corresponds with amd64_register_info[] in gdb/amd64-tdep.c */
    uint64_t *registers64 = (uint64_t *)mem_buf;

    if (env->hflags & HF_CS64_MASK) {
        registers64[0] = tswap64(env->regs[R_EAX]);
        registers64[1] = tswap64(env->regs[R_EBX]);
        registers64[2] = tswap64(env->regs[R_ECX]);
        registers64[3] = tswap64(env->regs[R_EDX]);
        registers64[4] = tswap64(env->regs[R_ESI]);
        registers64[5] = tswap64(env->regs[R_EDI]);
        registers64[6] = tswap64(env->regs[R_EBP]);
        registers64[7] = tswap64(env->regs[R_ESP]);
        for(i = 8; i < 16; i++) {
            registers64[i] = tswap64(env->regs[i]);
        }
        registers64[16] = tswap64(env->eip);

        registers = (uint32_t *)&registers64[17];
        registers[0] = tswap32(env->eflags);
        registers[1] = tswap32(env->segs[R_CS].selector);
        registers[2] = tswap32(env->segs[R_SS].selector);
        registers[3] = tswap32(env->segs[R_DS].selector);
        registers[4] = tswap32(env->segs[R_ES].selector);
        registers[5] = tswap32(env->segs[R_FS].selector);
        registers[6] = tswap32(env->segs[R_GS].selector);
        /* XXX: convert floats */
        for(i = 0; i < 8; i++) {
            memcpy(mem_buf + 16 * 8 + 7 * 4 + i * 10, &env->fpregs[i], 10);
        }
        registers[27] = tswap32(env->fpuc); /* fctrl */
        fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
        registers[28] = tswap32(fpus); /* fstat */
        registers[29] = 0; /* ftag */
        registers[30] = 0; /* fiseg */
        registers[31] = 0; /* fioff */
        registers[32] = 0; /* foseg */
        registers[33] = 0; /* fooff */
        registers[34] = 0; /* fop */
        for(i = 0; i < 16; i++) {
            memcpy(mem_buf + 16 * 8 + 35 * 4 + i * 16, &env->xmm_regs[i], 16);
        }
        registers[99] = tswap32(env->mxcsr);

        return 8 * 17 + 4 * 7 + 10 * 8 + 4 * 8 + 16 * 16 + 4;
    }
#endif
bellard authored
281
282

    for(i = 0; i < 8; i++) {
283
        registers[i] = env->regs[i];
bellard authored
284
    }
285
286
287
288
289
290
291
292
    registers[8] = env->eip;
    registers[9] = env->eflags;
    registers[10] = env->segs[R_CS].selector;
    registers[11] = env->segs[R_SS].selector;
    registers[12] = env->segs[R_DS].selector;
    registers[13] = env->segs[R_ES].selector;
    registers[14] = env->segs[R_FS].selector;
    registers[15] = env->segs[R_GS].selector;
bellard authored
293
294
295
296
    /* XXX: convert floats */
    for(i = 0; i < 8; i++) {
        memcpy(mem_buf + 16 * 4 + i * 10, &env->fpregs[i], 10);
    }
297
    registers[36] = env->fpuc;
bellard authored
298
    fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
299
300
301
302
303
304
305
    registers[37] = fpus;
    registers[38] = 0; /* XXX: convert tags */
    registers[39] = 0; /* fiseg */
    registers[40] = 0; /* fioff */
    registers[41] = 0; /* foseg */
    registers[42] = 0; /* fooff */
    registers[43] = 0; /* fop */
306
307
308
309
310
    for(i = 0; i < 16; i++)
        tswapls(&registers[i]);
    for(i = 36; i < 44; i++)
        tswapls(&registers[i]);
bellard authored
311
312
313
314
315
316
317
318
319
320
321
    return 44 * 4;
}

static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
{
    uint32_t *registers = (uint32_t *)mem_buf;
    int i;

    for(i = 0; i < 8; i++) {
        env->regs[i] = tswapl(registers[i]);
    }
322
323
    env->eip = tswapl(registers[8]);
    env->eflags = tswapl(registers[9]);
bellard authored
324
325
326
327
328
329
330
331
332
333
334
335
336
#if defined(CONFIG_USER_ONLY)
#define LOAD_SEG(index, sreg)\
            if (tswapl(registers[index]) != env->segs[sreg].selector)\
                cpu_x86_load_seg(env, sreg, tswapl(registers[index]));
            LOAD_SEG(10, R_CS);
            LOAD_SEG(11, R_SS);
            LOAD_SEG(12, R_DS);
            LOAD_SEG(13, R_ES);
            LOAD_SEG(14, R_FS);
            LOAD_SEG(15, R_GS);
#endif
}
bellard authored
337
338
339
#elif defined (TARGET_PPC)
static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
{
340
    uint32_t *registers = (uint32_t *)mem_buf, tmp;
bellard authored
341
342
343
    int i;

    /* fill in gprs */
344
    for(i = 0; i < 32; i++) {
345
        registers[i] = tswapl(env->gpr[i]);
bellard authored
346
347
348
    }
    /* fill in fprs */
    for (i = 0; i < 32; i++) {
349
350
        registers[(i * 2) + 32] = tswapl(*((uint32_t *)&env->fpr[i]));
	registers[(i * 2) + 33] = tswapl(*((uint32_t *)&env->fpr[i] + 1));
bellard authored
351
352
    }
    /* nip, msr, ccr, lnk, ctr, xer, mq */
353
    registers[96] = tswapl(env->nip);
354
    registers[97] = tswapl(env->msr);
bellard authored
355
356
    tmp = 0;
    for (i = 0; i < 8; i++)
357
        tmp |= env->crf[i] << (32 - ((i + 1) * 4));
358
359
360
    registers[98] = tswapl(tmp);
    registers[99] = tswapl(env->lr);
    registers[100] = tswapl(env->ctr);
361
    registers[101] = tswapl(ppc_load_xer(env));
362
    registers[102] = 0;
363
364

    return 103 * 4;
bellard authored
365
366
367
368
369
370
371
372
373
}

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++) {
374
        env->gpr[i] = tswapl(registers[i]);
bellard authored
375
376
377
    }
    /* fill in fprs */
    for (i = 0; i < 32; i++) {
378
379
        *((uint32_t *)&env->fpr[i]) = tswapl(registers[(i * 2) + 32]);
	*((uint32_t *)&env->fpr[i] + 1) = tswapl(registers[(i * 2) + 33]);
bellard authored
380
381
    }
    /* nip, msr, ccr, lnk, ctr, xer, mq */
382
    env->nip = tswapl(registers[96]);
383
    ppc_store_msr(env, tswapl(registers[97]));
384
    registers[98] = tswapl(registers[98]);
bellard authored
385
    for (i = 0; i < 8; i++)
386
        env->crf[i] = (registers[98] >> (32 - ((i + 1) * 4))) & 0xF;
387
388
    env->lr = tswapl(registers[99]);
    env->ctr = tswapl(registers[100]);
389
    ppc_store_xer(env, tswapl(registers[101]));
390
391
392
393
}
#elif defined (TARGET_SPARC)
static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
{
bellard authored
394
    target_ulong *registers = (target_ulong *)mem_buf;
395
396
397
    int i;

    /* fill in g0..g7 */
bellard authored
398
    for(i = 0; i < 8; i++) {
399
400
401
402
403
404
        registers[i] = tswapl(env->gregs[i]);
    }
    /* fill in register window */
    for(i = 0; i < 24; i++) {
        registers[i + 8] = tswapl(env->regwptr[i]);
    }
405
#ifndef TARGET_SPARC64
406
407
408
409
410
411
    /* fill in fprs */
    for (i = 0; i < 32; i++) {
        registers[i + 32] = tswapl(*((uint32_t *)&env->fpr[i]));
    }
    /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
    registers[64] = tswapl(env->y);
bellard authored
412
413
414
415
416
417
    {
	target_ulong tmp;

	tmp = GET_PSR(env);
	registers[65] = tswapl(tmp);
    }
418
419
420
421
422
423
424
    registers[66] = tswapl(env->wim);
    registers[67] = tswapl(env->tbr);
    registers[68] = tswapl(env->pc);
    registers[69] = tswapl(env->npc);
    registers[70] = tswapl(env->fsr);
    registers[71] = 0; /* csr */
    registers[72] = 0;
bellard authored
425
426
    return 73 * sizeof(target_ulong);
#else
427
428
429
430
    /* fill in fprs */
    for (i = 0; i < 64; i += 2) {
	uint64_t tmp;
431
432
433
        tmp = ((uint64_t)*(uint32_t *)&env->fpr[i]) << 32;
        tmp |= *(uint32_t *)&env->fpr[i + 1];
        registers[i / 2 + 32] = tswap64(tmp);
bellard authored
434
    }
435
436
    registers[64] = tswapl(env->pc);
    registers[65] = tswapl(env->npc);
437
438
439
440
    registers[66] = tswapl(((uint64_t)GET_CCR(env) << 32) |
                           ((env->asi & 0xff) << 24) |
                           ((env->pstate & 0xfff) << 8) |
                           GET_CWP64(env));
441
442
443
444
    registers[67] = tswapl(env->fsr);
    registers[68] = tswapl(env->fprs);
    registers[69] = tswapl(env->y);
    return 70 * sizeof(target_ulong);
bellard authored
445
#endif
446
447
448
449
}

static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
{
bellard authored
450
    target_ulong *registers = (target_ulong *)mem_buf;
451
452
453
454
455
456
457
458
    int i;

    /* fill in g0..g7 */
    for(i = 0; i < 7; i++) {
        env->gregs[i] = tswapl(registers[i]);
    }
    /* fill in register window */
    for(i = 0; i < 24; i++) {
bellard authored
459
        env->regwptr[i] = tswapl(registers[i + 8]);
460
    }
461
#ifndef TARGET_SPARC64
462
463
464
465
466
467
    /* fill in fprs */
    for (i = 0; i < 32; i++) {
        *((uint32_t *)&env->fpr[i]) = tswapl(registers[i + 32]);
    }
    /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
    env->y = tswapl(registers[64]);
bellard authored
468
    PUT_PSR(env, tswapl(registers[65]));
469
470
471
472
473
    env->wim = tswapl(registers[66]);
    env->tbr = tswapl(registers[67]);
    env->pc = tswapl(registers[68]);
    env->npc = tswapl(registers[69]);
    env->fsr = tswapl(registers[70]);
bellard authored
474
#else
475
    for (i = 0; i < 64; i += 2) {
476
477
478
479
480
        uint64_t tmp;

        tmp = tswap64(registers[i / 2 + 32]);
	*((uint32_t *)&env->fpr[i]) = tmp >> 32;
	*((uint32_t *)&env->fpr[i + 1]) = tmp & 0xffffffff;
bellard authored
481
    }
482
483
    env->pc = tswapl(registers[64]);
    env->npc = tswapl(registers[65]);
484
485
486
487
488
489
490
491
    {
        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);
    }
492
493
494
    env->fsr = tswapl(registers[67]);
    env->fprs = tswapl(registers[68]);
    env->y = tswapl(registers[69]);
bellard authored
495
#endif
bellard authored
496
}
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
#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).  */
515
    *(uint32_t *)ptr = tswapl (cpsr_read(env));
516
517
518
519
    ptr += 4;

    return ptr - mem_buf;
}
bellard authored
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
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;
535
    cpsr_write (env, tswapl(*(uint32_t *)ptr), 0xffffffff);
536
}
pbrook authored
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
#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++) {
597
        u.l.upper = tswap32(*(uint32_t *)ptr);
pbrook authored
598
599
600
601
602
603
        u.l.lower = tswap32(*(uint32_t *)ptr);
        env->fregs[i] = u.d;
    }
    /* FP control regs (not implemented).  */
    ptr += 3 * 4;
}
604
605
606
607
608
609
610
611
612
#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++)
      {
613
        *(target_ulong *)ptr = tswapl(env->gpr[env->current_tc][i]);
614
        ptr += sizeof(target_ulong);
615
616
      }
ths authored
617
    *(target_ulong *)ptr = (int32_t)tswap32(env->CP0_Status);
618
    ptr += sizeof(target_ulong);
619
620
    *(target_ulong *)ptr = tswapl(env->LO[env->current_tc][0]);
621
    ptr += sizeof(target_ulong);
622
623
    *(target_ulong *)ptr = tswapl(env->HI[env->current_tc][0]);
624
    ptr += sizeof(target_ulong);
625
626
627
    *(target_ulong *)ptr = tswapl(env->CP0_BadVAddr);
    ptr += sizeof(target_ulong);
628
ths authored
629
    *(target_ulong *)ptr = (int32_t)tswap32(env->CP0_Cause);
630
    ptr += sizeof(target_ulong);
631
632
    *(target_ulong *)ptr = tswapl(env->PC[env->current_tc]);
633
    ptr += sizeof(target_ulong);
634
635
    if (env->CP0_Config1 & (1 << CP0C1_FP))
636
      {
637
638
        for (i = 0; i < 32; i++)
          {
ths authored
639
640
641
642
            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]);
643
            ptr += sizeof(target_ulong);
644
          }
645
ths authored
646
        *(target_ulong *)ptr = (int32_t)tswap32(env->fpu->fcr31);
647
        ptr += sizeof(target_ulong);
648
ths authored
649
        *(target_ulong *)ptr = (int32_t)tswap32(env->fpu->fcr0);
650
        ptr += sizeof(target_ulong);
651
      }
652
ths authored
653
654
655
656
657
658
659
660
661
662
663
664
665
666
    /* "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);
667
668
669
670

    return ptr - mem_buf;
}
671
672
673
674
675
676
677
678
679
/* 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 \
680
    set_float_rounding_mode(ieee_rm[env->fpu->fcr31 & 3], &env->fpu->fp_status)
681
682
683
684
685
686
687
688
689
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++)
      {
690
        env->gpr[env->current_tc][i] = tswapl(*(target_ulong *)ptr);
691
        ptr += sizeof(target_ulong);
692
693
      }
694
695
    env->CP0_Status = tswapl(*(target_ulong *)ptr);
    ptr += sizeof(target_ulong);
696
697
    env->LO[env->current_tc][0] = tswapl(*(target_ulong *)ptr);
698
    ptr += sizeof(target_ulong);
699
700
    env->HI[env->current_tc][0] = tswapl(*(target_ulong *)ptr);
701
    ptr += sizeof(target_ulong);
702
703
704
    env->CP0_BadVAddr = tswapl(*(target_ulong *)ptr);
    ptr += sizeof(target_ulong);
705
706
707
    env->CP0_Cause = tswapl(*(target_ulong *)ptr);
    ptr += sizeof(target_ulong);
708
709
    env->PC[env->current_tc] = tswapl(*(target_ulong *)ptr);
710
    ptr += sizeof(target_ulong);
711
712
    if (env->CP0_Config1 & (1 << CP0C1_FP))
713
      {
714
715
        for (i = 0; i < 32; i++)
          {
ths authored
716
717
718
719
            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);
720
            ptr += sizeof(target_ulong);
721
          }
722
ths authored
723
        env->fpu->fcr31 = tswapl(*(target_ulong *)ptr) & 0xFF83FFFF;
724
        ptr += sizeof(target_ulong);
725
ths authored
726
        /* The remaining registers are assumed to be read-only. */
727
728
729
        /* set rounding mode */
        RESTORE_ROUNDING_MODE;
730
731

#ifndef CONFIG_SOFTFLOAT
732
733
        /* no floating point exception for native float */
        SET_FP_ENABLE(env->fcr31, 0);
734
#endif
735
      }
736
}
bellard authored
737
#elif defined (TARGET_SH4)
738
739
740

/* Hint: Use "set architecture sh4" in GDB to see fpu registers */
bellard authored
741
742
743
744
745
746
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)
pbrook authored
747
748
749
750
751
752
  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]);
bellard authored
753
754
755
756
757
758
759
  SAVE (env->pc);
  SAVE (env->pr);
  SAVE (env->gbr);
  SAVE (env->vbr);
  SAVE (env->mach);
  SAVE (env->macl);
  SAVE (env->sr);
760
761
762
763
764
765
766
767
  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]);
bellard authored
768
769
770
771
772
773
774
775
776
  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++;
pbrook authored
777
778
779
780
781
782
  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]);
bellard authored
783
784
785
786
787
788
789
  LOAD (env->pc);
  LOAD (env->pr);
  LOAD (env->gbr);
  LOAD (env->vbr);
  LOAD (env->mach);
  LOAD (env->macl);
  LOAD (env->sr);
790
791
792
793
794
795
796
797
  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]);
bellard authored
798
}
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
#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]);
831
  srs = env->pregs[PR_SRS];
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858

  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);
}
859
#else
bellard authored
860
861
862
863
864
865
866
867
868
869
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
bellard authored
870
871
static int gdb_handle_packet(GDBState *s, CPUState *env, const char *line_buf)
bellard authored
872
873
{
    const char *p;
874
    int ch, reg_size, type;
bellard authored
875
    char buf[4096];
876
    uint8_t mem_buf[4096];
bellard authored
877
    uint32_t *registers;
878
    target_ulong addr, len;
879
880
881
882
883
884
885
886
#ifdef DEBUG_GDB
    printf("command='%s'\n", line_buf);
#endif
    p = line_buf;
    ch = *p++;
    switch(ch) {
    case '?':
887
        /* TODO: Make this return the correct value for user-mode.  */
888
889
890
891
892
        snprintf(buf, sizeof(buf), "S%02x", SIGTRAP);
        put_packet(s, buf);
        break;
    case 'c':
        if (*p != '\0') {
893
            addr = strtoull(p, (char **)&p, 16);
bellard authored
894
#if defined(TARGET_I386)
895
            env->eip = addr;
bellard authored
896
#elif defined (TARGET_PPC)
897
            env->nip = addr;
bellard authored
898
899
900
#elif defined (TARGET_SPARC)
            env->pc = addr;
            env->npc = addr + 4;
901
902
#elif defined (TARGET_ARM)
            env->regs[15] = addr;
bellard authored
903
#elif defined (TARGET_SH4)
904
905
            env->pc = addr;
#elif defined (TARGET_MIPS)
906
            env->PC[env->current_tc] = addr;
907
908
#elif defined (TARGET_CRIS)
            env->pc = addr;
bellard authored
909
#endif
910
        }
bellard authored
911
912
913
914
915
916
#ifdef CONFIG_USER_ONLY
        s->running_state = 1;
#else
        vm_start();
#endif
	return RS_IDLE;
917
918
    case 's':
        if (*p != '\0') {
919
            addr = strtoull(p, (char **)&p, 16);
920
#if defined(TARGET_I386)
921
            env->eip = addr;
bellard authored
922
#elif defined (TARGET_PPC)
923
            env->nip = addr;
bellard authored
924
925
926
#elif defined (TARGET_SPARC)
            env->pc = addr;
            env->npc = addr + 4;
927
928
#elif defined (TARGET_ARM)
            env->regs[15] = addr;
bellard authored
929
#elif defined (TARGET_SH4)
930
931
            env->pc = addr;
#elif defined (TARGET_MIPS)
932
            env->PC[env->current_tc] = addr;
933
934
#elif defined (TARGET_CRIS)
            env->pc = addr;
935
#endif
936
937
        }
        cpu_single_step(env, 1);
bellard authored
938
939
940
941
942
943
#ifdef CONFIG_USER_ONLY
        s->running_state = 1;
#else
        vm_start();
#endif
	return RS_IDLE;
pbrook authored
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
    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 {
#ifdef CONFIG_USER_ONLY
                s->running_state = 1;
#else
                vm_start();
#endif
            }
        }
        break;
972
973
974
975
976
977
978
979
980
981
982
983
984
    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':
985
        addr = strtoull(p, (char **)&p, 16);
986
987
        if (*p == ',')
            p++;
988
        len = strtoull(p, NULL, 16);
989
990
991
992
993
994
        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);
        }
995
996
        break;
    case 'M':
997
        addr = strtoull(p, (char **)&p, 16);
998
999
        if (*p == ',')
            p++;
1000
        len = strtoull(p, (char **)&p, 16);
1001
        if (*p == ':')
1002
1003
1004
            p++;
        hextomem(mem_buf, p, len);
        if (cpu_memory_rw_debug(env, addr, mem_buf, len, 1) != 0)
1005
            put_packet(s, "E14");
1006
1007
1008
1009
1010
1011
1012
        else
            put_packet(s, "OK");
        break;
    case 'Z':
        type = strtoul(p, (char **)&p, 16);
        if (*p == ',')
            p++;
1013
        addr = strtoull(p, (char **)&p, 16);
1014
1015
        if (*p == ',')
            p++;
1016
        len = strtoull(p, (char **)&p, 16);
1017
1018
1019
1020
        if (type == 0 || type == 1) {
            if (cpu_breakpoint_insert(env, addr) < 0)
                goto breakpoint_error;
            put_packet(s, "OK");
1021
1022
1023
1024
1025
1026
#ifndef CONFIG_USER_ONLY
        } else if (type == 2) {
            if (cpu_watchpoint_insert(env, addr) < 0)
                goto breakpoint_error;
            put_packet(s, "OK");
#endif
1027
1028
        } else {
        breakpoint_error:
1029
            put_packet(s, "E22");
1030
1031
1032
1033
1034
1035
        }
        break;
    case 'z':
        type = strtoul(p, (char **)&p, 16);
        if (*p == ',')
            p++;
1036
        addr = strtoull(p, (char **)&p, 16);
1037
1038
        if (*p == ',')
            p++;
1039
        len = strtoull(p, (char **)&p, 16);
1040
1041
1042
        if (type == 0 || type == 1) {
            cpu_breakpoint_remove(env, addr);
            put_packet(s, "OK");
1043
1044
1045
1046
1047
#ifndef CONFIG_USER_ONLY
        } else if (type == 2) {
            cpu_watchpoint_remove(env, addr);
            put_packet(s, "OK");
#endif
1048
1049
1050
1051
        } else {
            goto breakpoint_error;
        }
        break;
1052
#ifdef CONFIG_LINUX_USER
1053
1054
1055
1056
    case 'q':
        if (strncmp(p, "Offsets", 7) == 0) {
            TaskState *ts = env->opaque;
1057
            sprintf(buf,
pbrook authored
1058
1059
                    "Text=" TARGET_ABI_FMT_lx ";Data=" TARGET_ABI_FMT_lx
                    ";Bss=" TARGET_ABI_FMT_lx,
1060
1061
1062
                    ts->info->code_offset,
                    ts->info->data_offset,
                    ts->info->data_offset);
1063
1064
1065
1066
1067
            put_packet(s, buf);
            break;
        }
        /* Fall through.  */
#endif
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
    default:
        //        unknown_command:
        /* put empty packet */
        buf[0] = '\0';
        put_packet(s, buf);
        break;
    }
    return RS_IDLE;
}
bellard authored
1078
1079
extern void tb_flush(CPUState *env);
1080
#ifndef CONFIG_USER_ONLY
1081
1082
1083
1084
1085
1086
static void gdb_vm_stopped(void *opaque, int reason)
{
    GDBState *s = opaque;
    char buf[256];
    int ret;
pbrook authored
1087
1088
1089
    if (s->state == RS_SYSCALL)
        return;
1090
    /* disable single step if it was enable */
bellard authored
1091
    cpu_single_step(s->env, 0);
1092
bellard authored
1093
    if (reason == EXCP_DEBUG) {
1094
        if (s->env->watchpoint_hit) {
1095
1096
            snprintf(buf, sizeof(buf), "T%02xwatch:" TARGET_FMT_lx ";",
                     SIGTRAP,
1097
1098
1099
1100
1101
                     s->env->watchpoint[s->env->watchpoint_hit - 1].vaddr);
            put_packet(s, buf);
            s->env->watchpoint_hit = 0;
            return;
        }
bellard authored
1102
	tb_flush(s->env);
1103
        ret = SIGTRAP;
1104
1105
1106
    } else if (reason == EXCP_INTERRUPT) {
        ret = SIGINT;
    } else {
1107
        ret = 0;
1108
    }
1109
1110
1111
    snprintf(buf, sizeof(buf), "S%02x", ret);
    put_packet(s, buf);
}
1112
#endif
1113
pbrook authored
1114
1115
/* Send a gdb syscall request.
   This accepts limited printf-style format specifiers, specifically:
pbrook authored
1116
1117
1118
    %x  - target_ulong argument printed in hex.
    %lx - 64-bit argument printed in hex.
    %s  - string pointer (target_ulong) and length (int) pair.  */
pbrook authored
1119
1120
1121
1122
1123
1124
void gdb_do_syscall(gdb_syscall_complete_cb cb, char *fmt, ...)
{
    va_list va;
    char buf[256];
    char *p;
    target_ulong addr;
pbrook authored
1125
    uint64_t i64;
pbrook authored
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
    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);
                p += sprintf(p, TARGET_FMT_lx, addr);
                break;
pbrook authored
1148
1149
1150
1151
1152
1153
            case 'l':
                if (*(fmt++) != 'x')
                    goto bad_format;
                i64 = va_arg(va, uint64_t);
                p += sprintf(p, "%" PRIx64, i64);
                break;
pbrook authored
1154
1155
1156
1157
1158
            case 's':
                addr = va_arg(va, target_ulong);
                p += sprintf(p, TARGET_FMT_lx "/%x", addr, va_arg(va, int));
                break;
            default:
pbrook authored
1159
            bad_format:
pbrook authored
1160
1161
1162
1163
1164
1165
1166
1167
                fprintf(stderr, "gdbstub: Bad syscall format string '%s'\n",
                        fmt - 1);
                break;
            }
        } else {
            *(p++) = *(fmt++);
        }
    }
1168
    *p = 0;
pbrook authored
1169
1170
1171
1172
1173
1174
1175
1176
1177
    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
}
bellard authored
1178
static void gdb_read_byte(GDBState *s, int ch)
1179
{
bellard authored
1180
    CPUState *env = s->env;
1181
    int i, csum;
1182
    uint8_t reply;
1183
1184
#ifndef CONFIG_USER_ONLY
1185
1186
1187
1188
1189
1190
1191
    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
1192
            put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
        }
#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;
    }
1205
1206
1207
1208
    if (vm_running) {
        /* when the CPU is running, we cannot do anything except stop
           it when receiving a char */
        vm_stop(EXCP_INTERRUPT);
1209
    } else
1210
#endif
bellard authored
1211
    {
1212
1213
1214
1215
1216
        switch(s->state) {
        case RS_IDLE:
            if (ch == '$') {
                s->line_buf_index = 0;
                s->state = RS_GETLINE;
1217
            }
bellard authored
1218
            break;
1219
1220
1221
1222
1223
        case RS_GETLINE:
            if (ch == '#') {
            s->state = RS_CHKSUM1;
            } else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {
                s->state = RS_IDLE;
bellard authored
1224
            } else {
1225
            s->line_buf[s->line_buf_index++] = ch;
bellard authored
1226
1227
            }
            break;
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
        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)) {
1240
1241
                reply = '-';
                put_buffer(s, &reply, 1);
1242
                s->state = RS_IDLE;
bellard authored
1243
            } else {
1244
1245
                reply = '+';
                put_buffer(s, &reply, 1);
1246
                s->state = gdb_handle_packet(s, env, s->line_buf);
bellard authored
1247
1248
            }
            break;
pbrook authored
1249
1250
        default:
            abort();
1251
1252
1253
1254
        }
    }
}
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
#ifdef CONFIG_USER_ONLY
int
gdb_handlesig (CPUState *env, int sig)
{
  GDBState *s;
  char buf[256];
  int n;

  if (gdbserver_fd < 0)
    return sig;

  s = &gdbserver_state;

  /* 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);
    }

  sig = 0;
  s->state = RS_IDLE;
bellard authored
1280
1281
  s->running_state = 0;
  while (s->running_state == 0) {
1282
1283
1284
1285
1286
1287
      n = read (s->fd, buf, 256);
      if (n > 0)
        {
          int i;

          for (i = 0; i < n; i++)
bellard authored
1288
            gdb_read_byte (s, buf[i]);
1289
1290
1291
1292
1293
1294
1295
        }
      else if (n == 0 || errno != EAGAIN)
        {
          /* XXX: Connection closed.  Should probably wait for annother
             connection before continuing.  */
          return sig;
        }
bellard authored
1296
  }
1297
1298
  return sig;
}
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314

/* Tell the remote gdb that the process has exited.  */
void gdb_exit(CPUState *env, int code)
{
  GDBState *s;
  char buf[4];

  if (gdbserver_fd < 0)
    return;

  s = &gdbserver_state;

  snprintf(buf, sizeof(buf), "W%02x", code);
  put_packet(s, buf);
}
1315
bellard authored
1316
static void gdb_accept(void *opaque)
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
{
    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) {
bellard authored
1330
1331
1332
            break;
        }
    }
1333
1334
1335

    /* set short latency */
    val = 1;
bellard authored
1336
    setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *)&val, sizeof(val));
1337
1338
1339
    s = &gdbserver_state;
    memset (s, 0, sizeof (GDBState));
bellard authored
1340
    s->env = first_cpu; /* XXX: allow to change CPU */
1341
1342
    s->fd = fd;
pbrook authored
1343
1344
    gdb_syscall_state = s;
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
    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;
bellard authored
1361
    setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *)&val, sizeof(val));
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384

    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 */
bellard authored
1385
    gdb_accept (NULL);
1386
1387
    return 0;
}
1388
#else
ths authored
1389
static int gdb_chr_can_receive(void *opaque)
1390
1391
1392
1393
{
  return 1;
}
ths authored
1394
static void gdb_chr_receive(void *opaque, const uint8_t *buf, int size)
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
{
    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);
pbrook authored
1409
        gdb_syscall_state = opaque;
1410
1411
1412
1413
1414
1415
        break;
    default:
        break;
    }
}
1416
int gdbserver_start(const char *port)
1417
1418
{
    GDBState *s;
1419
1420
1421
1422
1423
1424
1425
    char gdbstub_port_name[128];
    int port_num;
    char *p;
    CharDriverState *chr;

    if (!port || !*port)
      return -1;
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
    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);
1436
1437
1438
1439
1440
1441
1442
1443
1444
    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
1445
    qemu_chr_add_handlers(chr, gdb_chr_can_receive, gdb_chr_receive,
1446
1447
                          gdb_chr_event, s);
    qemu_add_vm_stop_handler(gdb_vm_stopped, s);
bellard authored
1448
1449
    return 0;
}
1450
#endif