OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [gdb/] [remote-m32r-sdi.c] - Blame information for rev 842

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* Remote debugging interface for M32R/SDI.
2
 
3
   Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4
   Free Software Foundation, Inc.
5
 
6
   Contributed by Renesas Technology Co.
7
   Written by Kei Sakamoto <sakamoto.kei@renesas.com>.
8
 
9
   This file is part of GDB.
10
 
11
   This program is free software; you can redistribute it and/or modify
12
   it under the terms of the GNU General Public License as published by
13
   the Free Software Foundation; either version 3 of the License, or
14
   (at your option) any later version.
15
 
16
   This program is distributed in the hope that it will be useful,
17
   but WITHOUT ANY WARRANTY; without even the implied warranty of
18
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19
   GNU General Public License for more details.
20
 
21
   You should have received a copy of the GNU General Public License
22
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
23
 
24
#include "defs.h"
25
#include "gdbcmd.h"
26
#include "gdbcore.h"
27
#include "inferior.h"
28
#include "target.h"
29
#include "regcache.h"
30
#include "gdb_string.h"
31
#include "gdbthread.h"
32
#include <ctype.h>
33
#include <signal.h>
34
#ifdef __MINGW32__
35
#include <winsock.h>
36
#else
37
#include <netinet/in.h>
38
#endif
39
#include <sys/types.h>
40
#include <sys/time.h>
41
#include <signal.h>
42
#include <time.h>
43
 
44
 
45
#include "serial.h"
46
 
47
/* Descriptor for I/O to remote machine.  */
48
 
49
static struct serial *sdi_desc = NULL;
50
 
51
#define SDI_TIMEOUT 30
52
 
53
 
54
#define SDIPORT 3232
55
 
56
static char chip_name[64];
57
 
58
static int step_mode;
59
static unsigned long last_pc_addr = 0xffffffff;
60
static unsigned char last_pc_addr_data[2];
61
 
62
static int mmu_on = 0;
63
 
64
static int use_ib_breakpoints = 1;
65
 
66
#define MAX_BREAKPOINTS 1024
67
static int max_ib_breakpoints;
68
static unsigned long bp_address[MAX_BREAKPOINTS];
69
static unsigned char bp_data[MAX_BREAKPOINTS][4];
70
 
71
/* dbt -> nop */
72
static const unsigned char dbt_bp_entry[] = {
73
  0x10, 0xe0, 0x70, 0x00
74
};
75
 
76
#define MAX_ACCESS_BREAKS 4
77
static int max_access_breaks;
78
static unsigned long ab_address[MAX_ACCESS_BREAKS];
79
static unsigned int ab_type[MAX_ACCESS_BREAKS];
80
static unsigned int ab_size[MAX_ACCESS_BREAKS];
81
static CORE_ADDR hit_watchpoint_addr = 0;
82
 
83
static int interrupted = 0;
84
 
85
/* Forward data declarations */
86
extern struct target_ops m32r_ops;
87
 
88
/* This is the ptid we use while we're connected to the remote.  Its
89
   value is arbitrary, as the target doesn't have a notion of
90
   processes or threads, but we need something non-null to place in
91
   inferior_ptid.  */
92
static ptid_t remote_m32r_ptid;
93
 
94
/* Commands */
95
#define SDI_OPEN                 1
96
#define SDI_CLOSE                2
97
#define SDI_RELEASE              3
98
#define SDI_READ_CPU_REG         4
99
#define SDI_WRITE_CPU_REG        5
100
#define SDI_READ_MEMORY          6
101
#define SDI_WRITE_MEMORY         7
102
#define SDI_EXEC_CPU             8
103
#define SDI_STOP_CPU             9
104
#define SDI_WAIT_FOR_READY      10
105
#define SDI_GET_ATTR            11
106
#define SDI_SET_ATTR            12
107
#define SDI_STATUS              13
108
 
109
/* Attributes */
110
#define SDI_ATTR_NAME            1
111
#define SDI_ATTR_BRK             2
112
#define SDI_ATTR_ABRK            3
113
#define SDI_ATTR_CACHE           4
114
#define SDI_CACHE_TYPE_M32102    0
115
#define SDI_CACHE_TYPE_CHAOS     1
116
#define SDI_ATTR_MEM_ACCESS      5
117
#define SDI_MEM_ACCESS_DEBUG_DMA 0
118
#define SDI_MEM_ACCESS_MON_CODE  1
119
 
120
/* Registers */
121
#define SDI_REG_R0               0
122
#define SDI_REG_R1               1
123
#define SDI_REG_R2               2
124
#define SDI_REG_R3               3
125
#define SDI_REG_R4               4
126
#define SDI_REG_R5               5
127
#define SDI_REG_R6               6
128
#define SDI_REG_R7               7
129
#define SDI_REG_R8               8
130
#define SDI_REG_R9               9
131
#define SDI_REG_R10             10
132
#define SDI_REG_R11             11
133
#define SDI_REG_R12             12
134
#define SDI_REG_FP              13
135
#define SDI_REG_LR              14
136
#define SDI_REG_SP              15
137
#define SDI_REG_PSW             16
138
#define SDI_REG_CBR             17
139
#define SDI_REG_SPI             18
140
#define SDI_REG_SPU             19
141
#define SDI_REG_CR4             20
142
#define SDI_REG_EVB             21
143
#define SDI_REG_BPC             22
144
#define SDI_REG_CR7             23
145
#define SDI_REG_BBPSW           24
146
#define SDI_REG_CR9             25
147
#define SDI_REG_CR10            26
148
#define SDI_REG_CR11            27
149
#define SDI_REG_CR12            28
150
#define SDI_REG_WR              29
151
#define SDI_REG_BBPC            30
152
#define SDI_REG_PBP             31
153
#define SDI_REG_ACCH            32
154
#define SDI_REG_ACCL            33
155
#define SDI_REG_ACC1H           34
156
#define SDI_REG_ACC1L           35
157
 
158
 
159
/* Low level communication functions */
160
 
161
/* Check an ack packet from the target */
162
static int
163
get_ack (void)
164
{
165
  int c;
166
 
167
  if (!sdi_desc)
168
    return -1;
169
 
170
  c = serial_readchar (sdi_desc, SDI_TIMEOUT);
171
 
172
  if (c < 0)
173
    return -1;
174
 
175
  if (c != '+')                 /* error */
176
    return -1;
177
 
178
  return 0;
179
}
180
 
181
/* Send data to the target and check an ack packet */
182
static int
183
send_data (void *buf, int len)
184
{
185
  int ret;
186
 
187
  if (!sdi_desc)
188
    return -1;
189
 
190
  if (serial_write (sdi_desc, buf, len) != 0)
191
    return -1;
192
 
193
  if (get_ack () == -1)
194
    return -1;
195
 
196
  return len;
197
}
198
 
199
/* Receive data from the target */
200
static int
201
recv_data (void *buf, int len)
202
{
203
  int total = 0;
204
  int c;
205
 
206
  if (!sdi_desc)
207
    return -1;
208
 
209
  while (total < len)
210
    {
211
      c = serial_readchar (sdi_desc, SDI_TIMEOUT);
212
 
213
      if (c < 0)
214
        return -1;
215
 
216
      ((unsigned char *) buf)[total++] = c;
217
    }
218
 
219
  return len;
220
}
221
 
