+Tue Nov 23 17:29:28 1993 Steve Chamberlain (sac@jonny.cygnus.com)
+
+ * ser-go32.c: Lint. (strncasecmp): Removed, now in libiberty.
+ (go32_readchar): Special handling for faster polling. (async
+ structure): Volatile.
+ * h8300-tdep.c (print_register_hook): Allocate and use the right
+ number bytes for the raw register.
+ * h8500-tdep.c (regoff, frame_find_saved_reg, examine_prologue):
+ deleted. (h8500_register_size, h8500_register_virtual_type, ):
+ Use new way of counting registers.
+ * remote-e7000.c (echo_index): deleted. (expect): Better handling
+ of user interrupts. (expect_prompt): Remove never used log file
+ support. (want, want_nopc): Add support for H8/300H.
+ (fetch_regs_from_dump): Treat \r and \n as whitespace.
+ (e7000_drain): Send an "end" command before waiting for output to
+ stop. (e7000_wait): Cope with H8/300H, better handling of user
+ interrupts. (why_stop, expect_n, sub2_from_pc): New function.
+ * remote-utils.c (gr_load_image): call fflush and QUIT more regularly.
+ * utils.c (notice_quit): New function for polling for user interrupts.
+
Fri Dec 10 15:53:56 1993 Per Bothner (bothner@kalessin.cygnus.com)
* stabsread.c (read_array_type): Allow negative array bounds,
* i386ly-tdep.c (i386lynx_saved_pc_after_call): Change call_inst
to unsigned char to avoid domain warning for some values.
+>>>>>>> 1.2024
Mon Nov 22 23:42:59 1993 Steve Chamberlain (sac@jonny.cygnus.com)
* remote-e7000.c (e7000_wait): Cope with H8/300 register dump.
if (regno == 8)
{
/* CCR register */
-
int C, Z, N, V;
- unsigned char b[2];
+ unsigned char b[4];
unsigned char l;
-
read_relative_register_raw_bytes (regno, b);
- l = b[1];
+ l = b[REGISTER_VIRTUAL_SIZE(8) -1];
printf_unfiltered ("\t");
printf_unfiltered ("I-%d - ", (l & 0x80) != 0);
printf_unfiltered ("H-%d - ", (l & 0x20) != 0);
void frame_find_saved_regs ();
-int regoff[NUM_REGS] =
-{0, 2, 4, 6, 8, 10, 12, 14, /* r0->r7 */
- 16, 18, /* ccr, pc */
- 20, 21, 22, 23}; /* cp, dp, ep, tp */
CORE_ADDR
h8500_skip_prologue (start_pc)
{
short int w;
- w = read_memory_integer (start_pc, 1);
+ w = read_memory_integer (start_pc, 1);
if (w == LINK_8)
{
start_pc += 2;
h8500_frame_chain (thisframe)
FRAME thisframe;
{
-
if (!inside_entry_file (thisframe->pc))
- return (read_memory_integer (thisframe->frame, 2) & 0xffff)
- | (read_register (SEG_T_REGNUM) << 16);
+ return (read_memory_integer (FRAME_FP (thisframe), PTR_SIZE));
else
return 0;
}
-/* Put here the code to store, into a struct frame_saved_regs,
- the addresses of the saved registers of frame described by FRAME_INFO.
- This includes special registers such as pc and fp saved in special
- ways in the stack frame. sp is even more special:
- the address we return for it IS the sp for the next frame.
-
- We cache the result of doing this in the frame_cache_obstack, since
- it is fairly expensive. */
-#if 0
-
-void
-frame_find_saved_regs (fi, fsr)
- struct frame_info *fi;
- struct frame_saved_regs *fsr;
-{
- register CORE_ADDR next_addr;
- register CORE_ADDR *saved_regs;
- register int regnum;
- register struct frame_saved_regs *cache_fsr;
- extern struct obstack frame_cache_obstack;
- CORE_ADDR ip;
- struct symtab_and_line sal;
- CORE_ADDR limit;
-
- if (!fi->fsr)
- {
- cache_fsr = (struct frame_saved_regs *)
- obstack_alloc (&frame_cache_obstack,
- sizeof (struct frame_saved_regs));
- memset (cache_fsr, '\0', sizeof (struct frame_saved_regs));
-
- fi->fsr = cache_fsr;
-
- /* Find the start and end of the function prologue. If the PC
- is in the function prologue, we only consider the part that
- has executed already. */
-
- ip = get_pc_function_start (fi->pc);
- sal = find_pc_line (ip, 0);
- limit = (sal.end && sal.end < fi->pc) ? sal.end : fi->pc;
-
- /* This will fill in fields in *fi as well as in cache_fsr. */
- examine_prologue (ip, limit, fi->frame, cache_fsr, fi);
- }
-
- if (fsr)
- *fsr = *fi->fsr;
-}
-
-#endif
/* Fetch the instruction at ADDR, returning 0 if ADDR is beyond LIM or
is not the address of a valid instruction, the address of the next
`fi' is a struct frame_info pointer; we fill in various fields in it
to reflect the offsets of the arg pointer and the locals pointer. */
-#if 0
-static CORE_ADDR
-examine_prologue (ip, limit, after_prolog_fp, fsr, fi)
- register CORE_ADDR ip;
- register CORE_ADDR limit;
- FRAME_ADDR after_prolog_fp;
- struct frame_saved_regs *fsr;
- struct frame_info *fi;
-{
- register CORE_ADDR next_ip;
- int r;
- int i;
- int have_fp = 0;
-
- register int src;
- register struct pic_prologue_code *pcode;
- char insn[2];
- int size, offset;
- unsigned int reg_save_depth = 2; /* Number of things pushed onto
- stack, starts at 2, 'cause the
- PC is already there */
-
- unsigned int auto_depth = 0; /* Number of bytes of autos */
-
- char in_frame[8]; /* One for each reg */
-
- memset (in_frame, 1, 8);
- for (r = 0; r < 8; r++)
- {
- fsr->regs[r] = 0;
- }
- if (after_prolog_fp == 0)
- {
- after_prolog_fp = read_register (SP_REGNUM);
- }
- if (ip == 0 || ip & ~0xffffff)
- return 0;
-
- ok = NEXT_PROLOGUE_INSN (ip, limit, &insn[0]);
-
- /* Skip over any fp push instructions */
- fsr->regs[6] = after_prolog_fp;
-
- if (ok && IS_LINK_8 (insn[0]))
- {
- ip++;
-
- in_frame[6] = reg_save_depth;
- reg_save_depth += 2;
- }
-
- next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
-
- /* Is this a move into the fp */
- if (next_ip && IS_MOV_SP_FP (insn_word))
- {
- ip = next_ip;
- next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
- have_fp = 1;
- }
-
- /* Skip over any stack adjustment, happens either with a number of
- sub#2,sp or a mov #x,r5 sub r5,sp */
-
- if (next_ip && IS_SUB2_SP (insn_word))
- {
- while (next_ip && IS_SUB2_SP (insn_word))
- {
- auto_depth += 2;
- ip = next_ip;
- next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
- }
- }
- else
- {
- if (next_ip && IS_MOVK_R5 (insn_word))
- {
- ip = next_ip;
- next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
- auto_depth += insn_word;
-
- next_ip = NEXT_PROLOGUE_INSN (next_ip, limit, &insn_word);
- auto_depth += insn_word;
-
- }
- }
- /* Work out which regs are stored where */
- while (next_ip && IS_PUSH (insn_word))
- {
- ip = next_ip;
- next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
- fsr->regs[r] = after_prolog_fp + auto_depth;
- auto_depth += 2;
- }
-
- /* The args are always reffed based from the stack pointer */
- fi->args_pointer = after_prolog_fp;
- /* Locals are always reffed based from the fp */
- fi->locals_pointer = after_prolog_fp;
- /* The PC is at a known place */
- fi->from_pc = read_memory_short (after_prolog_fp + 2);
-
- /* Rememeber any others too */
- in_frame[PC_REGNUM] = 0;
-
- if (have_fp)
- /* We keep the old FP in the SP spot */
- fsr->regs[SP_REGNUM] = (read_memory_short (fsr->regs[6]));
- else
- fsr->regs[SP_REGNUM] = after_prolog_fp + auto_depth;
-
- return (ip);
-}
-
-#endif
/* Return the saved PC from this frame. */
h8500_register_size (regno)
int regno;
{
- if (regno <= PC_REGNUM)
- return 2;
- else
+ switch (regno) {
+ case SEG_C_REGNUM:
+ case SEG_D_REGNUM:
+ case SEG_E_REGNUM:
+ case SEG_T_REGNUM:
return 1;
+ case R0_REGNUM:
+ case R1_REGNUM:
+ case R2_REGNUM:
+ case R3_REGNUM:
+ case R4_REGNUM:
+ case R5_REGNUM:
+ case R6_REGNUM:
+ case R7_REGNUM:
+ case CCR_REGNUM:
+ return 2;
+
+ case PR0_REGNUM:
+ case PR1_REGNUM:
+ case PR2_REGNUM:
+ case PR3_REGNUM:
+ case PR4_REGNUM:
+ case PR5_REGNUM:
+ case PR6_REGNUM:
+ case PR7_REGNUM:
+ case PC_REGNUM:
+ return 4;
+ }
}
struct type *
case R5_REGNUM:
case R6_REGNUM:
case R7_REGNUM:
- case PC_REGNUM:
case CCR_REGNUM:
return builtin_type_unsigned_short;
+ case PR0_REGNUM:
+ case PR1_REGNUM:
+ case PR2_REGNUM:
+ case PR3_REGNUM:
+ case PR4_REGNUM:
+ case PR5_REGNUM:
+ case PR6_REGNUM:
+ case PR7_REGNUM:
+ case PC_REGNUM:
+ return builtin_type_unsigned_long;
default:
abort ();
}
CORE_ADDR
target_read_sp ()
{
- return (read_register (SEG_T_REGNUM) << 16) | (read_register (SP_REGNUM));
+ return read_register (PR7_REGNUM);
}
void
target_write_sp (v)
CORE_ADDR v;
{
- write_register (SEG_T_REGNUM, v >> 16);
- write_register (SP_REGNUM, v & 0xffff);
+ write_register (PR7_REGNUM, v);
}
CORE_ADDR
target_read_pc ()
{
- return (read_register (SEG_C_REGNUM) << 16) | (read_register (PC_REGNUM));
+ return read_register (PC_REGNUM);
}
void
target_write_pc (v)
CORE_ADDR v;
{
- write_register (SEG_C_REGNUM, v >> 16);
- write_register (PC_REGNUM, v & 0xffff);
+ write_register (PC_REGNUM, v);
}
CORE_ADDR
target_read_fp ()
{
- return (read_register (SEG_T_REGNUM) << 16) | (read_register (FP_REGNUM));
+ return read_register (PR6_REGNUM);
}
void
target_write_fp (v)
CORE_ADDR v;
{
- write_register (SEG_T_REGNUM, v >> 16);
- write_register (FP_REGNUM, v & 0xffff);
+ write_register (PR6_REGNUM, v);
}
old_cleanups = make_cleanup (bfd_close, abfd);
QUIT;
- immediate_quit++;
if (!bfd_check_format (abfd, bfd_object))
error ("It doesn't seem to be an object file.\n");
- for (s = abfd->sections; s; s = s->next)
+ for (s = abfd->sections; s && !quit_flag; s = s->next)
{
if (bfd_get_section_flags (abfd, s) & SEC_LOAD)
{
int i;
printf_filtered ("%s\t: 0x%4x .. 0x%4x ",
s->name, s->vma, s->vma + s->_raw_size);
- for (i = 0; i < s->_raw_size; i += delta)
+ fflush (stdout);
+ for (i = 0; i < s->_raw_size && !quit_flag; i += delta)
{
int sub_delta = delta;
if (sub_delta > s->_raw_size - i)
sub_delta = s->_raw_size - i;
-
+ QUIT;
bfd_get_section_contents (abfd, s, buffer, i, sub_delta);
target_write_memory (s->vma + i, buffer, sub_delta);
printf_filtered ("*");
printf_filtered ("\n");
}
}
- immediate_quit--;
+
free (buffer);
write_pc (bfd_get_start_address (abfd));
bfd_close (abfd);
/* Remote serial interface for local (hardwired) serial ports for GO32.
Copyright 1992, 1993 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
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+ 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
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "defs.h"
#include "serial.h"
/* This is unused for now. We just return a placeholder. */
struct go32_ttystate
-{
- int bogus;
-};
-
-typedef struct {
- short jmp_op;
- short signature;
- short version;
- short buffer_start;
- short buffer_end;
- short getp;
- short putp;
- short iov;
-} ASYNC_STRUCT;
+ {
+ int bogus;
+ };
+
+typedef struct
+ {
+ short jmp_op;
+ short signature;
+ short version;
+ short buffer_start;
+ short buffer_end;
+ short getp;
+ short putp;
+ short iov;
+ }
+ASYNC_STRUCT;
static int go32_open PARAMS ((serial_t scb, const char *name));
static void go32_raw PARAMS ((serial_t scb));
-static int wait_for PARAMS ((serial_t scb, int timeout));
static int go32_readchar PARAMS ((serial_t scb, int timeout));
-static int rate_to_code PARAMS ((int rate));
static int go32_setbaudrate PARAMS ((serial_t scb, int rate));
static int go32_write PARAMS ((serial_t scb, const char *str, int len));
-static void go32_restore PARAMS ((serial_t scb));
static void go32_close PARAMS ((serial_t scb));
static serial_ttystate go32_get_tty_state PARAMS ((serial_t scb));
static int go32_set_tty_state PARAMS ((serial_t scb, serial_ttystate state));
-static int strncasecmp PARAMS ((const char *str1, const char *str2, int len));
static char *aptr PARAMS ((short p));
static ASYNC_STRUCT *getivec PARAMS ((int which));
static int dos_async_init PARAMS ((int port));
static void dos_async_tx PARAMS ((const char c));
-static int dos_async_ready PARAMS (());
static int dos_async_rx PARAMS (());
static int dosasync_read PARAMS ((int fd, char *buf, int len, int timeout));
static int dosasync_write PARAMS ((int fd, const char *buf, int len));
#define peek(a,b) (*(unsigned short *)(0xe0000000 + (a)*16 + (b)))
-static ASYNC_STRUCT *async;
+static volatile ASYNC_STRUCT *async;
static int iov;
#define com_rb iov
#define com_tb iov
#define com_lsr iov+5
#define com_msr iov+6
-static int
-strncasecmp(str1, str2, len)
- const char *str1, *str2;
- register int len;
-{
- unsigned char c1, c2;
-
- for (; len != 0; --len)
- {
- c1 = *str1++;
- c2 = *str2++;
-
- if (toupper(c1) != toupper(c2))
- return toupper(c1) - toupper(c2);
-
- if (c1 == '\0')
- return 0;
- }
- return 0;
-}
-
static char *
-aptr(p)
+aptr (p)
short p;
{
- return (char *)((unsigned)async - OFFSET + p);
+ return (char *) ((unsigned) async - OFFSET + p);
}
static ASYNC_STRUCT *
-getivec(int which)
+getivec (int which)
{
ASYNC_STRUCT *a;
- if (peek(0, which*4) != OFFSET)
+ if (peek (0, which * 4) != OFFSET)
return 0;
- a = (ASYNC_STRUCT *)(0xe0000000 + peek(0, which*4+2)*16 + peek(0, which*4));
+ a = (ASYNC_STRUCT *) (0xe0000000 + peek (0, which * 4 + 2) * 16 + peek (0, which * 4));
if (a->signature != SIGNATURE)
return 0;
}
static int
-dos_async_init(port)
+dos_async_init (port)
int port;
{
- int i;
-
switch (port)
{
case 1:
if (!async)
{
- error("GDB cannot connect to asynctsr program, check that it is installed\n\
+ error ("GDB cannot connect to asynctsr program, check that it is installed\n\
and that serial I/O is not being redirected (perhaps by NFS)\n\n\
example configuration:\n\
C> mode com%d:9600,n,8,1,p\n\
}
iov = async->iov;
- outportb(com_ier, 0x0f);
- outportb(com_bfr, 0x03);
- outportb(com_mcr, 0x0b);
+ outportb (com_ier, 0x0f);
+ outportb (com_bfr, 0x03);
+ outportb (com_mcr, 0x0b);
async->getp = async->putp = async->buffer_start;
-
+
return 1;
}
static void
-dos_async_tx(c)
+dos_async_tx (c)
const char c;
{
- while (~inportb(com_lsr) & 0x20);
-
- outportb(com_tb, c);
+ while (~inportb (com_lsr) & 0x20)
+ ;
+ outportb (com_tb, c);
}
-static int
-dos_async_ready()
-{
- return (async->getp != async->putp);
-}
+#define dos_async_ready() (async->getp != async->putp)
static int
-dos_async_rx()
+dos_async_rx ()
{
char rv;
- while (!dos_async_ready())
- if (kbhit())
- {
- printf_unfiltered("abort!\n");
- return 0;
- }
+ while (!dos_async_ready ())
+ {
+ if (kbhit ())
+ {
+ printf_unfiltered ("abort!\n");
+ return 0;
+ }
+ }
- rv = *aptr(async->getp++);
+ rv = *aptr (async->getp++);
if (async->getp >= async->buffer_end)
async->getp = async->buffer_start;
int timeout;
{
long now, then;
- int l = len;
+ int i;
time (&now);
then = now + timeout;
- while (l--)
+ for (i = 0; i < len; i++)
{
if (timeout)
{
- while (!dos_async_ready())
+ while (!dos_async_ready ())
{
time (&now);
if (now >= then)
- return len - l - 1;
+ return i;
}
}
- *buf++ = dos_async_rx();
+ *buf++ = dos_async_rx ();
}
-
return len;
}
static int
-dosasync_write(fd, buf, len)
+dosasync_write (fd, buf, len)
int fd;
const char *buf;
int len;
{
- int l = len;
+ int l;
- while (l--)
+ for (l = 0; l < len; l++)
dos_async_tx (*buf++);
return len;
return -11;
}
- scb->fd = dos_async_init(port);
+ scb->fd = dos_async_init (port);
if (!scb->fd)
return -1;
{
char buf;
- if (dosasync_read(scb->fd, &buf, 1, timeout))
+ /* Shortcut for polling */
+ if (timeout == 0)
+ {
+ if (dos_async_ready ())
+ {
+ return dos_async_rx ();
+ }
+ return SERIAL_TIMEOUT;
+ }
+
+ if (dosasync_read (scb->fd, &buf, 1, timeout))
return buf;
else
return SERIAL_TIMEOUT;
vector. Someday, they may do something real... */
static serial_ttystate
-go32_get_tty_state(scb)
+go32_get_tty_state (scb)
serial_t scb;
{
struct go32_ttystate *state;
- state = (struct go32_ttystate *)xmalloc(sizeof *state);
+ state = (struct go32_ttystate *) xmalloc (sizeof *state);
- return (serial_ttystate)state;
+ return (serial_ttystate) state;
}
static int
-go32_set_tty_state(scb, ttystate)
+go32_set_tty_state (scb, ttystate)
serial_t scb;
serial_ttystate ttystate;
{
- struct go32_ttystate *state;
-
return 0;
}
const char *str;
int len;
{
- dosasync_write(scb->fd, str, len);
+ dosasync_write (scb->fd, str, len);
return 0;
}
go32_close,
go32_readchar,
go32_write,
- go32_noop, /* flush output */
- go32_noop, /* flush input */
- go32_noop, /* send break -- currently used only for nindy */
+ go32_noop, /* flush output */
+ go32_noop, /* flush input */
+ go32_noop, /* send break -- currently used only for nindy */
go32_raw,
go32_get_tty_state,
go32_set_tty_state,
projects / external / binutils.git / commitdiff