gdb/dve3900-rom.c

   1 /* Remote debugging interface for Densan DVE-R3900 ROM monitor for
   2    GDB, the GNU debugger.
   3    Copyright 1997, 1998, 2000, 2001 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include "defs.h"
  23 #include "gdbcore.h"
  24 #include "target.h"
  25 #include "monitor.h"
  26 #include "serial.h"
  27 #include "inferior.h"
  28 #include "command.h"
  29 #include "gdb_string.h"
  30 #include <time.h>
  31 #include "regcache.h"
  32
  33 /* Type of function passed to bfd_map_over_sections.  */
  34
  35 typedef void (*section_map_func) (bfd * abfd, asection * sect, PTR obj);
  36
  37 /* Packet escape character used by Densan monitor.  */
  38
  39 #define PESC 0xdc
  40
  41 /* Maximum packet size.  This is actually smaller than necessary
  42    just to be safe.  */
  43
  44 #define MAXPSIZE 1024
  45
  46 /* External functions.  */
  47
  48 extern void report_transfer_performance (unsigned long, time_t, time_t);
  49
  50 /* Certain registers are "bitmapped", in that the monitor can only display
  51    them or let the user modify them as a series of named bitfields.
  52    This structure describes a field in a bitmapped register.  */
  53
  54 struct bit_field
  55   {
  56     char *prefix;               /* string appearing before the value */
  57     char *suffix;               /* string appearing after the value */
  58     char *user_name;            /* name used by human when entering field value */
  59     int length;                 /* number of bits in the field */
  60     int start;                  /* starting (least significant) bit number of field */
  61   };
  62
  63 /* Local functions for register manipulation.  */
  64
  65 static void r3900_supply_register (char *regname, int regnamelen,
  66                                    char *val, int vallen);
  67 static void fetch_bad_vaddr (void);
  68 static unsigned long fetch_fields (struct bit_field *bf);
  69 static void fetch_bitmapped_register (int regno, struct bit_field *bf);
  70 static void r3900_fetch_registers (int regno);
  71 static void store_bitmapped_register (int regno, struct bit_field *bf);
  72 static void r3900_store_registers (int regno);
  73
  74 /* Local functions for fast binary loading.  */
  75
  76 static void write_long (char *buf, long n);
  77 static void write_long_le (char *buf, long n);
  78 static int debug_readchar (int hex);
  79 static void debug_write (unsigned char *buf, int buflen);
  80 static void ignore_packet (void);
  81 static void send_packet (char type, unsigned char *buf, int buflen, int seq);
  82 static void process_read_request (unsigned char *buf, int buflen);
  83 static void count_section (bfd * abfd, asection * s,
  84                            unsigned int *section_count);
  85 static void load_section (bfd * abfd, asection * s, unsigned int *data_count);
  86 static void r3900_load (char *filename, int from_tty);
  87
  88 /* Miscellaneous local functions.  */
  89
  90 static void r3900_open (char *args, int from_tty);
  91
  92
  93 /* Pointers to static functions in monitor.c for fetching and storing
  94    registers.  We can't use these function in certain cases where the Densan
  95    monitor acts perversely: for registers that it displays in bit-map
  96    format, and those that can't be modified at all.  In those cases
  97    we have to use our own functions to fetch and store their values.  */
  98
  99 static void (*orig_monitor_fetch_registers) (int regno);
 100 static void (*orig_monitor_store_registers) (int regno);
 101
 102 /* Pointer to static function in monitor. for loading programs.
 103    We use this function for loading S-records via the serial link.  */
 104
 105 static void (*orig_monitor_load) (char *file, int from_tty);
 106
 107 /* This flag is set if a fast ethernet download should be used.  */
 108
 109 static int ethernet = 0;
 110
 111 /* This array of registers needs to match the indexes used by GDB. The
 112    whole reason this exists is because the various ROM monitors use
 113    different names than GDB does, and don't support all the registers
 114    either.  */
 115
 116 static char *r3900_regnames[NUM_REGS] =
 117 {
 118   "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 119   "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
 120   "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
 121   "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
 122
 123   "S",                          /* PS_REGNUM */
 124   "l",                          /* LO_REGNUM */
 125   "h",                          /* HI_REGNUM */
 126   "B",                          /* BADVADDR_REGNUM */
 127   "Pcause",                     /* CAUSE_REGNUM */
 128   "p"                           /* PC_REGNUM */
 129 };
 130
 131
 132 /* Table of register names produced by monitor's register dump command.  */
 133
 134 static struct reg_entry
 135   {
 136     char *name;
 137     int regno;
 138   }
 139 reg_table[] =
 140 {
 141   {
 142     "r0_zero", 0
 143   }
 144   ,
 145   {
 146     "r1_at", 1
 147   }
 148   ,
 149   {
 150     "r2_v0", 2
 151   }
 152   ,
 153   {
 154     "r3_v1", 3
 155   }
 156   ,
 157   {
 158     "r4_a0", 4
 159   }
 160   ,
 161   {
 162     "r5_a1", 5
 163   }
 164   ,
 165   {
 166     "r6_a2", 6
 167   }
 168   ,
 169   {
 170     "r7_a3", 7
 171   }
 172   ,
 173   {
 174     "r8_t0", 8
 175   }
 176   ,
 177   {
 178     "r9_t1", 9
 179   }
 180   ,
 181   {
 182     "r10_t2", 10
 183   }
 184   ,
 185   {
 186     "r11_t3", 11
 187   }
 188   ,
 189   {
 190     "r12_t4", 12
 191   }
 192   ,
 193   {
 194     "r13_t5", 13
 195   }
 196   ,
 197   {
 198     "r14_t6", 14
 199   }
 200   ,
 201   {
 202     "r15_t7", 15
 203   }
 204   ,
 205   {
 206     "r16_s0", 16
 207   }
 208   ,
 209   {
 210     "r17_s1", 17
 211   }
 212   ,
 213   {
 214     "r18_s2", 18
 215   }
 216   ,
 217   {
 218     "r19_s3", 19
 219   }
 220   ,
 221   {
 222     "r20_s4", 20
 223   }
 224   ,
 225   {
 226     "r21_s5", 21
 227   }
 228   ,
 229   {
 230     "r22_s6", 22
 231   }
 232   ,
 233   {
 234     "r23_s7", 23
 235   }
 236   ,
 237   {
 238     "r24_t8", 24
 239   }
 240   ,
 241   {
 242     "r25_t9", 25
 243   }
 244   ,
 245   {
 246     "r26_k0", 26
 247   }
 248   ,
 249   {
 250     "r27_k1", 27
 251   }
 252   ,
 253   {
 254     "r28_gp", 28
 255   }
 256   ,
 257   {
 258     "r29_sp", 29
 259   }
 260   ,
 261   {
 262     "r30_fp", 30
 263   }
 264   ,
 265   {
 266     "r31_ra", 31
 267   }
 268   ,
 269   {
 270     "HI", HI_REGNUM
 271   }
 272   ,
 273   {
 274     "LO", LO_REGNUM
 275   }
 276   ,
 277   {
 278     "PC", PC_REGNUM
 279   }
 280   ,
 281   {
 282     "BadV", BADVADDR_REGNUM
 283   }
 284   ,
 285   {
 286     NULL, 0
 287   }
 288 };
 289
 290
 291 /* The monitor displays the cache register along with the status register,
 292    as if they were a single register.  So when we want to fetch the
 293    status register, parse but otherwise ignore the fields of the
 294    cache register that the monitor displays.  Register fields that should
 295    be ignored have a length of zero in the tables below.  */
 296
 297 static struct bit_field status_fields[] =
 298 {
 299   /* Status register portion */
 300   {"SR[<CU=", " ", "cu", 4, 28},
 301   {"RE=", " ", "re", 1, 25},
 302   {"BEV=", " ", "bev", 1, 22},
 303   {"TS=", " ", "ts", 1, 21},
 304   {"Nmi=", " ", "nmi", 1, 20},
 305   {"INT=", " ", "int", 6, 10},
 306   {"SW=", ">]", "sw", 2, 8},
 307   {"[<KUO=", " ", "kuo", 1, 5},
 308   {"IEO=", " ", "ieo", 1, 4},
 309   {"KUP=", " ", "kup", 1, 3},
 310   {"IEP=", " ", "iep", 1, 2},
 311   {"KUC=", " ", "kuc", 1, 1},
 312   {"IEC=", ">]", "iec", 1, 0},
 313
 314   /* Cache register portion (dummy for parsing only) */
 315   {"CR[<IalO=", " ", "ialo", 0, 13},
 316   {"DalO=", " ", "dalo", 0, 12},
 317   {"IalP=", " ", "ialp", 0, 11},
 318   {"DalP=", " ", "dalp", 0, 10},
 319   {"IalC=", " ", "ialc", 0, 9},
 320   {"DalC=", ">] ", "dalc", 0, 8},
 321
 322   {NULL, NULL, 0, 0}            /* end of table marker */
 323 };
 324
 325
 326 #if 0                           /* FIXME: Enable when we add support for modifying cache register.  */
 327 static struct bit_field cache_fields[] =
 328 {
 329   /* Status register portion (dummy for parsing only) */
 330   {"SR[<CU=", " ", "cu", 0, 28},
 331   {"RE=", " ", "re", 0, 25},
 332   {"BEV=", " ", "bev", 0, 22},
 333   {"TS=", " ", "ts", 0, 21},
 334   {"Nmi=", " ", "nmi", 0, 20},
 335   {"INT=", " ", "int", 0, 10},
 336   {"SW=", ">]", "sw", 0, 8},
 337   {"[<KUO=", " ", "kuo", 0, 5},
 338   {"IEO=", " ", "ieo", 0, 4},
 339   {"KUP=", " ", "kup", 0, 3},
 340   {"IEP=", " ", "iep", 0, 2},
 341   {"KUC=", " ", "kuc", 0, 1},
 342   {"IEC=", ">]", "iec", 0, 0},
 343
 344   /* Cache register portion  */
 345   {"CR[<IalO=", " ", "ialo", 1, 13},
 346   {"DalO=", " ", "dalo", 1, 12},
 347   {"IalP=", " ", "ialp", 1, 11},
 348   {"DalP=", " ", "dalp", 1, 10},
 349   {"IalC=", " ", "ialc", 1, 9},
 350   {"DalC=", ">] ", "dalc", 1, 8},
 351
 352   {NULL, NULL, NULL, 0, 0}      /* end of table marker */
 353 };
 354 #endif
 355
 356
 357 static struct bit_field cause_fields[] =
 358 {
 359   {"<BD=", " ", "bd", 1, 31},
 360   {"CE=", " ", "ce", 2, 28},
 361   {"IP=", " ", "ip", 6, 10},
 362   {"SW=", " ", "sw", 2, 8},
 363   {"EC=", ">]", "ec", 5, 2},
 364
 365   {NULL, NULL, NULL, 0, 0}      /* end of table marker */
 366 };
 367
 368
 369 /* The monitor prints register values in the form
 370
 371    regname = xxxx xxxx
 372
 373    We look up the register name in a table, and remove the embedded space in
 374    the hex value before passing it to monitor_supply_register.  */
 375
 376 static void
 377 r3900_supply_register (char *regname, int regnamelen, char *val, int vallen)
 378 {
 379   int regno = -1;
 380   int i;
 381   char valbuf[10];
 382   char *p;
 383
 384   /* Perform some sanity checks on the register name and value.  */
 385   if (regnamelen < 2 || regnamelen > 7 || vallen != 9)
 386     return;
 387
 388   /* Look up the register name.  */
 389   for (i = 0; reg_table[i].name != NULL; i++)
 390     {
 391       int rlen = strlen (reg_table[i].name);
 392       if (rlen == regnamelen && strncmp (regname, reg_table[i].name, rlen) == 0)
 393         {
 394           regno = reg_table[i].regno;
 395           break;
 396         }
 397     }
 398   if (regno == -1)
 399     return;
 400
 401   /* Copy the hex value to a buffer and eliminate the embedded space. */
 402   for (i = 0, p = valbuf; i < vallen; i++)
 403     if (val[i] != ' ')
 404       *p++ = val[i];
 405   *p = '\0';
 406
 407   monitor_supply_register (regno, valbuf);
 408 }
 409
 410
 411 /* Fetch the BadVaddr register.  Unlike the other registers, this
 412    one can't be modified, and the monitor won't even prompt to let
 413    you modify it.  */
 414
 415 static void
 416 fetch_bad_vaddr (void)
 417 {
 418   char buf[20];
 419
 420   monitor_printf ("xB\r");
 421   monitor_expect ("BadV=", NULL, 0);
 422   monitor_expect_prompt (buf, sizeof (buf));
 423   monitor_supply_register (BADVADDR_REGNUM, buf);
 424 }
 425
 426
 427 /* Read a series of bit fields from the monitor, and return their
 428    combined binary value.  */
 429
 430 static unsigned long
 431 fetch_fields (struct bit_field *bf)
 432 {
 433   char buf[20];
 434   unsigned long val = 0;
 435   unsigned long bits;
 436
 437   for (; bf->prefix != NULL; bf++)
 438     {
 439       monitor_expect (bf->prefix, NULL, 0);     /* get prefix */
 440       monitor_expect (bf->suffix, buf, sizeof (buf));   /* hex value, suffix */
 441       if (bf->length != 0)
 442         {
 443           bits = strtoul (buf, NULL, 16);       /* get field value */
 444           bits &= ((1 << bf->length) - 1);      /* mask out useless bits */
 445           val |= bits << bf->start;     /* insert into register */
 446         }
 447
 448     }
 449
 450   return val;
 451 }
 452
 453
 454 static void
 455 fetch_bitmapped_register (int regno, struct bit_field *bf)
 456 {
 457   unsigned long val;
 458   unsigned char regbuf[MAX_REGISTER_RAW_SIZE];
 459
 460   monitor_printf ("x%s\r", r3900_regnames[regno]);
 461   val = fetch_fields (bf);
 462   monitor_printf (".\r");
 463   monitor_expect_prompt (NULL, 0);
 464
 465   /* supply register stores in target byte order, so swap here */
 466
 467   store_unsigned_integer (regbuf, REGISTER_RAW_SIZE (regno), val);
 468   supply_register (regno, regbuf);
 469
 470 }
 471
 472
 473 /* Fetch all registers (if regno is -1), or one register from the
 474    monitor.  For most registers, we can use the generic monitor_
 475    monitor_fetch_registers function.  But others are displayed in
 476    a very unusual fashion by the monitor, and must be handled specially.  */
 477
 478 static void
 479 r3900_fetch_registers (int regno)
 480 {
 481   switch (regno)
 482     {
 483     case BADVADDR_REGNUM:
 484       fetch_bad_vaddr ();
 485       return;
 486     case PS_REGNUM:
 487       fetch_bitmapped_register (PS_REGNUM, status_fields);
 488       return;
 489     case CAUSE_REGNUM:
 490       fetch_bitmapped_register (CAUSE_REGNUM, cause_fields);
 491       return;
 492     default:
 493       orig_monitor_fetch_registers (regno);
 494     }
 495 }
 496
 497
 498 /* Write the new value of the bitmapped register to the monitor.  */
 499
 500 static void
 501 store_bitmapped_register (int regno, struct bit_field *bf)
 502 {
 503   unsigned long oldval, newval;
 504
 505   /* Fetch the current value of the register.  */
 506   monitor_printf ("x%s\r", r3900_regnames[regno]);
 507   oldval = fetch_fields (bf);
 508   newval = read_register (regno);
 509
 510   /* To save time, write just the fields that have changed.  */
 511   for (; bf->prefix != NULL; bf++)
 512     {
 513       if (bf->length != 0)
 514         {
 515           unsigned long oldbits, newbits, mask;
 516
 517           mask = (1 << bf->length) - 1;
 518           oldbits = (oldval >> bf->start) & mask;
 519           newbits = (newval >> bf->start) & mask;
 520           if (oldbits != newbits)
 521             monitor_printf ("%s %lx ", bf->user_name, newbits);
 522         }
 523     }
 524
 525   monitor_printf (".\r");
 526   monitor_expect_prompt (NULL, 0);
 527 }
 528
 529
 530 static void
 531 r3900_store_registers (int regno)
 532 {
 533   switch (regno)
 534     {
 535     case PS_REGNUM:
 536       store_bitmapped_register (PS_REGNUM, status_fields);
 537       return;
 538     case CAUSE_REGNUM:
 539       store_bitmapped_register (CAUSE_REGNUM, cause_fields);
 540       return;
 541     default:
 542       orig_monitor_store_registers (regno);
 543     }
 544 }
 545
 546
 547 /* Write a 4-byte integer to the buffer in big-endian order.  */
 548
 549 static void
 550 write_long (char *buf, long n)
 551 {
 552   buf[0] = (n >> 24) & 0xff;
 553   buf[1] = (n >> 16) & 0xff;
 554   buf[2] = (n >> 8) & 0xff;
 555   buf[3] = n & 0xff;
 556 }
 557
 558
 559 /* Write a 4-byte integer to the buffer in little-endian order.  */
 560
 561 static void
 562 write_long_le (char *buf, long n)
 563 {
 564   buf[0] = n & 0xff;
 565   buf[1] = (n >> 8) & 0xff;
 566   buf[2] = (n >> 16) & 0xff;
 567   buf[3] = (n >> 24) & 0xff;
 568 }
 569
 570
 571 /* Read a character from the monitor.  If remote debugging is on,
 572    print the received character.  If HEX is non-zero, print the
 573    character in hexadecimal; otherwise, print it in ASCII.  */
 574
 575 static int
 576 debug_readchar (int hex)
 577 {
 578   char buf[10];
 579   int c = monitor_readchar ();
 580
 581   if (remote_debug > 0)
 582     {
 583       if (hex)
 584         sprintf (buf, "[%02x]", c & 0xff);
 585       else if (c == '\0')
 586         strcpy (buf, "\\0");
 587       else
 588         {
 589           buf[0] = c;
 590           buf[1] = '\0';
 591         }
 592       puts_debug ("Read -->", buf, "<--");
 593     }
 594   return c;
 595 }
 596
 597
 598 /* Send a buffer of characters to the monitor.  If remote debugging is on,
 599    print the sent buffer in hex.  */
 600
 601 static void
 602 debug_write (unsigned char *buf, int buflen)
 603 {
 604   char s[10];
 605
 606   monitor_write (buf, buflen);
 607
 608   if (remote_debug > 0)
 609     {
 610       while (buflen-- > 0)
 611         {
 612           sprintf (s, "[%02x]", *buf & 0xff);
 613           puts_debug ("Sent -->", s, "<--");
 614           buf++;
 615         }
 616     }
 617 }
 618
 619
 620 /* Ignore a packet sent to us by the monitor.  It send packets
 621    when its console is in "communications interface" mode.   A packet
 622    is of this form:
 623
 624    start of packet flag (one byte: 0xdc)
 625    packet type (one byte)
 626    length (low byte)
 627    length (high byte)
 628    data (length bytes)
 629
 630    The last two bytes of the data field are a checksum, but we don't
 631    bother to verify it.
 632  */
 633
 634 static void
 635 ignore_packet (void)
 636 {
 637   int c;
 638   int len;
 639
 640   /* Ignore lots of trash (messages about section addresses, for example)
 641      until we see the start of a packet.  */
 642   for (len = 0; len < 256; len++)
 643     {
 644       c = debug_readchar (0);
 645       if (c == PESC)
 646         break;
 647     }
 648   if (len == 8)
 649     error ("Packet header byte not found; %02x seen instead.", c);
 650
 651   /* Read the packet type and length.  */
 652   c = debug_readchar (1);       /* type */
 653
 654   c = debug_readchar (1);       /* low byte of length */
 655   len = c & 0xff;
 656
 657   c = debug_readchar (1);       /* high byte of length */
 658   len += (c & 0xff) << 8;
 659
 660   /* Ignore the rest of the packet.  */
 661   while (len-- > 0)
 662     c = debug_readchar (1);
 663 }
 664
 665
 666 /* Encapsulate some data into a packet and send it to the monitor.
 667
 668    The 'p' packet is a special case.  This is a packet we send
 669    in response to a read ('r') packet from the monitor.  This function
 670    appends a one-byte sequence number to the data field of such a packet.
 671  */
 672
 673 static void
 674 send_packet (char type, unsigned char *buf, int buflen, int seq)
 675 {
 676   unsigned char hdr[4];
 677   int len = buflen;
 678   int sum, i;
 679
 680   /* If this is a 'p' packet, add one byte for a sequence number.  */
 681   if (type == 'p')
 682     len++;
 683
 684   /* If the buffer has a non-zero length, add two bytes for a checksum.  */
 685   if (len > 0)
 686     len += 2;
 687
 688   /* Write the packet header.  */
 689   hdr[0] = PESC;
 690   hdr[1] = type;
 691   hdr[2] = len & 0xff;
 692   hdr[3] = (len >> 8) & 0xff;
 693   debug_write (hdr, sizeof (hdr));
 694
 695   if (len)
 696     {
 697       /* Write the packet data.  */
 698       debug_write (buf, buflen);
 699
 700       /* Write the sequence number if this is a 'p' packet.  */
 701       if (type == 'p')
 702         {
 703           hdr[0] = seq;
 704           debug_write (hdr, 1);
 705         }
 706
 707       /* Write the checksum.  */
 708       sum = 0;
 709       for (i = 0; i < buflen; i++)
 710         {
 711           int tmp = (buf[i] & 0xff);
 712           if (i & 1)
 713             sum += tmp;
 714           else
 715             sum += tmp << 8;
 716         }
 717       if (type == 'p')
 718         {
 719           if (buflen & 1)
 720             sum += (seq & 0xff);
 721           else
 722             sum += (seq & 0xff) << 8;
 723         }
 724       sum = (sum & 0xffff) + ((sum >> 16) & 0xffff);
 725       sum += (sum >> 16) & 1;
 726       sum = ~sum;
 727
 728       hdr[0] = (sum >> 8) & 0xff;
 729       hdr[1] = sum & 0xff;
 730       debug_write (hdr, 2);
 731     }
 732 }
 733
 734
 735 /* Respond to an expected read request from the monitor by sending
 736    data in chunks.  Handle all acknowledgements and handshaking packets.
 737
 738    The monitor expects a response consisting of a one or more 'p' packets,
 739    each followed by a portion of the data requested.  The 'p' packet
 740    contains only a four-byte integer, the value of which is the number
 741    of bytes of data we are about to send.  Following the 'p' packet,
 742    the monitor expects the data bytes themselves in raw, unpacketized,
 743    form, without even a checksum.
 744  */
 745
 746 static void
 747 process_read_request (unsigned char *buf, int buflen)
 748 {
 749   unsigned char len[4];
 750   int i, chunk;
 751   unsigned char seq;
 752
 753   /* Discard the read request.  FIXME: we have to hope it's for
 754      the exact number of bytes we want to send; should check for this.  */
 755   ignore_packet ();
 756
 757   for (i = chunk = 0, seq = 0; i < buflen; i += chunk, seq++)
 758     {
 759       /* Don't send more than MAXPSIZE bytes at a time.  */
 760       chunk = buflen - i;
 761       if (chunk > MAXPSIZE)
 762         chunk = MAXPSIZE;
 763
 764       /* Write a packet containing the number of bytes we are sending.  */
 765       write_long_le (len, chunk);
 766       send_packet ('p', len, sizeof (len), seq);
 767
 768       /* Write the data in raw form following the packet.  */
 769       debug_write (&buf[i], chunk);
 770
 771       /* Discard the ACK packet.  */
 772       ignore_packet ();
 773     }
 774
 775   /* Send an "end of data" packet.  */
 776   send_packet ('e', "", 0, 0);
 777 }
 778
 779
 780 /* Count loadable sections (helper function for r3900_load).  */
 781
 782 static void
 783 count_section (bfd *abfd, asection *s, unsigned int *section_count)
 784 {
 785   if (s->flags & SEC_LOAD && bfd_section_size (abfd, s) != 0)
 786     (*section_count)++;
 787 }
 788
 789
 790 /* Load a single BFD section (helper function for r3900_load).
 791
 792    WARNING: this code is filled with assumptions about how
 793    the Densan monitor loads programs.  The monitor issues
 794    packets containing read requests, but rather than respond
 795    to them in an general way, we expect them to following
 796    a certain pattern.
 797
 798    For example, we know that the monitor will start loading by
 799    issuing an 8-byte read request for the binary file header.
 800    We know this is coming and ignore the actual contents
 801    of the read request packet.
 802  */
 803
 804 static void
 805 load_section (bfd *abfd, asection *s, unsigned int *data_count)
 806 {
 807   if (s->flags & SEC_LOAD)
 808     {
 809       bfd_size_type section_size = bfd_section_size (abfd, s);
 810       bfd_vma section_base = bfd_section_lma (abfd, s);
 811       unsigned char *buffer;
 812       unsigned char header[8];
 813
 814       /* Don't output zero-length sections.  */
 815       if (section_size == 0)
 816         return;
 817       if (data_count)
 818         *data_count += section_size;
 819
 820       /* Print some fluff about the section being loaded.  */
 821       printf_filtered ("Loading section %s, size 0x%lx lma ",
 822                        bfd_section_name (abfd, s), (long) section_size);
 823       print_address_numeric (section_base, 1, gdb_stdout);
 824       printf_filtered ("\n");
 825       gdb_flush (gdb_stdout);
 826
 827       /* Write the section header (location and size).  */
 828       write_long (&header[0], (long) section_base);
 829       write_long (&header[4], (long) section_size);
 830       process_read_request (header, sizeof (header));
 831
 832       /* Read the section contents into a buffer, write it out,
 833          then free the buffer.  */
 834       buffer = (unsigned char *) xmalloc (section_size);
 835       bfd_get_section_contents (abfd, s, buffer, 0, section_size);
 836       process_read_request (buffer, section_size);
 837       xfree (buffer);
 838     }
 839 }
 840
 841
 842 /* When the ethernet is used as the console port on the Densan board,
 843    we can use the "Rm" command to do a fast binary load.  The format
 844    of the download data is:
 845
 846    number of sections (4 bytes)
 847    starting address (4 bytes)
 848    repeat for each section:
 849    location address (4 bytes)
 850    section size (4 bytes)
 851    binary data
 852
 853    The 4-byte fields are all in big-endian order.
 854
 855    Using this command is tricky because we have to put the monitor
 856    into a special funky "communications interface" mode, in which
 857    it sends and receives packets of data along with the normal prompt.
 858  */
 859
 860 static void
 861 r3900_load (char *filename, int from_tty)
 862 {
 863   bfd *abfd;
 864   unsigned int data_count = 0;
 865   time_t start_time, end_time;  /* for timing of download */
 866   int section_count = 0;
 867   unsigned char buffer[8];
 868
 869   /* If we are not using the ethernet, use the normal monitor load,
 870      which sends S-records over the serial link.  */
 871   if (!ethernet)
 872     {
 873       orig_monitor_load (filename, from_tty);
 874       return;
 875     }
 876
 877   /* Open the file.  */
 878   if (filename == NULL || filename[0] == 0)
 879     filename = get_exec_file (1);
 880   abfd = bfd_openr (filename, 0);
 881   if (!abfd)
 882     error ("Unable to open file %s\n", filename);
 883   if (bfd_check_format (abfd, bfd_object) == 0)
 884     error ("File is not an object file\n");
 885
 886   /* Output the "vconsi" command to get the monitor in the communication
 887      state where it will accept a load command.  This will cause
 888      the monitor to emit a packet before each prompt, so ignore the packet.  */
 889   monitor_printf ("vconsi\r");
 890   ignore_packet ();
 891   monitor_expect_prompt (NULL, 0);
 892
 893   /* Output the "Rm" (load) command and respond to the subsequent "open"
 894      packet by sending an ACK packet.  */
 895   monitor_printf ("Rm\r");
 896   ignore_packet ();
 897   send_packet ('a', "", 0, 0);
 898
 899   /* Output the fast load header (number of sections and starting address).  */
 900   bfd_map_over_sections ((bfd *) abfd, (section_map_func) count_section,
 901                          &section_count);
 902   write_long (&buffer[0], (long) section_count);
 903   if (exec_bfd)
 904     write_long (&buffer[4], (long) bfd_get_start_address (exec_bfd));
 905   else
 906     write_long (&buffer[4], 0);
 907   process_read_request (buffer, sizeof (buffer));
 908
 909   /* Output the section data.  */
 910   start_time = time (NULL);
 911   bfd_map_over_sections (abfd, (section_map_func) load_section, &data_count);
 912   end_time = time (NULL);
 913
 914   /* Acknowledge the close packet and put the monitor back into
 915      "normal" mode so it won't send packets any more.  */
 916   ignore_packet ();
 917   send_packet ('a', "", 0, 0);
 918   monitor_expect_prompt (NULL, 0);
 919   monitor_printf ("vconsx\r");
 920   monitor_expect_prompt (NULL, 0);
 921
 922   /* Print start address and download performance information.  */
 923   printf_filtered ("Start address 0x%lx\n", (long) bfd_get_start_address (abfd));
 924   report_transfer_performance (data_count, start_time, end_time);
 925
 926   /* Finally, make the PC point at the start address */
 927   if (exec_bfd)
 928     write_pc (bfd_get_start_address (exec_bfd));
 929
 930   inferior_pid = 0;             /* No process now */
 931
 932   /* This is necessary because many things were based on the PC at the
 933      time that we attached to the monitor, which is no longer valid
 934      now that we have loaded new code (and just changed the PC).
 935      Another way to do this might be to call normal_stop, except that
 936      the stack may not be valid, and things would get horribly
 937      confused... */
 938   clear_symtab_users ();
 939 }
 940
 941
 942 /* Commands to send to the monitor when first connecting:
 943    * The bare carriage return forces a prompt from the monitor
 944    (monitor doesn't prompt immediately after a reset).
 945    * The "vconsx" switches the monitor back to interactive mode
 946    in case an aborted download had left it in packet mode.
 947    * The "Xtr" command causes subsequent "t" (trace) commands to display
 948    the general registers only.
 949    * The "Xxr" command does the same thing for the "x" (examine
 950    registers) command.
 951    * The "bx" command clears all breakpoints.
 952  */
 953
 954 static char *r3900_inits[] =
 955 {"\r", "vconsx\r", "Xtr\r", "Xxr\r", "bx\r", NULL};
 956 static char *dummy_inits[] =
 957 {NULL};
 958
 959 static struct target_ops r3900_ops;
 960 static struct monitor_ops r3900_cmds;
 961
 962 static void
 963 r3900_open (char *args, int from_tty)
 964 {
 965   char buf[64];
 966   int i;
 967
 968   monitor_open (args, &r3900_cmds, from_tty);
 969
 970   /* We have to handle sending the init strings ourselves, because
 971      the first two strings we send (carriage returns) may not be echoed
 972      by the monitor, but the rest will be.  */
 973   monitor_printf_noecho ("\r\r");
 974   for (i = 0; r3900_inits[i] != NULL; i++)
 975     {
 976       monitor_printf (r3900_inits[i]);
 977       monitor_expect_prompt (NULL, 0);
 978     }
 979
 980   /* Attempt to determine whether the console device is ethernet or serial.
 981      This will tell us which kind of load to use (S-records over a serial
 982      link, or the Densan fast binary multi-section format over the net).  */
 983
 984   ethernet = 0;
 985   monitor_printf ("v\r");
 986   if (monitor_expect ("console device :", NULL, 0) != -1)
 987     if (monitor_expect ("\n", buf, sizeof (buf)) != -1)
 988       if (strstr (buf, "ethernet") != NULL)
 989         ethernet = 1;
 990   monitor_expect_prompt (NULL, 0);
 991 }
 992
 993 void
 994 _initialize_r3900_rom (void)
 995 {
 996   r3900_cmds.flags = MO_NO_ECHO_ON_OPEN |
 997     MO_ADDR_BITS_REMOVE |
 998     MO_CLR_BREAK_USES_ADDR |
 999     MO_GETMEM_READ_SINGLE |
1000     MO_PRINT_PROGRAM_OUTPUT;
1001
1002   r3900_cmds.init = dummy_inits;
1003   r3900_cmds.cont = "g\r";
1004   r3900_cmds.step = "t\r";
1005   r3900_cmds.set_break = "b %A\r";      /* COREADDR */
1006   r3900_cmds.clr_break = "b %A,0\r";    /* COREADDR */
1007   r3900_cmds.fill = "fx %A s %x %x\r";  /* COREADDR, len, val */
1008
1009   r3900_cmds.setmem.cmdb = "sx %A %x\r";        /* COREADDR, val */
1010   r3900_cmds.setmem.cmdw = "sh %A %x\r";        /* COREADDR, val */
1011   r3900_cmds.setmem.cmdl = "sw %A %x\r";        /* COREADDR, val */
1012
1013   r3900_cmds.getmem.cmdb = "sx %A\r";   /* COREADDR */
1014   r3900_cmds.getmem.cmdw = "sh %A\r";   /* COREADDR */
1015   r3900_cmds.getmem.cmdl = "sw %A\r";   /* COREADDR */
1016   r3900_cmds.getmem.resp_delim = " : ";
1017   r3900_cmds.getmem.term = " ";
1018   r3900_cmds.getmem.term_cmd = ".\r";
1019
1020   r3900_cmds.setreg.cmd = "x%s %x\r";   /* regname, val */
1021
1022   r3900_cmds.getreg.cmd = "x%s\r";      /* regname */
1023   r3900_cmds.getreg.resp_delim = "=";
1024   r3900_cmds.getreg.term = " ";
1025   r3900_cmds.getreg.term_cmd = ".\r";
1026
1027   r3900_cmds.dump_registers = "x\r";
1028   r3900_cmds.register_pattern =
1029     "\\([a-zA-Z0-9_]+\\) *=\\([0-9a-f]+ [0-9a-f]+\\b\\)";
1030   r3900_cmds.supply_register = r3900_supply_register;
1031   /* S-record download, via "keyboard port".  */
1032   r3900_cmds.load = "r0\r";
1033   r3900_cmds.prompt = "#";
1034   r3900_cmds.line_term = "\r";
1035   r3900_cmds.target = &r3900_ops;
1036   r3900_cmds.stopbits = SERIAL_1_STOPBITS;
1037   r3900_cmds.regnames = r3900_regnames;
1038   r3900_cmds.magic = MONITOR_OPS_MAGIC;
1039
1040   init_monitor_ops (&r3900_ops);
1041
1042   r3900_ops.to_shortname = "r3900";
1043   r3900_ops.to_longname = "R3900 monitor";
1044   r3900_ops.to_doc = "Debug using the DVE R3900 monitor.\n\
1045 Specify the serial device it is connected to (e.g. /dev/ttya).";
1046   r3900_ops.to_open = r3900_open;
1047
1048   /* Override the functions to fetch and store registers.  But save the
1049      addresses of the default functions, because we will use those functions
1050      for "normal" registers.  */
1051
1052   orig_monitor_fetch_registers = r3900_ops.to_fetch_registers;
1053   orig_monitor_store_registers = r3900_ops.to_store_registers;
1054   r3900_ops.to_fetch_registers = r3900_fetch_registers;
1055   r3900_ops.to_store_registers = r3900_store_registers;
1056
1057   /* Override the load function, but save the address of the default
1058      function to use when loading S-records over a serial link.  */
1059   orig_monitor_load = r3900_ops.to_load;
1060   r3900_ops.to_load = r3900_load;
1061
1062   add_target (&r3900_ops);
1063 }