222
/* Store unsigned long parameter on packet */
223
static void
224
store_long_parameter (void *buf, long val)
225
{
226
  val = htonl (val);
227
  memcpy (buf, &val, 4);
228
}
229
 
230
static int
231
send_cmd (unsigned char cmd)
232
{
233
  unsigned char buf[1];
234
  buf[0] = cmd;
235
  return send_data (buf, 1);
236
}
237
 
238
static int
239
send_one_arg_cmd (unsigned char cmd, unsigned char arg1)
240
{
241
  unsigned char buf[2];
242
  buf[0] = cmd;
243
  buf[1] = arg1;
244
  return send_data (buf, 2);
245
}
246
 
247
static int
248
send_two_arg_cmd (unsigned char cmd, unsigned char arg1, unsigned long arg2)
249
{
250
  unsigned char buf[6];
251
  buf[0] = cmd;
252
  buf[1] = arg1;
253
  store_long_parameter (buf + 2, arg2);
254
  return send_data (buf, 6);
255
}
256
 
257
static int
258
send_three_arg_cmd (unsigned char cmd, unsigned long arg1, unsigned long arg2,
259
                    unsigned long arg3)
260
{
261
  unsigned char buf[13];
262
  buf[0] = cmd;
263
  store_long_parameter (buf + 1, arg1);
264
  store_long_parameter (buf + 5, arg2);
265
  store_long_parameter (buf + 9, arg3);
266
  return send_data (buf, 13);
267
}
268
 
269
static unsigned char
270
recv_char_data (void)
271
{
272
  unsigned char val;
273
  recv_data (&val, 1);
274
  return val;
275
}
276
 
277
static unsigned long
278
recv_long_data (void)
279
{
280
  unsigned long val;
281
  recv_data (&val, 4);
282
  return ntohl (val);
283
}
284
 
285
 
286
/* Check if MMU is on */
287
static void
288
check_mmu_status (void)
289
{
290
  unsigned long val;
291
 
292
  /* Read PC address */
293
  if (send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_BPC) == -1)
294
    return;
295
  val = recv_long_data ();
296
  if ((val & 0xc0000000) == 0x80000000)
297
    {
298
      mmu_on = 1;
299
      return;
300
    }
301
 
302
  /* Read EVB address */
303
  if (send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_EVB) == -1)
304
    return;
305
  val = recv_long_data ();
306
  if ((val & 0xc0000000) == 0x80000000)
307
    {
308
      mmu_on = 1;
309
      return;
310
    }
311
 
312
  mmu_on = 0;
313
}
314
 
315
 
316
/* This is called not only when we first attach, but also when the
317
   user types "run" after having attached.  */
318
static void
319
m32r_create_inferior (struct target_ops *ops, char *execfile,
320
                      char *args, char **env, int from_tty)
321
{
322
  CORE_ADDR entry_pt;
323
 
324
  if (args && *args)
325
    error (_("Cannot pass arguments to remote STDEBUG process"));
326
 
327
  if (execfile == 0 || exec_bfd == 0)
328
    error (_("No executable file specified"));
329
 
330
  if (remote_debug)
331
    fprintf_unfiltered (gdb_stdlog, "m32r_create_inferior(%s,%s)\n", execfile,
332
                        args);
333
 
334
  entry_pt = bfd_get_start_address (exec_bfd);
335
 
336
  /* The "process" (board) is already stopped awaiting our commands, and
337
     the program is already downloaded.  We just set its PC and go.  */
338
 
339
  clear_proceed_status ();
340
 
341
  /* Tell wait_for_inferior that we've started a new process.  */
342
  init_wait_for_inferior ();
343
 
344
  /* Set up the "saved terminal modes" of the inferior
345
     based on what modes we are starting it with.  */
346
  target_terminal_init ();
347
 
348
  /* Install inferior's terminal modes.  */
349
  target_terminal_inferior ();
350
 
351
  regcache_write_pc (get_current_regcache (), entry_pt);
352
}
353
 
354
/* Open a connection to a remote debugger.
355
   NAME is the filename used for communication.  */
356
 
357
static void
358
m32r_open (char *args, int from_tty)
359
{
360
  struct hostent *host_ent;
361
  struct sockaddr_in server_addr;
362
  char *port_str, hostname[256];
363
  int port;
364
  int i, n;
365
  int yes = 1;
366
 
367
  if (remote_debug)
368
    fprintf_unfiltered (gdb_stdlog, "m32r_open(%d)\n", from_tty);
369
 
370
  target_preopen (from_tty);
371
 
372
  push_target (&m32r_ops);
373
 
374
  if (args == NULL)
375
    sprintf (hostname, "localhost:%d", SDIPORT);
376
  else
377
    {
378
      port_str = strchr (args, ':');
379
      if (port_str == NULL)
380
        sprintf (hostname, "%s:%d", args, SDIPORT);
381
      else
382
        strcpy (hostname, args);
383
    }
384
 
385
  sdi_desc = serial_open (hostname);
386
  if (!sdi_desc)
387
    error (_("Connection refused."));
388
 
389
  if (get_ack () == -1)
390
    error (_("Cannot connect to SDI target."));
391
 
392
  if (send_cmd (SDI_OPEN) == -1)
393
    error (_("Cannot connect to SDI target."));
394
 
395
  /* Get maximum number of ib breakpoints */
396
  send_one_arg_cmd (SDI_GET_ATTR, SDI_ATTR_BRK);
397
  max_ib_breakpoints = recv_char_data ();
398
  if (remote_debug)
399
    printf_filtered ("Max IB Breakpoints = %d\n", max_ib_breakpoints);
400
 
401
  /* Initialize breakpoints. */
402
  for (i = 0; i < MAX_BREAKPOINTS; i++)
403
    bp_address[i] = 0xffffffff;
404
 
405
  /* Get maximum number of access breaks. */
406
  send_one_arg_cmd (SDI_GET_ATTR, SDI_ATTR_ABRK);
407
  max_access_breaks = recv_char_data ();
408
  if (remote_debug)
409
    printf_filtered ("Max Access Breaks = %d\n", max_access_breaks);
410
 
411
  /* Initialize access breask. */
412
  for (i = 0; i < MAX_ACCESS_BREAKS; i++)
413
    ab_address[i] = 0x00000000;
414
 
415
  check_mmu_status ();
416
 
417
  /* Get the name of chip on target board. */
418
  send_one_arg_cmd (SDI_GET_ATTR, SDI_ATTR_NAME);
419
  recv_data (chip_name, 64);
420
 
421
  if (from_tty)
422
    printf_filtered ("Remote %s connected to %s\n", target_shortname,
423
                     chip_name);
424
}
425
 
426
/* Close out all files and local state before this target loses control. */
427
 
428
static void
429
m32r_close (int quitting)
430
{
431
  if (remote_debug)
432
    fprintf_unfiltered (gdb_stdlog, "m32r_close(%d)\n", quitting);
433
 
434
  if (sdi_desc)
435
    {
436
      send_cmd (SDI_CLOSE);
437
      serial_close (sdi_desc);
438
      sdi_desc = NULL;
439
    }
440
 
441
  inferior_ptid = null_ptid;
442
  delete_thread_silent (remote_m32r_ptid);
443
  return;
444
}
445
 
