/* Remote debugging interface for Densan DVE-R3900 ROM monitor for
|
/* Remote debugging interface for Densan DVE-R3900 ROM monitor for
|
GDB, the GNU debugger.
|
GDB, the GNU debugger.
|
Copyright 1997 Free Software Foundation, Inc.
|
Copyright 1997 Free Software Foundation, Inc.
|
|
|
This file is part of GDB.
|
This file is part of GDB.
|
|
|
This program is free software; you can redistribute it and/or modify
|
This program is free software; you can redistribute it and/or modify
|
it under the terms of the GNU General Public License as published by
|
it under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 2 of the License, or
|
the Free Software Foundation; either version 2 of the License, or
|
(at your option) any later version.
|
(at your option) any later version.
|
|
|
This program is distributed in the hope that it will be useful,
|
This program is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with this program; if not, write to the Free Software
|
along with this program; if not, write to the Free Software
|
Foundation, Inc., 59 Temple Place - Suite 330,
|
Foundation, Inc., 59 Temple Place - Suite 330,
|
Boston, MA 02111-1307, USA. */
|
Boston, MA 02111-1307, USA. */
|
|
|
#include "defs.h"
|
#include "defs.h"
|
#include "gdbcore.h"
|
#include "gdbcore.h"
|
#include "target.h"
|
#include "target.h"
|
#include "monitor.h"
|
#include "monitor.h"
|
#include "serial.h"
|
#include "serial.h"
|
#include "inferior.h"
|
#include "inferior.h"
|
#include "command.h"
|
#include "command.h"
|
#include "gdb_string.h"
|
#include "gdb_string.h"
|
#include <time.h>
|
#include <time.h>
|
|
|
/* Type of function passed to bfd_map_over_sections. */
|
/* Type of function passed to bfd_map_over_sections. */
|
|
|
typedef void (*section_map_func) PARAMS ((bfd * abfd, asection * sect, PTR obj));
|
typedef void (*section_map_func) PARAMS ((bfd * abfd, asection * sect, PTR obj));
|
|
|
/* Packet escape character used by Densan monitor. */
|
/* Packet escape character used by Densan monitor. */
|
|
|
#define PESC 0xdc
|
#define PESC 0xdc
|
|
|
/* Maximum packet size. This is actually smaller than necessary
|
/* Maximum packet size. This is actually smaller than necessary
|
just to be safe. */
|
just to be safe. */
|
|
|
#define MAXPSIZE 1024
|
#define MAXPSIZE 1024
|
|
|
/* External functions. */
|
/* External functions. */
|
|
|
extern void report_transfer_performance PARAMS ((unsigned long,
|
extern void report_transfer_performance PARAMS ((unsigned long,
|
time_t, time_t));
|
time_t, time_t));
|
|
|
/* Certain registers are "bitmapped", in that the monitor can only display
|
/* Certain registers are "bitmapped", in that the monitor can only display
|
them or let the user modify them as a series of named bitfields.
|
them or let the user modify them as a series of named bitfields.
|
This structure describes a field in a bitmapped register. */
|
This structure describes a field in a bitmapped register. */
|
|
|
struct bit_field
|
struct bit_field
|
{
|
{
|
char *prefix; /* string appearing before the value */
|
char *prefix; /* string appearing before the value */
|
char *suffix; /* string appearing after the value */
|
char *suffix; /* string appearing after the value */
|
char *user_name; /* name used by human when entering field value */
|
char *user_name; /* name used by human when entering field value */
|
int length; /* number of bits in the field */
|
int length; /* number of bits in the field */
|
int start; /* starting (least significant) bit number of field */
|
int start; /* starting (least significant) bit number of field */
|
};
|
};
|
|
|
/* Local functions for register manipulation. */
|
/* Local functions for register manipulation. */
|
|
|
static void r3900_supply_register PARAMS ((char *regname, int regnamelen,
|
static void r3900_supply_register PARAMS ((char *regname, int regnamelen,
|
char *val, int vallen));
|
char *val, int vallen));
|
static void fetch_bad_vaddr PARAMS ((void));
|
static void fetch_bad_vaddr PARAMS ((void));
|
static unsigned long fetch_fields PARAMS ((struct bit_field * bf));
|
static unsigned long fetch_fields PARAMS ((struct bit_field * bf));
|
static void fetch_bitmapped_register PARAMS ((int regno,
|
static void fetch_bitmapped_register PARAMS ((int regno,
|
struct bit_field * bf));
|
struct bit_field * bf));
|
static void r3900_fetch_registers PARAMS ((int regno));
|
static void r3900_fetch_registers PARAMS ((int regno));
|
static void store_bitmapped_register PARAMS ((int regno,
|
static void store_bitmapped_register PARAMS ((int regno,
|
struct bit_field * bf));
|
struct bit_field * bf));
|
static void r3900_store_registers PARAMS ((int regno));
|
static void r3900_store_registers PARAMS ((int regno));
|
|
|
/* Local functions for fast binary loading. */
|
/* Local functions for fast binary loading. */
|
|
|
static void write_long PARAMS ((char *buf, long n));
|
static void write_long PARAMS ((char *buf, long n));
|
static void write_long_le PARAMS ((char *buf, long n));
|
static void write_long_le PARAMS ((char *buf, long n));
|
static int debug_readchar PARAMS ((int hex));
|
static int debug_readchar PARAMS ((int hex));
|
static void debug_write PARAMS ((unsigned char *buf, int buflen));
|
static void debug_write PARAMS ((unsigned char *buf, int buflen));
|
static void ignore_packet PARAMS ((void));
|
static void ignore_packet PARAMS ((void));
|
static void send_packet PARAMS ((char type, unsigned char *buf, int buflen,
|
static void send_packet PARAMS ((char type, unsigned char *buf, int buflen,
|
int seq));
|
int seq));
|
static void process_read_request PARAMS ((unsigned char *buf, int buflen));
|
static void process_read_request PARAMS ((unsigned char *buf, int buflen));
|
static void count_section PARAMS ((bfd * abfd, asection * s,
|
static void count_section PARAMS ((bfd * abfd, asection * s,
|
unsigned int *section_count));
|
unsigned int *section_count));
|
static void load_section PARAMS ((bfd * abfd, asection * s,
|
static void load_section PARAMS ((bfd * abfd, asection * s,
|
unsigned int *data_count));
|
unsigned int *data_count));
|
static void r3900_load PARAMS ((char *filename, int from_tty));
|
static void r3900_load PARAMS ((char *filename, int from_tty));
|
|
|
/* Miscellaneous local functions. */
|
/* Miscellaneous local functions. */
|
|
|
static void r3900_open PARAMS ((char *args, int from_tty));
|
static void r3900_open PARAMS ((char *args, int from_tty));
|
|
|
|
|
/* Pointers to static functions in monitor.c for fetching and storing
|
/* Pointers to static functions in monitor.c for fetching and storing
|
registers. We can't use these function in certain cases where the Densan
|
registers. We can't use these function in certain cases where the Densan
|
monitor acts perversely: for registers that it displays in bit-map
|
monitor acts perversely: for registers that it displays in bit-map
|
format, and those that can't be modified at all. In those cases
|
format, and those that can't be modified at all. In those cases
|
we have to use our own functions to fetch and store their values. */
|
we have to use our own functions to fetch and store their values. */
|
|
|
static void (*orig_monitor_fetch_registers) PARAMS ((int regno));
|
static void (*orig_monitor_fetch_registers) PARAMS ((int regno));
|
static void (*orig_monitor_store_registers) PARAMS ((int regno));
|
static void (*orig_monitor_store_registers) PARAMS ((int regno));
|
|
|
/* Pointer to static function in monitor. for loading programs.
|
/* Pointer to static function in monitor. for loading programs.
|
We use this function for loading S-records via the serial link. */
|
We use this function for loading S-records via the serial link. */
|
|
|
static void (*orig_monitor_load) PARAMS ((char *file, int from_tty));
|
static void (*orig_monitor_load) PARAMS ((char *file, int from_tty));
|
|
|
/* This flag is set if a fast ethernet download should be used. */
|
/* This flag is set if a fast ethernet download should be used. */
|
|
|
static int ethernet = 0;
|
static int ethernet = 0;
|
|
|
/* This array of registers needs to match the indexes used by GDB. The
|
/* This array of registers needs to match the indexes used by GDB. The
|
whole reason this exists is because the various ROM monitors use
|
whole reason this exists is because the various ROM monitors use
|
different names than GDB does, and don't support all the registers
|
different names than GDB does, and don't support all the registers
|
either. */
|
either. */
|
|
|
static char *r3900_regnames[NUM_REGS] =
|
static char *r3900_regnames[NUM_REGS] =
|
{
|
{
|
"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
|
"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
|
"r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
|
"r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
|
"r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
|
"r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
|
"r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
|
"r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
|
|
|
"S", /* PS_REGNUM */
|
"S", /* PS_REGNUM */
|
"l", /* LO_REGNUM */
|
"l", /* LO_REGNUM */
|
"h", /* HI_REGNUM */
|
"h", /* HI_REGNUM */
|
"B", /* BADVADDR_REGNUM */
|
"B", /* BADVADDR_REGNUM */
|
"Pcause", /* CAUSE_REGNUM */
|
"Pcause", /* CAUSE_REGNUM */
|
"p" /* PC_REGNUM */
|
"p" /* PC_REGNUM */
|
};
|
};
|
|
|
|
|
/* Table of register names produced by monitor's register dump command. */
|
/* Table of register names produced by monitor's register dump command. */
|
|
|
static struct reg_entry
|
static struct reg_entry
|
{
|
{
|
char *name;
|
char *name;
|
int regno;
|
int regno;
|
}
|
}
|
reg_table[] =
|
reg_table[] =
|
{
|
{
|
{
|
{
|
"r0_zero", 0
|
"r0_zero", 0
|
}
|
}
|
,
|
,
|
{
|
{
|
"r1_at", 1
|
"r1_at", 1
|
}
|
}
|
,
|
,
|
{
|
{
|
"r2_v0", 2
|
"r2_v0", 2
|
}
|
}
|
,
|
,
|
{
|
{
|
"r3_v1", 3
|
"r3_v1", 3
|
}
|
}
|
,
|
,
|
{
|
{
|
"r4_a0", 4
|
"r4_a0", 4
|
}
|
}
|
,
|
,
|
{
|
{
|
"r5_a1", 5
|
"r5_a1", 5
|
}
|
}
|
,
|
,
|
{
|
{
|
"r6_a2", 6
|
"r6_a2", 6
|
}
|
}
|
,
|
,
|
{
|
{
|
"r7_a3", 7
|
"r7_a3", 7
|
}
|
}
|
,
|
,
|
{
|
{
|
"r8_t0", 8
|
"r8_t0", 8
|
}
|
}
|
,
|
,
|
{
|
{
|
"r9_t1", 9
|
"r9_t1", 9
|
}
|
}
|
,
|
,
|
{
|
{
|
"r10_t2", 10
|
"r10_t2", 10
|
}
|
}
|
,
|
,
|
{
|
{
|
"r11_t3", 11
|
"r11_t3", 11
|
}
|
}
|
,
|
,
|
{
|
{
|
"r12_t4", 12
|
"r12_t4", 12
|
}
|
}
|
,
|
,
|
{
|
{
|
"r13_t5", 13
|
"r13_t5", 13
|
}
|
}
|
,
|
,
|
{
|
{
|
"r14_t6", 14
|
"r14_t6", 14
|
}
|
}
|
,
|
,
|
{
|
{
|
"r15_t7", 15
|
"r15_t7", 15
|
}
|
}
|
,
|
,
|
{
|
{
|
"r16_s0", 16
|
"r16_s0", 16
|
}
|
}
|
,
|
,
|
{
|
{
|
"r17_s1", 17
|
"r17_s1", 17
|
}
|
}
|
,
|
,
|
{
|
{
|
"r18_s2", 18
|
"r18_s2", 18
|
}
|
}
|
,
|
,
|
{
|
{
|
"r19_s3", 19
|
"r19_s3", 19
|
}
|
}
|
,
|
,
|
{
|
{
|
"r20_s4", 20
|
"r20_s4", 20
|
}
|
}
|
,
|
,
|
{
|
{
|
"r21_s5", 21
|
"r21_s5", 21
|
}
|
}
|
,
|
,
|
{
|
{
|
"r22_s6", 22
|
"r22_s6", 22
|
}
|
}
|
,
|
,
|
{
|
{
|
"r23_s7", 23
|
"r23_s7", 23
|
}
|
}
|
,
|
,
|
{
|
{
|
"r24_t8", 24
|
"r24_t8", 24
|
}
|
}
|
,
|
,
|
{
|
{
|
"r25_t9", 25
|
"r25_t9", 25
|
}
|
}
|
,
|
,
|
{
|
{
|
"r26_k0", 26
|
"r26_k0", 26
|
}
|
}
|
,
|
,
|
{
|
{
|
"r27_k1", 27
|
"r27_k1", 27
|
}
|
}
|
,
|
,
|
{
|
{
|
"r28_gp", 28
|
"r28_gp", 28
|
}
|
}
|
,
|
,
|
{
|
{
|
"r29_sp", 29
|
"r29_sp", 29
|
}
|
}
|
,
|
,
|
{
|
{
|
"r30_fp", 30
|
"r30_fp", 30
|
}
|
}
|
,
|
,
|
{
|
{
|
"r31_ra", 31
|
"r31_ra", 31
|
}
|
}
|
,
|
,
|
{
|
{
|
"HI", HI_REGNUM
|
"HI", HI_REGNUM
|
}
|
}
|
,
|
,
|
{
|
{
|
"LO", LO_REGNUM
|
"LO", LO_REGNUM
|
}
|
}
|
,
|
,
|
{
|
{
|
"PC", PC_REGNUM
|
"PC", PC_REGNUM
|
}
|
}
|
,
|
,
|
{
|
{
|
"BadV", BADVADDR_REGNUM
|
"BadV", BADVADDR_REGNUM
|
}
|
}
|
,
|
,
|
{
|
{
|
NULL, 0
|
NULL, 0
|
}
|
}
|
};
|
};
|
|
|
|
|
/* The monitor displays the cache register along with the status register,
|
/* The monitor displays the cache register along with the status register,
|
as if they were a single register. So when we want to fetch the
|
as if they were a single register. So when we want to fetch the
|
status register, parse but otherwise ignore the fields of the
|
status register, parse but otherwise ignore the fields of the
|
cache register that the monitor displays. Register fields that should
|
cache register that the monitor displays. Register fields that should
|
be ignored have a length of zero in the tables below. */
|
be ignored have a length of zero in the tables below. */
|
|
|
static struct bit_field status_fields[] =
|
static struct bit_field status_fields[] =
|
{
|
{
|
/* Status register portion */
|
/* Status register portion */
|
{"SR[<CU=", " ", "cu", 4, 28},
|
{"SR[<CU=", " ", "cu", 4, 28},
|
{"RE=", " ", "re", 1, 25},
|
{"RE=", " ", "re", 1, 25},
|
{"BEV=", " ", "bev", 1, 22},
|
{"BEV=", " ", "bev", 1, 22},
|
{"TS=", " ", "ts", 1, 21},
|
{"TS=", " ", "ts", 1, 21},
|
{"Nmi=", " ", "nmi", 1, 20},
|
{"Nmi=", " ", "nmi", 1, 20},
|
{"INT=", " ", "int", 6, 10},
|
{"INT=", " ", "int", 6, 10},
|
{"SW=", ">]", "sw", 2, 8},
|
{"SW=", ">]", "sw", 2, 8},
|
{"[<KUO=", " ", "kuo", 1, 5},
|
{"[<KUO=", " ", "kuo", 1, 5},
|
{"IEO=", " ", "ieo", 1, 4},
|
{"IEO=", " ", "ieo", 1, 4},
|
{"KUP=", " ", "kup", 1, 3},
|
{"KUP=", " ", "kup", 1, 3},
|
{"IEP=", " ", "iep", 1, 2},
|
{"IEP=", " ", "iep", 1, 2},
|
{"KUC=", " ", "kuc", 1, 1},
|
{"KUC=", " ", "kuc", 1, 1},
|
{"IEC=", ">]", "iec", 1, 0},
|
{"IEC=", ">]", "iec", 1, 0},
|
|
|
/* Cache register portion (dummy for parsing only) */
|
/* Cache register portion (dummy for parsing only) */
|
{"CR[<IalO=", " ", "ialo", 0, 13},
|
{"CR[<IalO=", " ", "ialo", 0, 13},
|
{"DalO=", " ", "dalo", 0, 12},
|
{"DalO=", " ", "dalo", 0, 12},
|
{"IalP=", " ", "ialp", 0, 11},
|
{"IalP=", " ", "ialp", 0, 11},
|
{"DalP=", " ", "dalp", 0, 10},
|
{"DalP=", " ", "dalp", 0, 10},
|
{"IalC=", " ", "ialc", 0, 9},
|
{"IalC=", " ", "ialc", 0, 9},
|
{"DalC=", ">] ", "dalc", 0, 8},
|
{"DalC=", ">] ", "dalc", 0, 8},
|
|
|
{NULL, NULL, 0, 0} /* end of table marker */
|
{NULL, NULL, 0, 0} /* end of table marker */
|
};
|
};
|
|
|
|
|
#if 0 /* FIXME: Enable when we add support for modifying cache register. */
|
#if 0 /* FIXME: Enable when we add support for modifying cache register. */
|
static struct bit_field cache_fields[] =
|
static struct bit_field cache_fields[] =
|
{
|
{
|
/* Status register portion (dummy for parsing only) */
|
/* Status register portion (dummy for parsing only) */
|
{"SR[<CU=", " ", "cu", 0, 28},
|
{"SR[<CU=", " ", "cu", 0, 28},
|
{"RE=", " ", "re", 0, 25},
|
{"RE=", " ", "re", 0, 25},
|
{"BEV=", " ", "bev", 0, 22},
|
{"BEV=", " ", "bev", 0, 22},
|
{"TS=", " ", "ts", 0, 21},
|
{"TS=", " ", "ts", 0, 21},
|
{"Nmi=", " ", "nmi", 0, 20},
|
{"Nmi=", " ", "nmi", 0, 20},
|
{"INT=", " ", "int", 0, 10},
|
{"INT=", " ", "int", 0, 10},
|
{"SW=", ">]", "sw", 0, 8},
|
{"SW=", ">]", "sw", 0, 8},
|
{"[<KUO=", " ", "kuo", 0, 5},
|
{"[<KUO=", " ", "kuo", 0, 5},
|
{"IEO=", " ", "ieo", 0, 4},
|
{"IEO=", " ", "ieo", 0, 4},
|
{"KUP=", " ", "kup", 0, 3},
|
{"KUP=", " ", "kup", 0, 3},
|
{"IEP=", " ", "iep", 0, 2},
|
{"IEP=", " ", "iep", 0, 2},
|
{"KUC=", " ", "kuc", 0, 1},
|
{"KUC=", " ", "kuc", 0, 1},
|
{"IEC=", ">]", "iec", 0, 0},
|
{"IEC=", ">]", "iec", 0, 0},
|
|
|
/* Cache register portion */
|
/* Cache register portion */
|
{"CR[<IalO=", " ", "ialo", 1, 13},
|
{"CR[<IalO=", " ", "ialo", 1, 13},
|
{"DalO=", " ", "dalo", 1, 12},
|
{"DalO=", " ", "dalo", 1, 12},
|
{"IalP=", " ", "ialp", 1, 11},
|
{"IalP=", " ", "ialp", 1, 11},
|
{"DalP=", " ", "dalp", 1, 10},
|
{"DalP=", " ", "dalp", 1, 10},
|
{"IalC=", " ", "ialc", 1, 9},
|
{"IalC=", " ", "ialc", 1, 9},
|
{"DalC=", ">] ", "dalc", 1, 8},
|
{"DalC=", ">] ", "dalc", 1, 8},
|
|
|
{NULL, NULL, NULL, 0, 0} /* end of table marker */
|
{NULL, NULL, NULL, 0, 0} /* end of table marker */
|
};
|
};
|
#endif
|
#endif
|
|
|
|
|
static struct bit_field cause_fields[] =
|
static struct bit_field cause_fields[] =
|
{
|
{
|
{"<BD=", " ", "bd", 1, 31},
|
{"<BD=", " ", "bd", 1, 31},
|
{"CE=", " ", "ce", 2, 28},
|
{"CE=", " ", "ce", 2, 28},
|
{"IP=", " ", "ip", 6, 10},
|
{"IP=", " ", "ip", 6, 10},
|
{"SW=", " ", "sw", 2, 8},
|
{"SW=", " ", "sw", 2, 8},
|
{"EC=", ">]", "ec", 5, 2},
|
{"EC=", ">]", "ec", 5, 2},
|
|
|
{NULL, NULL, NULL, 0, 0} /* end of table marker */
|
{NULL, NULL, NULL, 0, 0} /* end of table marker */
|
};
|
};
|
|
|
|
|
/* The monitor prints register values in the form
|
/* The monitor prints register values in the form
|
|
|
regname = xxxx xxxx
|
regname = xxxx xxxx
|
|
|
We look up the register name in a table, and remove the embedded space in
|
We look up the register name in a table, and remove the embedded space in
|
the hex value before passing it to monitor_supply_register. */
|
the hex value before passing it to monitor_supply_register. */
|
|
|
static void
|
static void
|
r3900_supply_register (regname, regnamelen, val, vallen)
|
r3900_supply_register (regname, regnamelen, val, vallen)
|
char *regname;
|
char *regname;
|
int regnamelen;
|
int regnamelen;
|
char *val;
|
char *val;
|
int vallen;
|
int vallen;
|
{
|
{
|
int regno = -1;
|
int regno = -1;
|
int i;
|
int i;
|
char valbuf[10];
|
char valbuf[10];
|
char *p;
|
char *p;
|
|
|
/* Perform some sanity checks on the register name and value. */
|
/* Perform some sanity checks on the register name and value. */
|
if (regnamelen < 2 || regnamelen > 7 || vallen != 9)
|
if (regnamelen < 2 || regnamelen > 7 || vallen != 9)
|
return;
|
return;
|
|
|
/* Look up the register name. */
|
/* Look up the register name. */
|
for (i = 0; reg_table[i].name != NULL; i++)
|
for (i = 0; reg_table[i].name != NULL; i++)
|
{
|
{
|
int rlen = strlen (reg_table[i].name);
|
int rlen = strlen (reg_table[i].name);
|
if (rlen == regnamelen && strncmp (regname, reg_table[i].name, rlen) == 0)
|
if (rlen == regnamelen && strncmp (regname, reg_table[i].name, rlen) == 0)
|
{
|
{
|
regno = reg_table[i].regno;
|
regno = reg_table[i].regno;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
if (regno == -1)
|
if (regno == -1)
|
return;
|
return;
|
|
|
/* Copy the hex value to a buffer and eliminate the embedded space. */
|
/* Copy the hex value to a buffer and eliminate the embedded space. */
|
for (i = 0, p = valbuf; i < vallen; i++)
|
for (i = 0, p = valbuf; i < vallen; i++)
|
if (val[i] != ' ')
|
if (val[i] != ' ')
|
*p++ = val[i];
|
*p++ = val[i];
|
*p = '\0';
|
*p = '\0';
|
|
|
monitor_supply_register (regno, valbuf);
|
monitor_supply_register (regno, valbuf);
|
}
|
}
|
|
|
|
|
/* Fetch the BadVaddr register. Unlike the other registers, this
|
/* Fetch the BadVaddr register. Unlike the other registers, this
|
one can't be modified, and the monitor won't even prompt to let
|
one can't be modified, and the monitor won't even prompt to let
|
you modify it. */
|
you modify it. */
|
|
|
static void
|
static void
|
fetch_bad_vaddr ()
|
fetch_bad_vaddr ()
|
{
|
{
|
char buf[20];
|
char buf[20];
|
|
|
monitor_printf ("xB\r");
|
monitor_printf ("xB\r");
|
monitor_expect ("BadV=", NULL, 0);
|
monitor_expect ("BadV=", NULL, 0);
|
monitor_expect_prompt (buf, sizeof (buf));
|
monitor_expect_prompt (buf, sizeof (buf));
|
monitor_supply_register (BADVADDR_REGNUM, buf);
|
monitor_supply_register (BADVADDR_REGNUM, buf);
|
}
|
}
|
|
|
|
|
/* Read a series of bit fields from the monitor, and return their
|
/* Read a series of bit fields from the monitor, and return their
|
combined binary value. */
|
combined binary value. */
|
|
|
static unsigned long
|
static unsigned long
|
fetch_fields (bf)
|
fetch_fields (bf)
|
struct bit_field *bf;
|
struct bit_field *bf;
|
{
|
{
|
char buf[20];
|
char buf[20];
|
unsigned long val = 0;
|
unsigned long val = 0;
|
unsigned long bits;
|
unsigned long bits;
|
|
|
for (; bf->prefix != NULL; bf++)
|
for (; bf->prefix != NULL; bf++)
|
{
|
{
|
monitor_expect (bf->prefix, NULL, 0); /* get prefix */
|
monitor_expect (bf->prefix, NULL, 0); /* get prefix */
|
monitor_expect (bf->suffix, buf, sizeof (buf)); /* hex value, suffix */
|
monitor_expect (bf->suffix, buf, sizeof (buf)); /* hex value, suffix */
|
if (bf->length != 0)
|
if (bf->length != 0)
|
{
|
{
|
bits = strtoul (buf, NULL, 16); /* get field value */
|
bits = strtoul (buf, NULL, 16); /* get field value */
|
bits &= ((1 << bf->length) - 1); /* mask out useless bits */
|
bits &= ((1 << bf->length) - 1); /* mask out useless bits */
|
val |= bits << bf->start; /* insert into register */
|
val |= bits << bf->start; /* insert into register */
|
}
|
}
|
|
|
}
|
}
|
|
|
return val;
|
return val;
|
}
|
}
|
|
|
|
|
static void
|
static void
|
fetch_bitmapped_register (regno, bf)
|
fetch_bitmapped_register (regno, bf)
|
int regno;
|
int regno;
|
struct bit_field *bf;
|
struct bit_field *bf;
|
{
|
{
|
unsigned long val;
|
unsigned long val;
|
unsigned char regbuf[MAX_REGISTER_RAW_SIZE];
|
unsigned char regbuf[MAX_REGISTER_RAW_SIZE];
|
|
|
monitor_printf ("x%s\r", r3900_regnames[regno]);
|
monitor_printf ("x%s\r", r3900_regnames[regno]);
|
val = fetch_fields (bf);
|
val = fetch_fields (bf);
|
monitor_printf (".\r");
|
monitor_printf (".\r");
|
monitor_expect_prompt (NULL, 0);
|
monitor_expect_prompt (NULL, 0);
|
|
|
/* supply register stores in target byte order, so swap here */
|
/* supply register stores in target byte order, so swap here */
|
|
|
store_unsigned_integer (regbuf, REGISTER_RAW_SIZE (regno), val);
|
store_unsigned_integer (regbuf, REGISTER_RAW_SIZE (regno), val);
|
supply_register (regno, regbuf);
|
supply_register (regno, regbuf);
|
|
|
}
|
}
|
|
|
|
|
/* Fetch all registers (if regno is -1), or one register from the
|
/* Fetch all registers (if regno is -1), or one register from the
|
monitor. For most registers, we can use the generic monitor_
|
monitor. For most registers, we can use the generic monitor_
|
monitor_fetch_registers function. But others are displayed in
|
monitor_fetch_registers function. But others are displayed in
|
a very unusual fashion by the monitor, and must be handled specially. */
|
a very unusual fashion by the monitor, and must be handled specially. */
|
|
|
static void
|
static void
|
r3900_fetch_registers (regno)
|
r3900_fetch_registers (regno)
|
int regno;
|
int regno;
|
{
|
{
|
switch (regno)
|
switch (regno)
|
{
|
{
|
case BADVADDR_REGNUM:
|
case BADVADDR_REGNUM:
|
fetch_bad_vaddr ();
|
fetch_bad_vaddr ();
|
return;
|
return;
|
case PS_REGNUM:
|
case PS_REGNUM:
|
fetch_bitmapped_register (PS_REGNUM, status_fields);
|
fetch_bitmapped_register (PS_REGNUM, status_fields);
|
return;
|
return;
|
case CAUSE_REGNUM:
|
case CAUSE_REGNUM:
|
fetch_bitmapped_register (CAUSE_REGNUM, cause_fields);
|
fetch_bitmapped_register (CAUSE_REGNUM, cause_fields);
|
return;
|
return;
|
default:
|
default:
|
orig_monitor_fetch_registers (regno);
|
orig_monitor_fetch_registers (regno);
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Write the new value of the bitmapped register to the monitor. */
|
/* Write the new value of the bitmapped register to the monitor. */
|
|
|
static void
|
static void
|
store_bitmapped_register (regno, bf)
|
store_bitmapped_register (regno, bf)
|
int regno;
|
int regno;
|
struct bit_field *bf;
|
struct bit_field *bf;
|
{
|
{
|
unsigned long oldval, newval;
|
unsigned long oldval, newval;
|
|
|
/* Fetch the current value of the register. */
|
/* Fetch the current value of the register. */
|
monitor_printf ("x%s\r", r3900_regnames[regno]);
|
monitor_printf ("x%s\r", r3900_regnames[regno]);
|
oldval = fetch_fields (bf);
|
oldval = fetch_fields (bf);
|
newval = read_register (regno);
|
newval = read_register (regno);
|
|
|
/* To save time, write just the fields that have changed. */
|
/* To save time, write just the fields that have changed. */
|
for (; bf->prefix != NULL; bf++)
|
for (; bf->prefix != NULL; bf++)
|
{
|
{
|
if (bf->length != 0)
|
if (bf->length != 0)
|
{
|
{
|
unsigned long oldbits, newbits, mask;
|
unsigned long oldbits, newbits, mask;
|
|
|
mask = (1 << bf->length) - 1;
|
mask = (1 << bf->length) - 1;
|
oldbits = (oldval >> bf->start) & mask;
|
oldbits = (oldval >> bf->start) & mask;
|
newbits = (newval >> bf->start) & mask;
|
newbits = (newval >> bf->start) & mask;
|
if (oldbits != newbits)
|
if (oldbits != newbits)
|
monitor_printf ("%s %lx ", bf->user_name, newbits);
|
monitor_printf ("%s %lx ", bf->user_name, newbits);
|
}
|
}
|
}
|
}
|
|
|
monitor_printf (".\r");
|
monitor_printf (".\r");
|
monitor_expect_prompt (NULL, 0);
|
monitor_expect_prompt (NULL, 0);
|
}
|
}
|
|
|
|
|
static void
|
static void
|
r3900_store_registers (regno)
|
r3900_store_registers (regno)
|
int regno;
|
int regno;
|
{
|
{
|
switch (regno)
|
switch (regno)
|
{
|
{
|
case PS_REGNUM:
|
case PS_REGNUM:
|
store_bitmapped_register (PS_REGNUM, status_fields);
|
store_bitmapped_register (PS_REGNUM, status_fields);
|
return;
|
return;
|
case CAUSE_REGNUM:
|
case CAUSE_REGNUM:
|
store_bitmapped_register (CAUSE_REGNUM, cause_fields);
|
store_bitmapped_register (CAUSE_REGNUM, cause_fields);
|
return;
|
return;
|
default:
|
default:
|
orig_monitor_store_registers (regno);
|
orig_monitor_store_registers (regno);
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Write a 4-byte integer to the buffer in big-endian order. */
|
/* Write a 4-byte integer to the buffer in big-endian order. */
|
|
|
static void
|
static void
|
write_long (buf, n)
|
write_long (buf, n)
|
char *buf;
|
char *buf;
|
long n;
|
long n;
|
{
|
{
|
buf[0] = (n >> 24) & 0xff;
|
buf[0] = (n >> 24) & 0xff;
|
buf[1] = (n >> 16) & 0xff;
|
buf[1] = (n >> 16) & 0xff;
|
buf[2] = (n >> 8) & 0xff;
|
buf[2] = (n >> 8) & 0xff;
|
buf[3] = n & 0xff;
|
buf[3] = n & 0xff;
|
}
|
}
|
|
|
|
|
/* Write a 4-byte integer to the buffer in little-endian order. */
|
/* Write a 4-byte integer to the buffer in little-endian order. */
|
|
|
static void
|
static void
|
write_long_le (buf, n)
|
write_long_le (buf, n)
|
char *buf;
|
char *buf;
|
long n;
|
long n;
|
{
|
{
|
buf[0] = n & 0xff;
|
buf[0] = n & 0xff;
|
buf[1] = (n >> 8) & 0xff;
|
buf[1] = (n >> 8) & 0xff;
|
buf[2] = (n >> 16) & 0xff;
|
buf[2] = (n >> 16) & 0xff;
|
buf[3] = (n >> 24) & 0xff;
|
buf[3] = (n >> 24) & 0xff;
|
}
|
}
|
|
|
|
|
/* Read a character from the monitor. If remote debugging is on,
|
/* Read a character from the monitor. If remote debugging is on,
|
print the received character. If HEX is non-zero, print the
|
print the received character. If HEX is non-zero, print the
|
character in hexadecimal; otherwise, print it in ASCII. */
|
character in hexadecimal; otherwise, print it in ASCII. */
|
|
|
static int
|
static int
|
debug_readchar (hex)
|
debug_readchar (hex)
|
int hex;
|
int hex;
|
{
|
{
|
char buf[10];
|
char buf[10];
|
int c = monitor_readchar ();
|
int c = monitor_readchar ();
|
|
|
if (remote_debug > 0)
|
if (remote_debug > 0)
|
{
|
{
|
if (hex)
|
if (hex)
|
sprintf (buf, "[%02x]", c & 0xff);
|
sprintf (buf, "[%02x]", c & 0xff);
|
else if (c == '\0')
|
else if (c == '\0')
|
strcpy (buf, "\\0");
|
strcpy (buf, "\\0");
|
else
|
else
|
{
|
{
|
buf[0] = c;
|
buf[0] = c;
|
buf[1] = '\0';
|
buf[1] = '\0';
|
}
|
}
|
puts_debug ("Read -->", buf, "<--");
|
puts_debug ("Read -->", buf, "<--");
|
}
|
}
|
return c;
|
return c;
|
}
|
}
|
|
|
|
|
/* Send a buffer of characters to the monitor. If remote debugging is on,
|
/* Send a buffer of characters to the monitor. If remote debugging is on,
|
print the sent buffer in hex. */
|
print the sent buffer in hex. */
|
|
|
static void
|
static void
|
debug_write (buf, buflen)
|
debug_write (buf, buflen)
|
unsigned char *buf;
|
unsigned char *buf;
|
int buflen;
|
int buflen;
|
{
|
{
|
char s[10];
|
char s[10];
|
|
|
monitor_write (buf, buflen);
|
monitor_write (buf, buflen);
|
|
|
if (remote_debug > 0)
|
if (remote_debug > 0)
|
{
|
{
|
while (buflen-- > 0)
|
while (buflen-- > 0)
|
{
|
{
|
sprintf (s, "[%02x]", *buf & 0xff);
|
sprintf (s, "[%02x]", *buf & 0xff);
|
puts_debug ("Sent -->", s, "<--");
|
puts_debug ("Sent -->", s, "<--");
|
buf++;
|
buf++;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Ignore a packet sent to us by the monitor. It send packets
|
/* Ignore a packet sent to us by the monitor. It send packets
|
when its console is in "communications interface" mode. A packet
|
when its console is in "communications interface" mode. A packet
|
is of this form:
|
is of this form:
|
|
|
start of packet flag (one byte: 0xdc)
|
start of packet flag (one byte: 0xdc)
|
packet type (one byte)
|
packet type (one byte)
|
length (low byte)
|
length (low byte)
|
length (high byte)
|
length (high byte)
|
data (length bytes)
|
data (length bytes)
|
|
|
The last two bytes of the data field are a checksum, but we don't
|
The last two bytes of the data field are a checksum, but we don't
|
bother to verify it.
|
bother to verify it.
|
*/
|
*/
|
|
|
static void
|
static void
|
ignore_packet ()
|
ignore_packet ()
|
{
|
{
|
int c;
|
int c;
|
int len;
|
int len;
|
|
|
/* Ignore lots of trash (messages about section addresses, for example)
|
/* Ignore lots of trash (messages about section addresses, for example)
|
until we see the start of a packet. */
|
until we see the start of a packet. */
|
for (len = 0; len < 256; len++)
|
for (len = 0; len < 256; len++)
|
{
|
{
|
c = debug_readchar (0);
|
c = debug_readchar (0);
|
if (c == PESC)
|
if (c == PESC)
|
break;
|
break;
|
}
|
}
|
if (len == 8)
|
if (len == 8)
|
error ("Packet header byte not found; %02x seen instead.", c);
|
error ("Packet header byte not found; %02x seen instead.", c);
|
|
|
/* Read the packet type and length. */
|
/* Read the packet type and length. */
|
c = debug_readchar (1); /* type */
|
c = debug_readchar (1); /* type */
|
|
|
c = debug_readchar (1); /* low byte of length */
|
c = debug_readchar (1); /* low byte of length */
|
len = c & 0xff;
|
len = c & 0xff;
|
|
|
c = debug_readchar (1); /* high byte of length */
|
c = debug_readchar (1); /* high byte of length */
|
len += (c & 0xff) << 8;
|
len += (c & 0xff) << 8;
|
|
|
/* Ignore the rest of the packet. */
|
/* Ignore the rest of the packet. */
|
while (len-- > 0)
|
while (len-- > 0)
|
c = debug_readchar (1);
|
c = debug_readchar (1);
|
}
|
}
|
|
|
|
|
/* Encapsulate some data into a packet and send it to the monitor.
|
/* Encapsulate some data into a packet and send it to the monitor.
|
|
|
The 'p' packet is a special case. This is a packet we send
|
The 'p' packet is a special case. This is a packet we send
|
in response to a read ('r') packet from the monitor. This function
|
in response to a read ('r') packet from the monitor. This function
|
appends a one-byte sequence number to the data field of such a packet.
|
appends a one-byte sequence number to the data field of such a packet.
|
*/
|
*/
|
|
|
static void
|
static void
|
send_packet (type, buf, buflen, seq)
|
send_packet (type, buf, buflen, seq)
|
char type;
|
char type;
|
unsigned char *buf;
|
unsigned char *buf;
|
int buflen, seq;
|
int buflen, seq;
|
{
|
{
|
unsigned char hdr[4];
|
unsigned char hdr[4];
|
int len = buflen;
|
int len = buflen;
|
int sum, i;
|
int sum, i;
|
|
|
/* If this is a 'p' packet, add one byte for a sequence number. */
|
/* If this is a 'p' packet, add one byte for a sequence number. */
|
if (type == 'p')
|
if (type == 'p')
|
len++;
|
len++;
|
|
|
/* If the buffer has a non-zero length, add two bytes for a checksum. */
|
/* If the buffer has a non-zero length, add two bytes for a checksum. */
|
if (len > 0)
|
if (len > 0)
|
len += 2;
|
len += 2;
|
|
|
/* Write the packet header. */
|
/* Write the packet header. */
|
hdr[0] = PESC;
|
hdr[0] = PESC;
|
hdr[1] = type;
|
hdr[1] = type;
|
hdr[2] = len & 0xff;
|
hdr[2] = len & 0xff;
|
hdr[3] = (len >> 8) & 0xff;
|
hdr[3] = (len >> 8) & 0xff;
|
debug_write (hdr, sizeof (hdr));
|
debug_write (hdr, sizeof (hdr));
|
|
|
if (len)
|
if (len)
|
{
|
{
|
/* Write the packet data. */
|
/* Write the packet data. */
|
debug_write (buf, buflen);
|
debug_write (buf, buflen);
|
|
|
/* Write the sequence number if this is a 'p' packet. */
|
/* Write the sequence number if this is a 'p' packet. */
|
if (type == 'p')
|
if (type == 'p')
|
{
|
{
|
hdr[0] = seq;
|
hdr[0] = seq;
|
debug_write (hdr, 1);
|
debug_write (hdr, 1);
|
}
|
}
|
|
|
/* Write the checksum. */
|
/* Write the checksum. */
|
sum = 0;
|
sum = 0;
|
for (i = 0; i < buflen; i++)
|
for (i = 0; i < buflen; i++)
|
{
|
{
|
int tmp = (buf[i] & 0xff);
|
int tmp = (buf[i] & 0xff);
|
if (i & 1)
|
if (i & 1)
|
sum += tmp;
|
sum += tmp;
|
else
|
else
|
sum += tmp << 8;
|
sum += tmp << 8;
|
}
|
}
|
if (type == 'p')
|
if (type == 'p')
|
{
|
{
|
if (buflen & 1)
|
if (buflen & 1)
|
sum += (seq & 0xff);
|
sum += (seq & 0xff);
|
else
|
else
|
sum += (seq & 0xff) << 8;
|
sum += (seq & 0xff) << 8;
|
}
|
}
|
sum = (sum & 0xffff) + ((sum >> 16) & 0xffff);
|
sum = (sum & 0xffff) + ((sum >> 16) & 0xffff);
|
sum += (sum >> 16) & 1;
|
sum += (sum >> 16) & 1;
|
sum = ~sum;
|
sum = ~sum;
|
|
|
hdr[0] = (sum >> 8) & 0xff;
|
hdr[0] = (sum >> 8) & 0xff;
|
hdr[1] = sum & 0xff;
|
hdr[1] = sum & 0xff;
|
debug_write (hdr, 2);
|
debug_write (hdr, 2);
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Respond to an expected read request from the monitor by sending
|
/* Respond to an expected read request from the monitor by sending
|
data in chunks. Handle all acknowledgements and handshaking packets.
|
data in chunks. Handle all acknowledgements and handshaking packets.
|
|
|
The monitor expects a response consisting of a one or more 'p' packets,
|
The monitor expects a response consisting of a one or more 'p' packets,
|
each followed by a portion of the data requested. The 'p' packet
|
each followed by a portion of the data requested. The 'p' packet
|
contains only a four-byte integer, the value of which is the number
|
contains only a four-byte integer, the value of which is the number
|
of bytes of data we are about to send. Following the 'p' packet,
|
of bytes of data we are about to send. Following the 'p' packet,
|
the monitor expects the data bytes themselves in raw, unpacketized,
|
the monitor expects the data bytes themselves in raw, unpacketized,
|
form, without even a checksum.
|
form, without even a checksum.
|
*/
|
*/
|
|
|
static void
|
static void
|
process_read_request (buf, buflen)
|
process_read_request (buf, buflen)
|
unsigned char *buf;
|
unsigned char *buf;
|
int buflen;
|
int buflen;
|
{
|
{
|
unsigned char len[4];
|
unsigned char len[4];
|
int i, chunk;
|
int i, chunk;
|
unsigned char seq;
|
unsigned char seq;
|
|
|
/* Discard the read request. FIXME: we have to hope it's for
|
/* Discard the read request. FIXME: we have to hope it's for
|
the exact number of bytes we want to send; should check for this. */
|
the exact number of bytes we want to send; should check for this. */
|
ignore_packet ();
|
ignore_packet ();
|
|
|
for (i = chunk = 0, seq = 0; i < buflen; i += chunk, seq++)
|
for (i = chunk = 0, seq = 0; i < buflen; i += chunk, seq++)
|
{
|
{
|
/* Don't send more than MAXPSIZE bytes at a time. */
|
/* Don't send more than MAXPSIZE bytes at a time. */
|
chunk = buflen - i;
|
chunk = buflen - i;
|
if (chunk > MAXPSIZE)
|
if (chunk > MAXPSIZE)
|
chunk = MAXPSIZE;
|
chunk = MAXPSIZE;
|
|
|
/* Write a packet containing the number of bytes we are sending. */
|
/* Write a packet containing the number of bytes we are sending. */
|
write_long_le (len, chunk);
|
write_long_le (len, chunk);
|
send_packet ('p', len, sizeof (len), seq);
|
send_packet ('p', len, sizeof (len), seq);
|
|
|
/* Write the data in raw form following the packet. */
|
/* Write the data in raw form following the packet. */
|
debug_write (&buf[i], chunk);
|
debug_write (&buf[i], chunk);
|
|
|
/* Discard the ACK packet. */
|
/* Discard the ACK packet. */
|
ignore_packet ();
|
ignore_packet ();
|
}
|
}
|
|
|
/* Send an "end of data" packet. */
|
/* Send an "end of data" packet. */
|
send_packet ('e', "", 0, 0);
|
send_packet ('e', "", 0, 0);
|
}
|
}
|
|
|
|
|
/* Count loadable sections (helper function for r3900_load). */
|
/* Count loadable sections (helper function for r3900_load). */
|
|
|
static void
|
static void
|
count_section (abfd, s, section_count)
|
count_section (abfd, s, section_count)
|
bfd *abfd;
|
bfd *abfd;
|
asection *s;
|
asection *s;
|
unsigned int *section_count;
|
unsigned int *section_count;
|
{
|
{
|
if (s->flags & SEC_LOAD && bfd_section_size (abfd, s) != 0)
|
if (s->flags & SEC_LOAD && bfd_section_size (abfd, s) != 0)
|
(*section_count)++;
|
(*section_count)++;
|
}
|
}
|
|
|
|
|
/* Load a single BFD section (helper function for r3900_load).
|
/* Load a single BFD section (helper function for r3900_load).
|
|
|
WARNING: this code is filled with assumptions about how
|
WARNING: this code is filled with assumptions about how
|
the Densan monitor loads programs. The monitor issues
|
the Densan monitor loads programs. The monitor issues
|
packets containing read requests, but rather than respond
|
packets containing read requests, but rather than respond
|
to them in an general way, we expect them to following
|
to them in an general way, we expect them to following
|
a certain pattern.
|
a certain pattern.
|
|
|
For example, we know that the monitor will start loading by
|
For example, we know that the monitor will start loading by
|
issuing an 8-byte read request for the binary file header.
|
issuing an 8-byte read request for the binary file header.
|
We know this is coming and ignore the actual contents
|
We know this is coming and ignore the actual contents
|
of the read request packet.
|
of the read request packet.
|
*/
|
*/
|
|
|
static void
|
static void
|
load_section (abfd, s, data_count)
|
load_section (abfd, s, data_count)
|
bfd *abfd;
|
bfd *abfd;
|
asection *s;
|
asection *s;
|
unsigned int *data_count;
|
unsigned int *data_count;
|
{
|
{
|
if (s->flags & SEC_LOAD)
|
if (s->flags & SEC_LOAD)
|
{
|
{
|
bfd_size_type section_size = bfd_section_size (abfd, s);
|
bfd_size_type section_size = bfd_section_size (abfd, s);
|
bfd_vma section_base = bfd_section_lma (abfd, s);
|
bfd_vma section_base = bfd_section_lma (abfd, s);
|
unsigned char *buffer;
|
unsigned char *buffer;
|
unsigned char header[8];
|
unsigned char header[8];
|
|
|
/* Don't output zero-length sections. */
|
/* Don't output zero-length sections. */
|
if (section_size == 0)
|
if (section_size == 0)
|
return;
|
return;
|
if (data_count)
|
if (data_count)
|
*data_count += section_size;
|
*data_count += section_size;
|
|
|
/* Print some fluff about the section being loaded. */
|
/* Print some fluff about the section being loaded. */
|
printf_filtered ("Loading section %s, size 0x%lx lma ",
|
printf_filtered ("Loading section %s, size 0x%lx lma ",
|
bfd_section_name (abfd, s), (long) section_size);
|
bfd_section_name (abfd, s), (long) section_size);
|
print_address_numeric (section_base, 1, gdb_stdout);
|
print_address_numeric (section_base, 1, gdb_stdout);
|
printf_filtered ("\n");
|
printf_filtered ("\n");
|
gdb_flush (gdb_stdout);
|
gdb_flush (gdb_stdout);
|
|
|
/* Write the section header (location and size). */
|
/* Write the section header (location and size). */
|
write_long (&header[0], (long) section_base);
|
write_long (&header[0], (long) section_base);
|
write_long (&header[4], (long) section_size);
|
write_long (&header[4], (long) section_size);
|
process_read_request (header, sizeof (header));
|
process_read_request (header, sizeof (header));
|
|
|
/* Read the section contents into a buffer, write it out,
|
/* Read the section contents into a buffer, write it out,
|
then free the buffer. */
|
then free the buffer. */
|
buffer = (unsigned char *) xmalloc (section_size);
|
buffer = (unsigned char *) xmalloc (section_size);
|
bfd_get_section_contents (abfd, s, buffer, 0, section_size);
|
bfd_get_section_contents (abfd, s, buffer, 0, section_size);
|
process_read_request (buffer, section_size);
|
process_read_request (buffer, section_size);
|
free (buffer);
|
free (buffer);
|
}
|
}
|
}
|
}
|
|
|
|
|
/* When the ethernet is used as the console port on the Densan board,
|
/* When the ethernet is used as the console port on the Densan board,
|
we can use the "Rm" command to do a fast binary load. The format
|
we can use the "Rm" command to do a fast binary load. The format
|
of the download data is:
|
of the download data is:
|
|
|
number of sections (4 bytes)
|
number of sections (4 bytes)
|
starting address (4 bytes)
|
starting address (4 bytes)
|
repeat for each section:
|
repeat for each section:
|
location address (4 bytes)
|
location address (4 bytes)
|
section size (4 bytes)
|
section size (4 bytes)
|
binary data
|
binary data
|
|
|
The 4-byte fields are all in big-endian order.
|
The 4-byte fields are all in big-endian order.
|
|
|
Using this command is tricky because we have to put the monitor
|
Using this command is tricky because we have to put the monitor
|
into a special funky "communications interface" mode, in which
|
into a special funky "communications interface" mode, in which
|
it sends and receives packets of data along with the normal prompt.
|
it sends and receives packets of data along with the normal prompt.
|
*/
|
*/
|
|
|
static void
|
static void
|
r3900_load (filename, from_tty)
|
r3900_load (filename, from_tty)
|
char *filename;
|
char *filename;
|
int from_tty;
|
int from_tty;
|
{
|
{
|
bfd *abfd;
|
bfd *abfd;
|
unsigned int data_count = 0;
|
unsigned int data_count = 0;
|
time_t start_time, end_time; /* for timing of download */
|
time_t start_time, end_time; /* for timing of download */
|
int section_count = 0;
|
int section_count = 0;
|
unsigned char buffer[8];
|
unsigned char buffer[8];
|
|
|
/* If we are not using the ethernet, use the normal monitor load,
|
/* If we are not using the ethernet, use the normal monitor load,
|
which sends S-records over the serial link. */
|
which sends S-records over the serial link. */
|
if (!ethernet)
|
if (!ethernet)
|
{
|
{
|
orig_monitor_load (filename, from_tty);
|
orig_monitor_load (filename, from_tty);
|
return;
|
return;
|
}
|
}
|
|
|
/* Open the file. */
|
/* Open the file. */
|
if (filename == NULL || filename[0] == 0)
|
if (filename == NULL || filename[0] == 0)
|
filename = get_exec_file (1);
|
filename = get_exec_file (1);
|
abfd = bfd_openr (filename, 0);
|
abfd = bfd_openr (filename, 0);
|
if (!abfd)
|
if (!abfd)
|
error ("Unable to open file %s\n", filename);
|
error ("Unable to open file %s\n", filename);
|
if (bfd_check_format (abfd, bfd_object) == 0)
|
if (bfd_check_format (abfd, bfd_object) == 0)
|
error ("File is not an object file\n");
|
error ("File is not an object file\n");
|
|
|
/* Output the "vconsi" command to get the monitor in the communication
|
/* Output the "vconsi" command to get the monitor in the communication
|
state where it will accept a load command. This will cause
|
state where it will accept a load command. This will cause
|
the monitor to emit a packet before each prompt, so ignore the packet. */
|
the monitor to emit a packet before each prompt, so ignore the packet. */
|
monitor_printf ("vconsi\r");
|
monitor_printf ("vconsi\r");
|
ignore_packet ();
|
ignore_packet ();
|
monitor_expect_prompt (NULL, 0);
|
monitor_expect_prompt (NULL, 0);
|
|
|
/* Output the "Rm" (load) command and respond to the subsequent "open"
|
/* Output the "Rm" (load) command and respond to the subsequent "open"
|
packet by sending an ACK packet. */
|
packet by sending an ACK packet. */
|
monitor_printf ("Rm\r");
|
monitor_printf ("Rm\r");
|
ignore_packet ();
|
ignore_packet ();
|
send_packet ('a', "", 0, 0);
|
send_packet ('a', "", 0, 0);
|
|
|
/* Output the fast load header (number of sections and starting address). */
|
/* Output the fast load header (number of sections and starting address). */
|
bfd_map_over_sections ((bfd *) abfd, (section_map_func) count_section,
|
bfd_map_over_sections ((bfd *) abfd, (section_map_func) count_section,
|
§ion_count);
|
§ion_count);
|
write_long (&buffer[0], (long) section_count);
|
write_long (&buffer[0], (long) section_count);
|
if (exec_bfd)
|
if (exec_bfd)
|
write_long (&buffer[4], (long) bfd_get_start_address (exec_bfd));
|
write_long (&buffer[4], (long) bfd_get_start_address (exec_bfd));
|
else
|
else
|
write_long (&buffer[4], 0);
|
write_long (&buffer[4], 0);
|
process_read_request (buffer, sizeof (buffer));
|
process_read_request (buffer, sizeof (buffer));
|
|
|
/* Output the section data. */
|
/* Output the section data. */
|
start_time = time (NULL);
|
start_time = time (NULL);
|
bfd_map_over_sections (abfd, (section_map_func) load_section, &data_count);
|
bfd_map_over_sections (abfd, (section_map_func) load_section, &data_count);
|
end_time = time (NULL);
|
end_time = time (NULL);
|
|
|
/* Acknowledge the close packet and put the monitor back into
|
/* Acknowledge the close packet and put the monitor back into
|
"normal" mode so it won't send packets any more. */
|
"normal" mode so it won't send packets any more. */
|
ignore_packet ();
|
ignore_packet ();
|
send_packet ('a', "", 0, 0);
|
send_packet ('a', "", 0, 0);
|
monitor_expect_prompt (NULL, 0);
|
monitor_expect_prompt (NULL, 0);
|
monitor_printf ("vconsx\r");
|
monitor_printf ("vconsx\r");
|
monitor_expect_prompt (NULL, 0);
|
monitor_expect_prompt (NULL, 0);
|
|
|
/* Print start address and download performance information. */
|
/* Print start address and download performance information. */
|
printf_filtered ("Start address 0x%lx\n", (long) bfd_get_start_address (abfd));
|
printf_filtered ("Start address 0x%lx\n", (long) bfd_get_start_address (abfd));
|
report_transfer_performance (data_count, start_time, end_time);
|
report_transfer_performance (data_count, start_time, end_time);
|
|
|
/* Finally, make the PC point at the start address */
|
/* Finally, make the PC point at the start address */
|
if (exec_bfd)
|
if (exec_bfd)
|
write_pc (bfd_get_start_address (exec_bfd));
|
write_pc (bfd_get_start_address (exec_bfd));
|
|
|
inferior_pid = 0; /* No process now */
|
inferior_pid = 0; /* No process now */
|
|
|
/* This is necessary because many things were based on the PC at the
|
/* This is necessary because many things were based on the PC at the
|
time that we attached to the monitor, which is no longer valid
|
time that we attached to the monitor, which is no longer valid
|
now that we have loaded new code (and just changed the PC).
|
now that we have loaded new code (and just changed the PC).
|
Another way to do this might be to call normal_stop, except that
|
Another way to do this might be to call normal_stop, except that
|
the stack may not be valid, and things would get horribly
|
the stack may not be valid, and things would get horribly
|
confused... */
|
confused... */
|
clear_symtab_users ();
|
clear_symtab_users ();
|
}
|
}
|
|
|
|
|
/* Commands to send to the monitor when first connecting:
|
/* Commands to send to the monitor when first connecting:
|
* The bare carriage return forces a prompt from the monitor
|
* The bare carriage return forces a prompt from the monitor
|
(monitor doesn't prompt immediately after a reset).
|
(monitor doesn't prompt immediately after a reset).
|
* The "vconsx" switches the monitor back to interactive mode
|
* The "vconsx" switches the monitor back to interactive mode
|
in case an aborted download had left it in packet mode.
|
in case an aborted download had left it in packet mode.
|
* The "Xtr" command causes subsequent "t" (trace) commands to display
|
* The "Xtr" command causes subsequent "t" (trace) commands to display
|
the general registers only.
|
the general registers only.
|
* The "Xxr" command does the same thing for the "x" (examine
|
* The "Xxr" command does the same thing for the "x" (examine
|
registers) command.
|
registers) command.
|
* The "bx" command clears all breakpoints.
|
* The "bx" command clears all breakpoints.
|
*/
|
*/
|
|
|
static char *r3900_inits[] =
|
static char *r3900_inits[] =
|
{"\r", "vconsx\r", "Xtr\r", "Xxr\r", "bx\r", NULL};
|
{"\r", "vconsx\r", "Xtr\r", "Xxr\r", "bx\r", NULL};
|
static char *dummy_inits[] =
|
static char *dummy_inits[] =
|
{NULL};
|
{NULL};
|
|
|
static struct target_ops r3900_ops;
|
static struct target_ops r3900_ops;
|
static struct monitor_ops r3900_cmds;
|
static struct monitor_ops r3900_cmds;
|
|
|
static void
|
static void
|
r3900_open (args, from_tty)
|
r3900_open (args, from_tty)
|
char *args;
|
char *args;
|
int from_tty;
|
int from_tty;
|
{
|
{
|
char buf[64];
|
char buf[64];
|
int i;
|
int i;
|
|
|
monitor_open (args, &r3900_cmds, from_tty);
|
monitor_open (args, &r3900_cmds, from_tty);
|
|
|
/* We have to handle sending the init strings ourselves, because
|
/* We have to handle sending the init strings ourselves, because
|
the first two strings we send (carriage returns) may not be echoed
|
the first two strings we send (carriage returns) may not be echoed
|
by the monitor, but the rest will be. */
|
by the monitor, but the rest will be. */
|
monitor_printf_noecho ("\r\r");
|
monitor_printf_noecho ("\r\r");
|
for (i = 0; r3900_inits[i] != NULL; i++)
|
for (i = 0; r3900_inits[i] != NULL; i++)
|
{
|
{
|
monitor_printf (r3900_inits[i]);
|
monitor_printf (r3900_inits[i]);
|
monitor_expect_prompt (NULL, 0);
|
monitor_expect_prompt (NULL, 0);
|
}
|
}
|
|
|
/* Attempt to determine whether the console device is ethernet or serial.
|
/* Attempt to determine whether the console device is ethernet or serial.
|
This will tell us which kind of load to use (S-records over a serial
|
This will tell us which kind of load to use (S-records over a serial
|
link, or the Densan fast binary multi-section format over the net). */
|
link, or the Densan fast binary multi-section format over the net). */
|
|
|
ethernet = 0;
|
ethernet = 0;
|
monitor_printf ("v\r");
|
monitor_printf ("v\r");
|
if (monitor_expect ("console device :", NULL, 0) != -1)
|
if (monitor_expect ("console device :", NULL, 0) != -1)
|
if (monitor_expect ("\n", buf, sizeof (buf)) != -1)
|
if (monitor_expect ("\n", buf, sizeof (buf)) != -1)
|
if (strstr (buf, "ethernet") != NULL)
|
if (strstr (buf, "ethernet") != NULL)
|
ethernet = 1;
|
ethernet = 1;
|
monitor_expect_prompt (NULL, 0);
|
monitor_expect_prompt (NULL, 0);
|
}
|
}
|
|
|
void
|
void
|
_initialize_r3900_rom ()
|
_initialize_r3900_rom ()
|
{
|
{
|
r3900_cmds.flags = MO_NO_ECHO_ON_OPEN |
|
r3900_cmds.flags = MO_NO_ECHO_ON_OPEN |
|
MO_ADDR_BITS_REMOVE |
|
MO_ADDR_BITS_REMOVE |
|
MO_CLR_BREAK_USES_ADDR |
|
MO_CLR_BREAK_USES_ADDR |
|
MO_GETMEM_READ_SINGLE |
|
MO_GETMEM_READ_SINGLE |
|
MO_PRINT_PROGRAM_OUTPUT;
|
MO_PRINT_PROGRAM_OUTPUT;
|
|
|
r3900_cmds.init = dummy_inits;
|
r3900_cmds.init = dummy_inits;
|
r3900_cmds.cont = "g\r";
|
r3900_cmds.cont = "g\r";
|
r3900_cmds.step = "t\r";
|
r3900_cmds.step = "t\r";
|
r3900_cmds.set_break = "b %A\r"; /* COREADDR */
|
r3900_cmds.set_break = "b %A\r"; /* COREADDR */
|
r3900_cmds.clr_break = "b %A,0\r"; /* COREADDR */
|
r3900_cmds.clr_break = "b %A,0\r"; /* COREADDR */
|
r3900_cmds.fill = "fx %A s %x %x\r"; /* COREADDR, len, val */
|
r3900_cmds.fill = "fx %A s %x %x\r"; /* COREADDR, len, val */
|
|
|
r3900_cmds.setmem.cmdb = "sx %A %x\r"; /* COREADDR, val */
|
r3900_cmds.setmem.cmdb = "sx %A %x\r"; /* COREADDR, val */
|
r3900_cmds.setmem.cmdw = "sh %A %x\r"; /* COREADDR, val */
|
r3900_cmds.setmem.cmdw = "sh %A %x\r"; /* COREADDR, val */
|
r3900_cmds.setmem.cmdl = "sw %A %x\r"; /* COREADDR, val */
|
r3900_cmds.setmem.cmdl = "sw %A %x\r"; /* COREADDR, val */
|
|
|
r3900_cmds.getmem.cmdb = "sx %A\r"; /* COREADDR */
|
r3900_cmds.getmem.cmdb = "sx %A\r"; /* COREADDR */
|
r3900_cmds.getmem.cmdw = "sh %A\r"; /* COREADDR */
|
r3900_cmds.getmem.cmdw = "sh %A\r"; /* COREADDR */
|
r3900_cmds.getmem.cmdl = "sw %A\r"; /* COREADDR */
|
r3900_cmds.getmem.cmdl = "sw %A\r"; /* COREADDR */
|
r3900_cmds.getmem.resp_delim = " : ";
|
r3900_cmds.getmem.resp_delim = " : ";
|
r3900_cmds.getmem.term = " ";
|
r3900_cmds.getmem.term = " ";
|
r3900_cmds.getmem.term_cmd = ".\r";
|
r3900_cmds.getmem.term_cmd = ".\r";
|
|
|
r3900_cmds.setreg.cmd = "x%s %x\r"; /* regname, val */
|
r3900_cmds.setreg.cmd = "x%s %x\r"; /* regname, val */
|
|
|
r3900_cmds.getreg.cmd = "x%s\r"; /* regname */
|
r3900_cmds.getreg.cmd = "x%s\r"; /* regname */
|
r3900_cmds.getreg.resp_delim = "=";
|
r3900_cmds.getreg.resp_delim = "=";
|
r3900_cmds.getreg.term = " ";
|
r3900_cmds.getreg.term = " ";
|
r3900_cmds.getreg.term_cmd = ".\r";
|
r3900_cmds.getreg.term_cmd = ".\r";
|
|
|
r3900_cmds.dump_registers = "x\r";
|
r3900_cmds.dump_registers = "x\r";
|
r3900_cmds.register_pattern =
|
r3900_cmds.register_pattern =
|
"\\([a-zA-Z0-9_]+\\) *=\\([0-9a-f]+ [0-9a-f]+\\b\\)";
|
"\\([a-zA-Z0-9_]+\\) *=\\([0-9a-f]+ [0-9a-f]+\\b\\)";
|
r3900_cmds.supply_register = r3900_supply_register;
|
r3900_cmds.supply_register = r3900_supply_register;
|
/* S-record download, via "keyboard port". */
|
/* S-record download, via "keyboard port". */
|
r3900_cmds.load = "r0\r";
|
r3900_cmds.load = "r0\r";
|
r3900_cmds.prompt = "#";
|
r3900_cmds.prompt = "#";
|
r3900_cmds.line_term = "\r";
|
r3900_cmds.line_term = "\r";
|
r3900_cmds.target = &r3900_ops;
|
r3900_cmds.target = &r3900_ops;
|
r3900_cmds.stopbits = SERIAL_1_STOPBITS;
|
r3900_cmds.stopbits = SERIAL_1_STOPBITS;
|
r3900_cmds.regnames = r3900_regnames;
|
r3900_cmds.regnames = r3900_regnames;
|
r3900_cmds.magic = MONITOR_OPS_MAGIC;
|
r3900_cmds.magic = MONITOR_OPS_MAGIC;
|
|
|
init_monitor_ops (&r3900_ops);
|
init_monitor_ops (&r3900_ops);
|
|
|
r3900_ops.to_shortname = "r3900";
|
r3900_ops.to_shortname = "r3900";
|
r3900_ops.to_longname = "R3900 monitor";
|
r3900_ops.to_longname = "R3900 monitor";
|
r3900_ops.to_doc = "Debug using the DVE R3900 monitor.\n\
|
r3900_ops.to_doc = "Debug using the DVE R3900 monitor.\n\
|
Specify the serial device it is connected to (e.g. /dev/ttya).";
|
Specify the serial device it is connected to (e.g. /dev/ttya).";
|
r3900_ops.to_open = r3900_open;
|
r3900_ops.to_open = r3900_open;
|
|
|
/* Override the functions to fetch and store registers. But save the
|
/* Override the functions to fetch and store registers. But save the
|
addresses of the default functions, because we will use those functions
|
addresses of the default functions, because we will use those functions
|
for "normal" registers. */
|
for "normal" registers. */
|
|
|
orig_monitor_fetch_registers = r3900_ops.to_fetch_registers;
|
orig_monitor_fetch_registers = r3900_ops.to_fetch_registers;
|
orig_monitor_store_registers = r3900_ops.to_store_registers;
|
orig_monitor_store_registers = r3900_ops.to_store_registers;
|
r3900_ops.to_fetch_registers = r3900_fetch_registers;
|
r3900_ops.to_fetch_registers = r3900_fetch_registers;
|
r3900_ops.to_store_registers = r3900_store_registers;
|
r3900_ops.to_store_registers = r3900_store_registers;
|
|
|
/* Override the load function, but save the address of the default
|
/* Override the load function, but save the address of the default
|
function to use when loading S-records over a serial link. */
|
function to use when loading S-records over a serial link. */
|
orig_monitor_load = r3900_ops.to_load;
|
orig_monitor_load = r3900_ops.to_load;
|
r3900_ops.to_load = r3900_load;
|
r3900_ops.to_load = r3900_load;
|
|
|
add_target (&r3900_ops);
|
add_target (&r3900_ops);
|
}
|
}
|
|
|