446
/* Tell the remote machine to resume.  */
447
 
448
static void
449
m32r_resume (struct target_ops *ops,
450
             ptid_t ptid, int step, enum target_signal sig)
451
{
452
  unsigned long pc_addr, bp_addr, ab_addr;
453
  int ib_breakpoints;
454
  unsigned char buf[13];
455
  int i;
456
 
457
  if (remote_debug)
458
    {
459
      if (step)
460
        fprintf_unfiltered (gdb_stdlog, "\nm32r_resume(step)\n");
461
      else
462
        fprintf_unfiltered (gdb_stdlog, "\nm32r_resume(cont)\n");
463
    }
464
 
465
  check_mmu_status ();
466
 
467
  pc_addr = regcache_read_pc (get_current_regcache ());
468
  if (remote_debug)
469
    fprintf_unfiltered (gdb_stdlog, "pc <= 0x%lx\n", pc_addr);
470
 
471
  /* At pc address there is a parallel instruction with +2 offset,
472
     so we have to make it a serial instruction or avoid it. */
473
  if (pc_addr == last_pc_addr)
474
    {
475
      /* Avoid a parallel nop. */
476
      if (last_pc_addr_data[0] == 0xf0 && last_pc_addr_data[1] == 0x00)
477
        {
478
          pc_addr += 2;
479
          /* Now we can forget this instruction. */
480
          last_pc_addr = 0xffffffff;
481
        }
482
      /* Clear a parallel bit. */
483
      else
484
        {
485
          buf[0] = SDI_WRITE_MEMORY;
486
          if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
487
            store_long_parameter (buf + 1, pc_addr);
488
          else
489
            store_long_parameter (buf + 1, pc_addr - 1);
490
          store_long_parameter (buf + 5, 1);
491
          buf[9] = last_pc_addr_data[0] & 0x7f;
492
          send_data (buf, 10);
493
        }
494
    }
495
 
496
  /* Set PC. */
497
  send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_BPC, pc_addr);
498
 
499
  /* step mode. */
500
  step_mode = step;
501
  if (step)
502
    {
503
      /* Set PBP. */
504
      send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_PBP, pc_addr | 1);
505
    }
506
  else
507
    {
508
      /* Unset PBP. */
509
      send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_PBP, 0x00000000);
510
    }
511
 
512
  if (use_ib_breakpoints)
513
    ib_breakpoints = max_ib_breakpoints;
514
  else
515
    ib_breakpoints = 0;
516
 
517
  /* Set ib breakpoints. */
518
  for (i = 0; i < ib_breakpoints; i++)
519
    {
520
      bp_addr = bp_address[i];
521
 
522
      if (bp_addr == 0xffffffff)
523
        continue;
524
 
525
      /* Set PBP. */
526
      if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
527
        send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8000 + 4 * i, 4,
528
                            0x00000006);
529
      else
530
        send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8000 + 4 * i, 4,
531
                            0x06000000);
532
 
533
      send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8080 + 4 * i, 4, bp_addr);
534
    }
535
 
536
  /* Set dbt breakpoints. */
537
  for (i = ib_breakpoints; i < MAX_BREAKPOINTS; i++)
538
    {
539
      bp_addr = bp_address[i];
540
 
541
      if (bp_addr == 0xffffffff)
542
        continue;
543
 
544
      if (!mmu_on)
545
        bp_addr &= 0x7fffffff;
546
 
547
      /* Write DBT instruction. */
548
      buf[0] = SDI_WRITE_MEMORY;
549
      store_long_parameter (buf + 1, (bp_addr & 0xfffffffc));
550
      store_long_parameter (buf + 5, 4);
551
      if ((bp_addr & 2) == 0 && bp_addr != (pc_addr & 0xfffffffc))
552
        {
553
          if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
554
            {
555
              buf[9] = dbt_bp_entry[0];
556
              buf[10] = dbt_bp_entry[1];
557
              buf[11] = dbt_bp_entry[2];
558
              buf[12] = dbt_bp_entry[3];
559
            }
560
          else
561
            {
562
              buf[9] = dbt_bp_entry[3];
563
              buf[10] = dbt_bp_entry[2];
564
              buf[11] = dbt_bp_entry[1];
565
              buf[12] = dbt_bp_entry[0];
566
            }
567
        }
568
      else
569
        {
570
          if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
571
            {
572
              if ((bp_addr & 2) == 0)
573
                {
574
                  buf[9] = dbt_bp_entry[0];
575
                  buf[10] = dbt_bp_entry[1];
576
                  buf[11] = bp_data[i][2] & 0x7f;
577
                  buf[12] = bp_data[i][3];
578
                }
579
              else
580
                {
581
                  buf[9] = bp_data[i][0];
582
                  buf[10] = bp_data[i][1];
583
                  buf[11] = dbt_bp_entry[0];
584
                  buf[12] = dbt_bp_entry[1];
585
                }
586
            }
587
          else
588
            {
589
              if ((bp_addr & 2) == 0)
590
                {
591
                  buf[9] = bp_data[i][0];
592
                  buf[10] = bp_data[i][1] & 0x7f;
593
                  buf[11] = dbt_bp_entry[1];
594
                  buf[12] = dbt_bp_entry[0];
595
                }
596
              else
597
                {
598
                  buf[9] = dbt_bp_entry[1];
599
                  buf[10] = dbt_bp_entry[0];
600
                  buf[11] = bp_data[i][2];
601
                  buf[12] = bp_data[i][3];
602
                }
603
            }
604
        }
605
      send_data (buf, 13);
606
    }
607
 
608
  /* Set access breaks. */
609
  for (i = 0; i < max_access_breaks; i++)
610
    {
611
      ab_addr = ab_address[i];
612
 
613
      if (ab_addr == 0x00000000)
614
        continue;
615
 
616
      /* DBC register */
617
      if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
618
        {
619
          switch (ab_type[i])
620
            {
621
            case 0:              /* write watch */
622
              send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8100 + 4 * i, 4,
623
                                  0x00000086);
624
              break;
625
            case 1:             /* read watch */
626
              send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8100 + 4 * i, 4,
627
                                  0x00000046);
628
              break;
629
            case 2:             /* access watch */
630
              send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8100 + 4 * i, 4,
631
                                  0x00000006);
632
              break;
633
            }
634
        }
635
      else
636
        {
637
          switch (ab_type[i])
638
            {
639
            case 0:              /* write watch */
640
              send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8100 + 4 * i, 4,
641
                                  0x86000000);
642
              break;
643
            case 1:             /* read watch */
644
              send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8100 + 4 * i, 4,
645
                                  0x46000000);
646
              break;
647
            case 2:             /* access watch */
648
              send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8100 + 4 * i, 4,
649
                                  0x06000000);
650
              break;
651
            }
652
        }
653
 
654
      /* DBAH register */
655
      send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8180 + 4 * i, 4, ab_addr);
656
 
657
      /* DBAL register */
658
      send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8200 + 4 * i, 4,
659
                          0xffffffff);
660
 
661
      /* DBD register */
662
      send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8280 + 4 * i, 4,
663
                          0x00000000);
664
 
665
      /* DBDM register */
666
      send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8300 + 4 * i, 4,
667
                          0x00000000);
668
    }
669
 
670
  /* Resume program. */
671
  send_cmd (SDI_EXEC_CPU);
672
 
673
  /* Without this, some commands which require an active target (such as kill)
674
     won't work.  This variable serves (at least) double duty as both the pid
675
     of the target process (if it has such), and as a flag indicating that a
676
     target is active.  These functions should be split out into seperate
677
     variables, especially since GDB will someday have a notion of debugging
678
     several processes.  */
679
  inferior_ptid = remote_m32r_ptid;
680
  add_thread_silent (remote_m32r_ptid);
681
 
682
  return;
683
}
684
 
685
/* Wait until the remote machine stops, then return,
686
   storing status in STATUS just as `wait' would.  */
687
 
688
static void
689
gdb_cntrl_c (int signo)
690
{
691
  if (remote_debug)
692
    fprintf_unfiltered (gdb_stdlog, "interrupt\n");
693
  interrupted = 1;
694
}
695
 
696
static ptid_t
697
m32r_wait (struct target_ops *ops,
698
           ptid_t ptid, struct target_waitstatus *status, int options)
699
{
700
  static RETSIGTYPE (*prev_sigint) ();
701
  unsigned long bp_addr, pc_addr;
702
  int ib_breakpoints;
703
  long i;
704
  unsigned char buf[13];
705
  unsigned long val;
706
  int ret, c;
707
 
708
  if (remote_debug)
709
    fprintf_unfiltered (gdb_stdlog, "m32r_wait()\n");
710
 
711
  status->kind = TARGET_WAITKIND_EXITED;
712
  status->value.sig = 0;
713
 
714
  interrupted = 0;
715
  prev_sigint = signal (SIGINT, gdb_cntrl_c);
716
 
717
  /* Wait for ready */
718
  buf[0] = SDI_WAIT_FOR_READY;
719
  if (serial_write (sdi_desc, buf, 1) != 0)
720
    error (_("Remote connection closed"));
721
 
722
  while (1)
723
    {
724
      c = serial_readchar (sdi_desc, SDI_TIMEOUT);
725
      if (c < 0)
726
        error (_("Remote connection closed"));
727
 
728
      if (c == '-')             /* error */
729
        {
730
          status->kind = TARGET_WAITKIND_STOPPED;
731
          status->value.sig = TARGET_SIGNAL_HUP;
732
          return inferior_ptid;
733
        }
734
      else if (c == '+')        /* stopped */
735
        break;
736
 
737
      if (interrupted)
738
        ret = serial_write (sdi_desc, "!", 1);  /* packet to interrupt */
739
      else
740
        ret = serial_write (sdi_desc, ".", 1);  /* packet to wait */
741
      if (ret != 0)
742
        error (_("Remote connection closed"));
743
    }
744
 
745
  status->kind = TARGET_WAITKIND_STOPPED;
746
  if (interrupted)
747
    status->value.sig = TARGET_SIGNAL_INT;
748
  else
749
    status->value.sig = TARGET_SIGNAL_TRAP;
750
 
751
  interrupted = 0;
752
  signal (SIGINT, prev_sigint);
753
 
754
  check_mmu_status ();
755
 
756
  /* Recover parallel bit. */
757
  if (last_pc_addr != 0xffffffff)
758
    {
759
      buf[0] = SDI_WRITE_MEMORY;
760
      if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
761
        store_long_parameter (buf + 1, last_pc_addr);
762
      else
763
        store_long_parameter (buf + 1, last_pc_addr - 1);
764
      store_long_parameter (buf + 5, 1);
765
      buf[9] = last_pc_addr_data[0];
766
      send_data (buf, 10);
767
      last_pc_addr = 0xffffffff;
768
    }
769
 
770
  if (use_ib_breakpoints)
771
    ib_breakpoints = max_ib_breakpoints;
772
  else
773
    ib_breakpoints = 0;
774
 
775
  /* Set back pc by 2 if m32r is stopped with dbt. */
776
  last_pc_addr = 0xffffffff;
777
  send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_BPC);
778
  pc_addr = recv_long_data () - 2;
779
  for (i = ib_breakpoints; i < MAX_BREAKPOINTS; i++)
780
    {
781
      if (pc_addr == bp_address[i])
782
        {
783
          send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_BPC, pc_addr);
784
 
785
          /* If there is a parallel instruction with +2 offset at pc
786
             address, we have to take care of it later. */
787
          if ((pc_addr & 0x2) != 0)
788
            {
789
              if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
790
                {
791
                  if ((bp_data[i][2] & 0x80) != 0)
792
                    {
793
                      last_pc_addr = pc_addr;
794
                      last_pc_addr_data[0] = bp_data[i][2];
795
                      last_pc_addr_data[1] = bp_data[i][3];
796
                    }
797
                }
798
              else
799
                {
800
                  if ((bp_data[i][1] & 0x80) != 0)
801
                    {
802
                      last_pc_addr = pc_addr;
803
                      last_pc_addr_data[0] = bp_data[i][1];
804
                      last_pc_addr_data[1] = bp_data[i][0];
805
                    }
806
                }
807
            }
808
          break;
809
        }
810
    }
811
 
812
  /* Remove ib breakpoints. */
813
  for (i = 0; i < ib_breakpoints; i++)
814
    {
815
      if (bp_address[i] != 0xffffffff)
816
        send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8000 + 4 * i, 4,
817
                            0x00000000);
818
    }
819
  /* Remove dbt breakpoints. */
820
  for (i = ib_breakpoints; i < MAX_BREAKPOINTS; i++)
821
    {
822
      bp_addr = bp_address[i];
823
      if (bp_addr != 0xffffffff)
824
        {
825
          if (!mmu_on)
826
            bp_addr &= 0x7fffffff;
827
          buf[0] = SDI_WRITE_MEMORY;
828
          store_long_parameter (buf + 1, bp_addr & 0xfffffffc);
829
          store_long_parameter (buf + 5, 4);
830
          buf[9] = bp_data[i][0];
831
          buf[10] = bp_data[i][1];
832
          buf[11] = bp_data[i][2];
833
          buf[12] = bp_data[i][3];
834
          send_data (buf, 13);
835
        }
836
    }
837
 
838
  /* Remove access breaks. */
839
  hit_watchpoint_addr = 0;
840
  for (i = 0; i < max_access_breaks; i++)
841
    {
842
      if (ab_address[i] != 0x00000000)
843
        {
844
          buf[0] = SDI_READ_MEMORY;
845
          store_long_parameter (buf + 1, 0xffff8100 + 4 * i);
846
          store_long_parameter (buf + 5, 4);
847
          serial_write (sdi_desc, buf, 9);
848
          c = serial_readchar (sdi_desc, SDI_TIMEOUT);
849
          if (c != '-' && recv_data (buf, 4) != -1)
850
            {
851
              if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
852
                {
853
                  if ((buf[3] & 0x1) == 0x1)
854
                    hit_watchpoint_addr = ab_address[i];
855
                }
856
              else
857
                {
858
                  if ((buf[0] & 0x1) == 0x1)
859
                    hit_watchpoint_addr = ab_address[i];
860
                }
861
            }
862
 
863
          send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8100 + 4 * i, 4,
864
                              0x00000000);
865
        }
866
    }
867
 
868
  if (remote_debug)
869
    fprintf_unfiltered (gdb_stdlog, "pc => 0x%lx\n", pc_addr);
870
 
871
  return inferior_ptid;
872
}
873
 
874
/* Terminate the open connection to the remote debugger.
875
   Use this when you want to detach and do something else
876
   with your gdb.  */
877
static void
878
m32r_detach (struct target_ops *ops, char *args, int from_tty)
879
{
880
  if (remote_debug)
881
    fprintf_unfiltered (gdb_stdlog, "m32r_detach(%d)\n", from_tty);
882
 
883
  m32r_resume (ops, inferior_ptid, 0, 0);
884
 
885
  /* calls m32r_close to do the real work */
886
  pop_target ();
887
  if (from_tty)
888
    fprintf_unfiltered (gdb_stdlog, "Ending remote %s debugging\n",
889
                        target_shortname);
890
}
891
 
892
/* Return the id of register number REGNO. */
893
 
894
static int
895
get_reg_id (int regno)
896
{
897
  switch (regno)
898
    {
899
    case 20:
900
      return SDI_REG_BBPC;
901
    case 21:
902
      return SDI_REG_BPC;
903
    case 22:
904
      return SDI_REG_ACCL;
905
    case 23:
906
      return SDI_REG_ACCH;
907
    case 24:
908
      return SDI_REG_EVB;
909
    }
910
 
911
  return regno;
912
}
913
 
914
/* Fetch register REGNO, or all registers if REGNO is -1.
915
   Returns errno value.  */
916
static void
917
m32r_fetch_register (struct target_ops *ops,
918
                     struct regcache *regcache, int regno)
919
{
920
  struct gdbarch *gdbarch = get_regcache_arch (regcache);
921
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
922
  unsigned long val, val2, regid;
923
 
924
  if (regno == -1)
925
    {
926
      for (regno = 0;
927
           regno < gdbarch_num_regs (get_regcache_arch (regcache));
928
           regno++)
929
        m32r_fetch_register (ops, regcache, regno);
930
    }
931
  else
932
    {
933
      char buffer[MAX_REGISTER_SIZE];
934
 
935
      regid = get_reg_id (regno);
936
      send_one_arg_cmd (SDI_READ_CPU_REG, regid);
937
      val = recv_long_data ();
938
 
939
      if (regid == SDI_REG_PSW)
940
        {
941
          send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_BBPSW);
942
          val2 = recv_long_data ();
943
          val = ((0x00cf & val2) << 8) | ((0xcf00 & val) >> 8);
944
        }
945
 
946
      if (remote_debug)
947
        fprintf_unfiltered (gdb_stdlog, "m32r_fetch_register(%d,0x%08lx)\n",
948
                            regno, val);
949
 
950
      /* We got the number the register holds, but gdb expects to see a
951
         value in the target byte ordering.  */
952
      store_unsigned_integer (buffer, 4, byte_order, val);
953
      regcache_raw_supply (regcache, regno, buffer);
954
    }
955
  return;
956
}
957
 
958
/* Store register REGNO, or all if REGNO == 0.
959
   Return errno value.  */
960
static void
961
m32r_store_register (struct target_ops *ops,
962
                     struct regcache *regcache, int regno)
963
{
964
  int regid;
965
  ULONGEST regval, tmp;
966
 
967
  if (regno == -1)
968
    {
969
      for (regno = 0;
970
           regno < gdbarch_num_regs (get_regcache_arch (regcache));
971
           regno++)
972
        m32r_store_register (ops, regcache, regno);
973
    }
974
  else
975
    {
976
      regcache_cooked_read_unsigned (regcache, regno, &regval);
977
      regid = get_reg_id (regno);
978
 
979
      if (regid == SDI_REG_PSW)
980
        {
981
          unsigned long psw, bbpsw;
982
 
983
          send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_PSW);
984
          psw = recv_long_data ();
985
 
986
          send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_BBPSW);
987
          bbpsw = recv_long_data ();
988
 
989
          tmp = (0x00cf & psw) | ((0x00cf & regval) << 8);
990
          send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_PSW, tmp);
991
 
992
          tmp = (0x0030 & bbpsw) | ((0xcf00 & regval) >> 8);
993
          send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_BBPSW, tmp);
994
        }
995
      else
996
        {
997
          send_two_arg_cmd (SDI_WRITE_CPU_REG, regid, regval);
998
        }
999
 
1000
      if (remote_debug)
1001
        fprintf_unfiltered (gdb_stdlog, "m32r_store_register(%d,0x%08lu)\n",
1002
                            regno, (unsigned long) regval);
1003
    }
1004
}
1005
 
1006
/* Get ready to modify the registers array.  On machines which store
1007
   individual registers, this doesn't need to do anything.  On machines
1008
   which store all the registers in one fell swoop, this makes sure
1009
   that registers contains all the registers from the program being
1010
   debugged.  */
1011
 
1012
static void
1013
m32r_prepare_to_store (struct regcache *regcache)
1014
{
1015
  /* Do nothing, since we can store individual regs */
1016
  if (remote_debug)
1017
    fprintf_unfiltered (gdb_stdlog, "m32r_prepare_to_store()\n");
1018
}
1019
 
1020
static void
1021
m32r_files_info (struct target_ops *target)
1022
{
1023
  char *file = "nothing";
1024
 
1025
  if (exec_bfd)
1026
    {
1027
      file = bfd_get_filename (exec_bfd);
1028
      printf_filtered ("\tAttached to %s running program %s\n",
1029
                       chip_name, file);
1030
    }
1031
}
1032
 
1033
/* Read/Write memory.  */
1034
static int
1035
m32r_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
1036
                  int write,
1037
                  struct mem_attrib *attrib, struct target_ops *target)
1038
{
1039
  unsigned long taddr;
1040
  unsigned char buf[0x2000];
1041
  int ret, c;
1042
 
1043
  taddr = memaddr;
1044
 
1045
  if (!mmu_on)
1046
    {
1047
      if ((taddr & 0xa0000000) == 0x80000000)
1048
        taddr &= 0x7fffffff;
1049
    }
1050
 
1051
  if (remote_debug)
1052
    {
1053
      if (write)
1054
        fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory(%s,%d,write)\n",
1055
                            paddress (target_gdbarch, memaddr), len);
1056
      else
1057
        fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory(%s,%d,read)\n",
1058
                            paddress (target_gdbarch, memaddr), len);
1059
    }
1060
 
1061
  if (write)
1062
    {
1063
      buf[0] = SDI_WRITE_MEMORY;
1064
      store_long_parameter (buf + 1, taddr);
1065
      store_long_parameter (buf + 5, len);
1066
      if (len < 0x1000)
1067
        {
1068
          memcpy (buf + 9, myaddr, len);
1069
          ret = send_data (buf, len + 9) - 9;
1070
        }
1071
      else
1072
        {
1073
          if (serial_write (sdi_desc, buf, 9) != 0)
1074
            {
1075
              if (remote_debug)
1076
                fprintf_unfiltered (gdb_stdlog,
1077
                                    "m32r_xfer_memory() failed\n");
1078
              return 0;
1079
            }
1080
          ret = send_data (myaddr, len);
1081
        }
1082
    }
1083
  else
1084
    {
1085
      buf[0] = SDI_READ_MEMORY;
1086
      store_long_parameter (buf + 1, taddr);
1087
      store_long_parameter (buf + 5, len);
1088
      if (serial_write (sdi_desc, buf, 9) != 0)
1089
        {
1090
          if (remote_debug)
1091
            fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory() failed\n");
1092
          return 0;
1093
        }
1094
 
1095
      c = serial_readchar (sdi_desc, SDI_TIMEOUT);
1096
      if (c < 0 || c == '-')
1097
        {
1098
          if (remote_debug)
1099
            fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory() failed\n");
1100
          return 0;
1101
        }
1102
 
1103
      ret = recv_data (myaddr, len);
1104
    }
1105
 
1106
  if (ret <= 0)
1107
    {
1108
      if (remote_debug)
1109
        fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory() fails\n");
1110
      return 0;
1111
    }
1112
 
1113
  return ret;
1114
}
1115
 
1116
static void
1117
m32r_kill (struct target_ops *ops)
1118
{
1119
  if (remote_debug)
1120
    fprintf_unfiltered (gdb_stdlog, "m32r_kill()\n");
1121
 
1122
  inferior_ptid = null_ptid;
1123
  delete_thread_silent (remote_m32r_ptid);
1124
 
1125
  return;
1126
}
1127
 
1128
/* Clean up when a program exits.
1129
 
1130
   The program actually lives on in the remote processor's RAM, and may be
1131
   run again without a download.  Don't leave it full of breakpoint
1132
   instructions.  */
1133
 
1134
static void
1135
m32r_mourn_inferior (struct target_ops *ops)
1136
{
1137
  if (remote_debug)
1138
    fprintf_unfiltered (gdb_stdlog, "m32r_mourn_inferior()\n");
1139
 
1140
  remove_breakpoints ();
1141
  generic_mourn_inferior ();
1142
}
1143
 
1144
static int
1145
m32r_insert_breakpoint (struct gdbarch *gdbarch,
1146
                        struct bp_target_info *bp_tgt)
1147
{
1148
  CORE_ADDR addr = bp_tgt->placed_address;
1149
  int ib_breakpoints;
1150
  unsigned char buf[13];
1151
  int i, c;
1152
 
1153
  if (remote_debug)
1154
    fprintf_unfiltered (gdb_stdlog, "m32r_insert_breakpoint(%s,...)\n",
1155
                        paddress (gdbarch, addr));
1156
 
1157
  if (use_ib_breakpoints)
1158
    ib_breakpoints = max_ib_breakpoints;
1159
  else
1160
    ib_breakpoints = 0;
1161
 
1162
  for (i = 0; i < MAX_BREAKPOINTS; i++)
1163
    {
1164
      if (bp_address[i] == 0xffffffff)
1165
        {
1166
          bp_address[i] = addr;
1167
          if (i >= ib_breakpoints)
1168
            {
1169
              buf[0] = SDI_READ_MEMORY;
1170
              if (mmu_on)
1171
                store_long_parameter (buf + 1, addr & 0xfffffffc);
1172
              else
1173
                store_long_parameter (buf + 1, addr & 0x7ffffffc);
1174
              store_long_parameter (buf + 5, 4);
1175
              serial_write (sdi_desc, buf, 9);
1176
              c = serial_readchar (sdi_desc, SDI_TIMEOUT);
1177
              if (c != '-')
1178
                recv_data (bp_data[i], 4);
1179
            }
1180
          return 0;
1181
        }
1182
    }
1183
 
1184
  error (_("Too many breakpoints"));
1185
  return 1;
1186
}
1187
 
1188
static int
1189
m32r_remove_breakpoint (struct gdbarch *gdbarch,
1190
                        struct bp_target_info *bp_tgt)
1191
{
1192
  CORE_ADDR addr = bp_tgt->placed_address;
1193
  int i;
1194
 
1195
  if (remote_debug)
1196
    fprintf_unfiltered (gdb_stdlog, "m32r_remove_breakpoint(%s)\n",
1197
                        paddress (gdbarch, addr));
1198
 
1199
  for (i = 0; i < MAX_BREAKPOINTS; i++)
1200
    {
1201
      if (bp_address[i] == addr)
1202
        {
1203
          bp_address[i] = 0xffffffff;
1204
          break;
1205
        }
1206
    }
1207
 
1208
  return 0;
1209
}
1210
 
1211
static void
1212
m32r_load (char *args, int from_tty)
1213
{
1214
  struct cleanup *old_chain;
1215
  asection *section;
1216
  bfd *pbfd;
1217
  bfd_vma entry;
1218
  char *filename;
1219
  int quiet;
1220
  int nostart;
1221
  struct timeval start_time, end_time;
1222
  unsigned long data_count;     /* Number of bytes transferred to memory */
1223
  int ret;
1224
  static RETSIGTYPE (*prev_sigint) ();
1225
 
1226
  /* for direct tcp connections, we can do a fast binary download */
1227
  quiet = 0;
1228
  nostart = 0;
1229
  filename = NULL;
1230
 
1231
  while (*args != '\000')
1232
    {
1233
      char *arg;
1234
 
1235
      while (isspace (*args))
1236
        args++;
1237
 
1238
      arg = args;
1239
 
1240
      while ((*args != '\000') && !isspace (*args))
1241
        args++;
1242
 
1243
      if (*args != '\000')
1244
        *args++ = '\000';
1245
 
1246
      if (*arg != '-')
1247
        filename = arg;
1248
      else if (strncmp (arg, "-quiet", strlen (arg)) == 0)
1249
        quiet = 1;
1250
      else if (strncmp (arg, "-nostart", strlen (arg)) == 0)
1251
        nostart = 1;
1252
      else
1253
        error (_("Unknown option `%s'"), arg);
1254
    }
1255
 
1256
  if (!filename)
1257
    filename = get_exec_file (1);
1258
 
1259
  pbfd = bfd_openr (filename, gnutarget);
1260
  if (pbfd == NULL)
1261
    {
1262
      perror_with_name (filename);
1263
      return;
1264
    }
1265
  old_chain = make_cleanup_bfd_close (pbfd);
1266
 
1267
  if (!bfd_check_format (pbfd, bfd_object))
1268
    error (_("\"%s\" is not an object file: %s"), filename,
1269
           bfd_errmsg (bfd_get_error ()));
1270
 
1271
  gettimeofday (&start_time, NULL);
1272
  data_count = 0;
1273
 
1274
  interrupted = 0;
1275
  prev_sigint = signal (SIGINT, gdb_cntrl_c);
1276
 
1277
  for (section = pbfd->sections; section; section = section->next)
1278
    {
1279
      if (bfd_get_section_flags (pbfd, section) & SEC_LOAD)
1280
        {
1281
          bfd_vma section_address;
1282
          bfd_size_type section_size;
1283
          file_ptr fptr;
1284
          int n;
1285
 
1286
          section_address = bfd_section_lma (pbfd, section);
1287
          section_size = bfd_get_section_size (section);
1288
 
1289
          if (!mmu_on)
1290
            {
1291
              if ((section_address & 0xa0000000) == 0x80000000)
1292
                section_address &= 0x7fffffff;
1293
            }
1294
 
1295
          if (!quiet)
1296
            printf_filtered ("[Loading section %s at 0x%lx (%d bytes)]\n",
1297
                             bfd_get_section_name (pbfd, section),
1298
                             (unsigned long) section_address,
1299
                             (int) section_size);
1300
 
1301
          fptr = 0;
1302
 
1303
          data_count += section_size;
1304
 
1305
          n = 0;
1306
          while (section_size > 0)
1307
            {
1308
              char unsigned buf[0x1000 + 9];
1309
              int count;
1310
 
1311
              count = min (section_size, 0x1000);
1312
 
1313
              buf[0] = SDI_WRITE_MEMORY;
1314
              store_long_parameter (buf + 1, section_address);
1315
              store_long_parameter (buf + 5, count);
1316
 
1317
              bfd_get_section_contents (pbfd, section, buf + 9, fptr, count);
1318
              if (send_data (buf, count + 9) <= 0)
1319
                error (_("Error while downloading %s section."),
1320
                       bfd_get_section_name (pbfd, section));
1321
 
1322
              if (!quiet)
1323
                {
1324
                  printf_unfiltered (".");
1325
                  if (n++ > 60)
1326
                    {
1327
                      printf_unfiltered ("\n");
1328
                      n = 0;
1329
                    }
1330
                  gdb_flush (gdb_stdout);
1331
                }
1332
 
1333
              section_address += count;
1334
              fptr += count;
1335
              section_size -= count;
1336
 
1337
              if (interrupted)
1338
                break;
1339
            }
1340
 
1341
          if (!quiet && !interrupted)
1342
            {
1343
              printf_unfiltered ("done.\n");
1344
              gdb_flush (gdb_stdout);
1345
            }
1346
        }
1347
 
1348
      if (interrupted)
1349
        {
1350
          printf_unfiltered ("Interrupted.\n");
1351
          break;
1352
        }
1353
    }
1354
 
1355
  interrupted = 0;
1356
  signal (SIGINT, prev_sigint);
1357
 
1358
  gettimeofday (&end_time, NULL);
1359
 
1360
  /* Make the PC point at the start address */
1361
  if (exec_bfd)
1362
    regcache_write_pc (get_current_regcache (),
1363
                       bfd_get_start_address (exec_bfd));
1364
 
1365
  inferior_ptid = null_ptid;    /* No process now */
1366
  delete_thread_silent (remote_m32r_ptid);
1367
 
1368
  /* This is necessary because many things were based on the PC at the time
1369
     that we attached to the monitor, which is no longer valid now that we
1370
     have loaded new code (and just changed the PC).  Another way to do this
1371
     might be to call normal_stop, except that the stack may not be valid,
1372
     and things would get horribly confused... */
1373
 
1374
  clear_symtab_users ();
1375
 
1376
  if (!nostart)
1377
    {
1378
      entry = bfd_get_start_address (pbfd);
1379
 
1380
      if (!quiet)
1381
        printf_unfiltered ("[Starting %s at 0x%lx]\n", filename,
1382
                           (unsigned long) entry);
1383
    }
1384
 
1385
  print_transfer_performance (gdb_stdout, data_count, 0, &start_time,
1386
                              &end_time);
1387
 
1388
  do_cleanups (old_chain);
1389
}
1390
 
1391
static void
1392
m32r_stop (ptid_t ptid)
1393
{
1394
  if (remote_debug)
1395
    fprintf_unfiltered (gdb_stdlog, "m32r_stop()\n");
1396
 
1397
  send_cmd (SDI_STOP_CPU);
1398
 
1399
  return;
1400
}
1401
 
1402
 
1403
/* Tell whether this target can support a hardware breakpoint.  CNT
1404
   is the number of hardware breakpoints already installed.  This
1405
   implements the target_can_use_hardware_watchpoint macro.  */
1406
 
1407
static int
1408
m32r_can_use_hw_watchpoint (int type, int cnt, int othertype)
1409
{
1410
  return sdi_desc != NULL && cnt < max_access_breaks;
1411
}
1412
 
1413
/* Set a data watchpoint.  ADDR and LEN should be obvious.  TYPE is 0
1414
   for a write watchpoint, 1 for a read watchpoint, or 2 for a read/write
1415
   watchpoint. */
1416
 
1417
static int
1418
m32r_insert_watchpoint (CORE_ADDR addr, int len, int type)
1419
{
1420
  int i;
1421
 
1422
  if (remote_debug)
1423
    fprintf_unfiltered (gdb_stdlog, "m32r_insert_watchpoint(%s,%d,%d)\n",
1424
                        paddress (target_gdbarch, addr), len, type);
1425
 
1426
  for (i = 0; i < MAX_ACCESS_BREAKS; i++)
1427
    {
1428
      if (ab_address[i] == 0x00000000)
1429
        {
1430
          ab_address[i] = addr;
1431
          ab_size[i] = len;
1432
          ab_type[i] = type;
1433
          return 0;
1434
        }
1435
    }
1436
 
1437
  error (_("Too many watchpoints"));
1438
  return 1;
1439
}
1440
 
1441
static int
1442
m32r_remove_watchpoint (CORE_ADDR addr, int len, int type)
1443
{
1444
  int i;
1445
 
1446
  if (remote_debug)
1447
    fprintf_unfiltered (gdb_stdlog, "m32r_remove_watchpoint(%s,%d,%d)\n",
1448
                        paddress (target_gdbarch, addr), len, type);
1449
 
1450
  for (i = 0; i < MAX_ACCESS_BREAKS; i++)
1451
    {
1452
      if (ab_address[i] == addr)
1453
        {
1454
          ab_address[i] = 0x00000000;
1455
          break;
1456
        }
1457
    }
1458
 
1459
  return 0;
1460
}
1461
 
1462
static int
1463
m32r_stopped_data_address (struct target_ops *target, CORE_ADDR *addr_p)
1464
{
1465
  int rc = 0;
1466
  if (hit_watchpoint_addr != 0x00000000)
1467
    {
1468
      *addr_p = hit_watchpoint_addr;
1469
      rc = 1;
1470
    }
1471
  return rc;
1472
}
1473
 
1474
static int
1475
m32r_stopped_by_watchpoint (void)
1476
{
1477
  CORE_ADDR addr;
1478
  return m32r_stopped_data_address (&current_target, &addr);
1479
}
1480
 
1481
/* Check to see if a thread is still alive.  */
1482
 
1483
static int
1484
m32r_thread_alive (struct target_ops *ops, ptid_t ptid)
1485
{
1486
  if (ptid_equal (ptid, remote_m32r_ptid))
1487
    /* The main task is always alive.  */
1488
    return 1;
1489
 
1490
  return 0;
1491
}
1492
 
1493
/* Convert a thread ID to a string.  Returns the string in a static
1494
   buffer.  */
1495
 
1496
static char *
1497
m32r_pid_to_str (struct target_ops *ops, ptid_t ptid)
1498
{
1499
  static char buf[64];
1500
 
1501
  if (ptid_equal (remote_m32r_ptid, ptid))
1502
    {
1503
      xsnprintf (buf, sizeof buf, "Thread <main>");
1504
      return buf;
1505
    }
1506
 
1507
  return normal_pid_to_str (ptid);
1508
}
1509
 
1510
static void
1511
sdireset_command (char *args, int from_tty)
1512
{
1513
  if (remote_debug)
1514
    fprintf_unfiltered (gdb_stdlog, "m32r_sdireset()\n");
1515
 
1516
  send_cmd (SDI_OPEN);
1517
 
1518
  inferior_ptid = null_ptid;
1519
  delete_thread_silent (remote_m32r_ptid);
1520
}
1521
 
1522
 
1523
static void
1524
sdistatus_command (char *args, int from_tty)
1525
{
1526
  unsigned char buf[4096];
1527
  int i, c;
1528
 
1529
  if (remote_debug)
1530
    fprintf_unfiltered (gdb_stdlog, "m32r_sdireset()\n");
1531
 
1532
  if (!sdi_desc)
1533
    return;
1534
 
1535
  send_cmd (SDI_STATUS);
1536
  for (i = 0; i < 4096; i++)
1537
    {
1538
      c = serial_readchar (sdi_desc, SDI_TIMEOUT);
1539
      if (c < 0)
1540
        return;
1541
      buf[i] = c;
1542
      if (c == 0)
1543
        break;
1544
    }
1545
 
1546
  printf_filtered ("%s", buf);
1547
}
1548
 
1549
 
1550
static void
1551
debug_chaos_command (char *args, int from_tty)
1552
{
1553
  unsigned char buf[3];
1554
 
1555
  buf[0] = SDI_SET_ATTR;
1556
  buf[1] = SDI_ATTR_CACHE;
1557
  buf[2] = SDI_CACHE_TYPE_CHAOS;
1558
  send_data (buf, 3);
1559
}
1560
 
1561
 
1562
static void
1563
use_debug_dma_command (char *args, int from_tty)
1564
{
1565
  unsigned char buf[3];
1566
 
1567
  buf[0] = SDI_SET_ATTR;
1568
  buf[1] = SDI_ATTR_MEM_ACCESS;
1569
  buf[2] = SDI_MEM_ACCESS_DEBUG_DMA;
1570
  send_data (buf, 3);
1571
}
1572
 
1573
static void
1574
use_mon_code_command (char *args, int from_tty)
1575
{
1576
  unsigned char buf[3];
1577
 
1578
  buf[0] = SDI_SET_ATTR;
1579
  buf[1] = SDI_ATTR_MEM_ACCESS;
1580
  buf[2] = SDI_MEM_ACCESS_MON_CODE;
1581
  send_data (buf, 3);
1582
}
1583
 
1584
 
1585
static void
1586
use_ib_breakpoints_command (char *args, int from_tty)
1587
{
1588
  use_ib_breakpoints = 1;
1589
}
1590
 
1591
static void
1592
use_dbt_breakpoints_command (char *args, int from_tty)
1593
{
1594
  use_ib_breakpoints = 0;
1595
}
1596
 
1597
static int
1598
m32r_return_one (struct target_ops *target)
1599
{
1600
  return 1;
1601
}
1602
 
1603
/* Define the target subroutine names */
1604
 
1605
struct target_ops m32r_ops;
1606
 
1607
static void
1608
init_m32r_ops (void)
1609
{
1610
  m32r_ops.to_shortname = "m32rsdi";
1611
  m32r_ops.to_longname = "Remote M32R debugging over SDI interface";
1612
  m32r_ops.to_doc = "Use an M32R board using SDI debugging protocol.";
1613
  m32r_ops.to_open = m32r_open;
1614
  m32r_ops.to_close = m32r_close;
1615
  m32r_ops.to_detach = m32r_detach;
1616
  m32r_ops.to_resume = m32r_resume;
1617
  m32r_ops.to_wait = m32r_wait;
1618
  m32r_ops.to_fetch_registers = m32r_fetch_register;
1619
  m32r_ops.to_store_registers = m32r_store_register;
1620
  m32r_ops.to_prepare_to_store = m32r_prepare_to_store;
1621
  m32r_ops.deprecated_xfer_memory = m32r_xfer_memory;
1622
  m32r_ops.to_files_info = m32r_files_info;
1623
  m32r_ops.to_insert_breakpoint = m32r_insert_breakpoint;
1624
  m32r_ops.to_remove_breakpoint = m32r_remove_breakpoint;
1625
  m32r_ops.to_can_use_hw_breakpoint = m32r_can_use_hw_watchpoint;
1626
  m32r_ops.to_insert_watchpoint = m32r_insert_watchpoint;
1627
  m32r_ops.to_remove_watchpoint = m32r_remove_watchpoint;
1628
  m32r_ops.to_stopped_by_watchpoint = m32r_stopped_by_watchpoint;
1629
  m32r_ops.to_stopped_data_address = m32r_stopped_data_address;
1630
  m32r_ops.to_kill = m32r_kill;
1631
  m32r_ops.to_load = m32r_load;
1632
  m32r_ops.to_create_inferior = m32r_create_inferior;
1633
  m32r_ops.to_mourn_inferior = m32r_mourn_inferior;
1634
  m32r_ops.to_stop = m32r_stop;
1635
  m32r_ops.to_log_command = serial_log_command;
1636
  m32r_ops.to_thread_alive = m32r_thread_alive;
1637
  m32r_ops.to_pid_to_str = m32r_pid_to_str;
1638
  m32r_ops.to_stratum = process_stratum;
1639
  m32r_ops.to_has_all_memory = m32r_return_one;
1640
  m32r_ops.to_has_memory = m32r_return_one;
1641
  m32r_ops.to_has_stack = m32r_return_one;
1642
  m32r_ops.to_has_registers = m32r_return_one;
1643
  m32r_ops.to_has_execution = m32r_return_one;
1644
  m32r_ops.to_magic = OPS_MAGIC;
1645
};
1646
 
1647
 
1648
extern initialize_file_ftype _initialize_remote_m32r;
1649
 
1650
void
1651
_initialize_remote_m32r (void)
1652
{
1653
  int i;
1654
 
1655
  init_m32r_ops ();
1656
 
1657
  /* Initialize breakpoints. */
1658
  for (i = 0; i < MAX_BREAKPOINTS; i++)
1659
    bp_address[i] = 0xffffffff;
1660
 
1661
  /* Initialize access breaks. */
1662
  for (i = 0; i < MAX_ACCESS_BREAKS; i++)
1663
    ab_address[i] = 0x00000000;
1664
 
1665
  add_target (&m32r_ops);
1666
 
1667
  add_com ("sdireset", class_obscure, sdireset_command,
1668
           _("Reset SDI connection."));
1669
 
1670
  add_com ("sdistatus", class_obscure, sdistatus_command,
1671
           _("Show status of SDI connection."));
1672
 
1673
  add_com ("debug_chaos", class_obscure, debug_chaos_command,
1674
           _("Debug M32R/Chaos."));
1675
 
1676
  add_com ("use_debug_dma", class_obscure, use_debug_dma_command,
1677
           _("Use debug DMA mem access."));
1678
  add_com ("use_mon_code", class_obscure, use_mon_code_command,
1679
           _("Use mon code mem access."));
1680
 
1681
  add_com ("use_ib_break", class_obscure, use_ib_breakpoints_command,
1682
           _("Set breakpoints by IB break."));
1683
  add_com ("use_dbt_break", class_obscure, use_dbt_breakpoints_command,
1684
           _("Set breakpoints by dbt."));
1685
 
1686
  /* Yes, 42000 is arbitrary.  The only sense out of it, is that it
1687
     isn't 0.  */
1688
  remote_m32r_ptid = ptid_build (42000, 0, 42000);
1689
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.