mirror/binutils-gdb
2
0
Fork 0
mirror of https://sourceware.org/git/binutils-gdb.git synced 2024-12-27 04:52:05 +08:00
Code Issues Packages Projects Releases Wiki Activity
0e04a5142a
binutils-gdb/gdb/testsuite/gdb.trace/gdb_c_test.c
Fred Fish 04c12f60f9 Checked in under the "obvious fix/typo rule". 
2002-03-06  Fred Fish  <fnf@redhat.com>
	* gdb.base/funcargs.c:  Remove extraneous ';' character.
	* gdb.trace/gdb_c_test.c: Remove extraneous ';' character.
2002-03-07 04:18:55 +00:00

3793 lines
106 KiB
C
Raw Blame History

/*
******************************************************************************
******************************************************************************
*
* COPYRIGHT (C) by EMC Corporation, 1997 All rights reserved.
* $Id$
* DESCRIPTION: This module has been provided for the purpose of testing GDB.
*
* NOTES:
*
******************************************************************************
*****************************************************************************/
/*=============================================================================
* INCLUDE FILES
*===========================================================================*/
#ifdef DO_IT_BY_THE_BOOK
#include "symtypes_defs.h"
#include "printp.h"
#include "adbg_expression.h"
#include "common_hw_ds.h"
#include "common_hw_defs.h"
#include "evnttrac.h"
#include "sym_scratch_ds.h"
#include "symglob_ds.h"
#include "sym_protglob_ds.h"
#include "ether.h"
#include <ctype.h>
#else
#include "adbg_dtc.h"
#define YES 1
#define NO 0
#define TRUE 1
#define FALSE 0
#define ENABLED 1
#define DISABLED 0
#define CONTROL_C 3 /* ASCII 'ETX' */
/*
* Faked after ctype.h
*/
#define isxdigit(X) (((X) >= '0' && (X) <= '9') || \
((X) >= 'A' && (X) <= 'F') || \
((X) >= 'a' && (X) <= 'f'))
/*
* Borrowed from string.h
*/
extern unsigned int strlen ( const char * );
/*
* Extracted from symtypes.h:
*/
typedef char BOOL; /* 8 Bits */
typedef unsigned char UCHAR; /* 8 Bits */
typedef unsigned short USHORT; /* 16 Bits */
typedef unsigned long ULONG; /* 32 Bits */
/*
* for struct t_expr_tag and
* decl of build_and_add_expression
*/
#include "adbg_expression.h"
#define NULL 0
/*
* Extracted from printp.h:
*/
extern void printp ( const char * fptr, ... );
extern void sprintp ( const char * fptr, ... );
/*
* Extracted from ether.h:
*/
extern long eth_to_gdb ( UCHAR *buf, long length );
/*
* Derived from hwequs.s:
*/
#define CS_CODE_START 0x100000
#define CS_CODE_SIZE 0x200000
#define LAST_CS_WORD (CS_CODE_START + CS_CODE_SIZE - 2)
#define sh_genstat1 (*((volatile ULONG *) 0xFFFFFE54))
#define rs232_mode1 0 /* rs-232 mode 1 reg. */
#define rs232_mode2 rs232_mode1 /* rs-232 mode 2 reg. */
#define rs232_stat 4 /* rs-232 status reg. */
#define rs232_clk rs232_stat /* rs-232 clock select reg. */
#define rs232_cmd 8 /* rs-232 command reg */
#define rs232_transmit 12 /* rs-232 transmit reg. */
#define rs232_receive rs232_transmit /* rs-232 transmit reg. */
#define rs232_aux 16 /* rs-232 aux control reg. */
#define rs232_isr 20 /* rs-232 interrupt status reg. */
#define rs232_imr rs232_isr /* rs-232 interrupt mask reg. */
#define rs232_tc_high 24 /* rs-232 timer/counter high reg. */
#define rs232_tc_low 28 /* rs-232 timer/counter low reg. */
#endif
/*============================================================================
* MODULE DEFINES
*===========================================================================*/
#define P_RST_LAN_UART_REG ((volatile UCHAR *) 0xFFFFFE45)
#define M_RST_LAN_UART 0x80 /* Bit 7 */
#define P_LAN0TR_REG P_RST_LAN_UART_REG
#define M_LAN0TR 0x20 /* Bit 5 */
#define M_SH_GENCON_LAN0TR 0x00200000 /* Bit 21 */
#define MAX_RS232_CHARS 512
#define LAN_Q_MOD(X) ((X) % MAX_RS232_CHARS)
/*---------------------------------------*
* LAN UART Registers *
*---------------------------------------*/
#define LAN_UART_BASE ((ULONG) 0xfffffc22)
/* Write-Read */
#define P_LAN_MR1 ((volatile UCHAR *) (LAN_UART_BASE + ((ULONG) rs232_mode1 )))
#define P_LAN_MR2 ((volatile UCHAR *) (LAN_UART_BASE + ((ULONG) rs232_mode2 )))
/* Write-Only */
#define P_LAN_ACR ((volatile UCHAR *) (LAN_UART_BASE + ((ULONG) rs232_aux )))
#define P_LAN_CR ((volatile UCHAR *) (LAN_UART_BASE + ((ULONG) rs232_cmd )))
#define P_LAN_CSR ((volatile UCHAR *) (LAN_UART_BASE + ((ULONG) rs232_clk )))
#define P_LAN_CTLR ((volatile UCHAR *) (LAN_UART_BASE + ((ULONG) rs232_tc_low )))
#define P_LAN_CTUR ((volatile UCHAR *) (LAN_UART_BASE + ((ULONG) rs232_tc_high )))
#define P_LAN_IMR ((volatile UCHAR *) (LAN_UART_BASE + ((ULONG) rs232_imr )))
/* Read-Only */
#define P_LAN_SR ((volatile UCHAR *) (LAN_UART_BASE + ((ULONG) rs232_stat )))
#define P_LAN_ISR ((volatile UCHAR *) (LAN_UART_BASE + ((ULONG) rs232_isr )))
#define P_LAN_XMT ((volatile UCHAR *) (LAN_UART_BASE + ((ULONG) rs232_transmit)))
#define P_LAN_RCV ((volatile UCHAR *) (LAN_UART_BASE + ((ULONG) rs232_receive )))
/*
* Bit Values for Write-Read and Write-Only Registers
*/
#define DEFAULT_LAN_MR1 ((UCHAR) 0x13)
#define DEFAULT_LAN_MR2 ((UCHAR) 0x07)
#define DEFAULT_LAN_CSR ((UCHAR) 0xcc)
#define DEFAULT_LAN_ACR ((UCHAR) 0x38)
#define DEFAULT_LAN_CTUR ((UCHAR) 0xff)
#define DEFAULT_LAN_CTLR ((UCHAR) 0xff)
#define LAN_ACR_SELECT_BRG_0 DEFAULT_LAN_ACR
#define LAN_ACR_SELECT_BRG_1 (DEFAULT_LAN_ACR | 0x80)
#define UART_CR_RESET_MR_PTR ((UCHAR) 0x10) /* Reset MR pointer (points to MR1). */
#define UART_CR_RESET_RVCR ((UCHAR) 0x20) /* Reset receiver (disabled). */
#define UART_CR_RESET_XMTR ((UCHAR) 0x30) /* Reset transmitter (disabled). */
#define UART_CR_RESET_ERROR_STATUS ((UCHAR) 0x40) /* Reset error status. */
#define UART_CR_RESET_BRK_CHG_INT ((UCHAR) 0x50) /* Reset break change interrupt. */
#define UART_CR_START_CNTR_TIMER ((UCHAR) 0x80) /* Start counter/timer. */
#define UART_CR_STOP_CNTR ((UCHAR) 0x90) /* Stop counter. */
#define UART_CR_DISABLE_XMTR ((UCHAR) 0x08) /* Disable transmitter. */
#define UART_CR_ENABLE_XMTR ((UCHAR) 0x04) /* Enable transmitter. */
#define UART_CR_DISABLE_RCVR ((UCHAR) 0x02) /* Disable receiver. */
#define UART_CR_ENABLE_RCVR ((UCHAR) 0x01) /* Enable receiver. */
#define UART_CSR_BR_4800 ((UCHAR) 0x99) /* With either BRG Set selected (via ACR). */
#define UART_CSR_BR_9600 ((UCHAR) 0xbb) /* With either BRG Set selected (via ACR). */
#define UART_CSR_BR_19200 ((UCHAR) 0xcc) /* With BRG Set '1' selected (via ACR). */
#define UART_CSR_BR_38400 ((UCHAR) 0xcc) /* With BRG Set '0' selected (via ACR). */
#define UART_IMR_RxRDY ((UCHAR) 0x04) /* Enable 'RxRDY' interrupt. */
#define UART_IMR_TxEMT ((UCHAR) 0x02) /* Enable 'TxEMT' interrupt. */
#define UART_IMR_TxRDY ((UCHAR) 0x01) /* Enable 'TxRDY' interrupt. */
/*
* Bit Masks for Read-Only Registers
*/
#define M_UART_SR_RCVD_BRK 0x80 /* Bit 7 */
#define M_UART_SR_FE 0x40 /* Bit 6 */
#define M_UART_SR_PE 0x20 /* Bit 5 */
#define M_UART_SR_OE 0x10 /* Bit 4 */
#define M_UART_SR_TxEMT 0x08 /* Bit 3 */
#define M_UART_SR_TxRDY 0x04 /* Bit 2 */
#define M_UART_SR_FFULL 0x02 /* Bit 1 */
#define M_UART_SR_RxRDY 0x01 /* Bit 0 */
#define M_UART_ISR_RxRDY 0x04 /* Bit 2 */
#define M_UART_ISR_TxEMT 0x02 /* Bit 1 */
#define M_UART_ISR_TxRDY 0x01 /* Bit 0 */
/*---------------------------------------*
* Support for 'Utility 83'. *
*---------------------------------------*/
#define LAN_UTIL_CODE 0x83
#define LAN_INIT ((ULONG) (('I' << 24) | ('N' << 16) | ('I' << 8) | 'T'))
#define LAN_BAUD ((ULONG) (('B' << 24) | ('A' << 16) | ('U' << 8) | 'D'))
#define LAN_INTR ((ULONG) (('I' << 24) | ('N' << 16) | ('T' << 8) | 'R'))
#define LAN_XMT ((ULONG) (('X' << 16) | ('M' << 8) | 'T'))
#define LAN_ECHO ((ULONG) (('E' << 24) | ('C' << 16) | ('H' << 8) | 'O'))
#define LAN_STAT ((ULONG) (('S' << 24) | ('T' << 16) | ('A' << 8) | 'T'))
#define LAN_IN ((ULONG) (('I' << 8) | 'N'))
#define LAN_OUT ((ULONG) (('O' << 16) | ('U' << 8) | 'T'))
#define LAN_PUTC ((ULONG) (('P' << 24) | ('U' << 16) | ('T' << 8) | 'C'))
#define LAN_WPM ((ULONG) (('W' << 16) | ('P' << 8) | 'M'))
#define STATUS(X) ( ( ( X ) == 0 ) ? "disabled" : "enabled" )
#define XMT_VIA_BP_ENABLED() ( *P_LAN0TR_REG & M_LAN0TR ? 1 : 0 )
#define TRAP_1_INST 0x4E41
/*
* Bit #13 of shared genstat 1 indicates
* which processor we are as follows.
*
* 0 => X (side A)
* 1 => Y (side B)
*/
#define M_PROC_ID 0x00002000
#define IS_SIDE_A() ( ( (sh_genstat1) & M_PROC_ID ) == 0 )
#define IS_SIDE_B() ( (sh_genstat1) & M_PROC_ID )
#ifdef STANDALONE /* Compile this module stand-alone for debugging */
#define LAN_PUT_CHAR(X) printf("%c", X)
#else
#define LAN_PUT_CHAR(X) while ( lan_put_char( X ) )
#endif
#define VIA_RS232 0
#define VIA_ETHERNET 1
#define MAX_IO_BUF_SIZE 400
#define MAX_BYTE_CODES 200 /* maximum length for bytecode string */
static ULONG gdb_host_comm;
static ULONG gdb_cat_ack;
static char eth_outbuffer[ MAX_IO_BUF_SIZE + 1 ];
#ifdef STANDALONE
#define ACK_PKT() LAN_PUT_CHAR( '+' )
#define NACK_PKT() LAN_PUT_CHAR( '-' )
#else
#define ACK_PKT() { \
if ( VIA_ETHERNET == gdb_host_comm ) \
{ \
gdb_cat_ack = YES; \
} \
else \
{ \
LAN_PUT_CHAR( '+' ); \
} \
}
#define NACK_PKT() { \
if ( VIA_ETHERNET == gdb_host_comm ) \
{ \
eth_outbuffer[ 0 ] = '-'; \
eth_to_gdb( (UCHAR *) eth_outbuffer, 1 ); \
} \
else \
{ \
LAN_PUT_CHAR( '-' ); \
} \
}
#endif
/*============================================================================
* MODULE TYPEDEFS
*===========================================================================*/
typedef struct rs232_queue {
long head_index;
long tail_index;
ULONG overflows;
long gdb_packet_start;
long gdb_packet_end;
long gdb_packet_csum1;
long gdb_packet_csum2;
UCHAR buf[ MAX_RS232_CHARS ];
} T_RS232_QUEUE;
/*=============================================================================
* EXTERNAL GLOBAL VARIABLES
*===========================================================================*/
extern volatile UCHAR sss_trace_flag;
/*=============================================================================
* STATIC MODULE DECLARATIONS
*===========================================================================*/
static T_RS232_QUEUE lan_input_queue,
lan_output_queue;
static BOOL test_echo;
#if 0
/* The stub no longer seems to use this. */
static BOOL write_access_enabled;
#endif
static int baud_rate_idx;
static ULONG tx_by_intr,
tx_by_poll;
static UCHAR lan_shadow_imr;
/*=============================================================================
* EXTERNAL FUNCTION PROTOTYPES
*===========================================================================*/
extern long write_to_protected_mem( void *address, unsigned short value );
/*=============================================================================
* MODULE GLOBAL FUNCTIONS PROTOTYPES
*===========================================================================*/
ULONG gdb_c_test( ULONG *parm );
void lan_init( void );
void lan_isr( void );
long lan_get_char( void );
long lan_put_char( UCHAR c );
ULONG lan_util( ULONG *parm );
/*=============================================================================
* MODULE LOCAL FUNCTION PROTOTYPES
*===========================================================================*/
static void lan_reset( void );
static void lan_configure( void );
static void lan_init_queue( T_RS232_QUEUE *p_queue );
static void lan_add_to_queue( long c, T_RS232_QUEUE *p_queue );
static UCHAR lan_next_queue_char( T_RS232_QUEUE *p_queue );
static void lan_util_menu( void );
static long get_gdb_input( long c, T_RS232_QUEUE *p_input_q );
/*=============================================================================
* GDB STUB FUNCTION PROTOTYPES
*===========================================================================*/
void gdb_trap_1_handler( void );
void gdb_trace_handler ( void );
void gdb_get_eth_input( unsigned char *buf, long length );
static void getpacket ( void );
static void putpacket ( char * );
static void discard_packet ( void );
#ifdef STANDALONE /* Compile this module stand-alone for debugging */
#include <stdio.h>
#define printp printf /* easier than declaring a local varargs stub func. */
#endif /* STANDALONE */
/*=============================================================================
* MODULE BODY
*===========================================================================*/
/* ------------------- Things that belong in a header file --------------- */
extern char *memset (char *, int, int);
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*
* *
* Global Module Functions *
* *
*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
static char gdb_char_test;
static short gdb_short_test;
static long gdb_long_test;
static char gdb_arr_test[25];
static struct GDB_STRUCT_TEST
{
char c;
short s;
long l;
int bfield : 11; /* collect bitfield */
char arr[25];
struct GDB_STRUCT_TEST *next;
} gdb_struct1_test, gdb_struct2_test, *gdb_structp_test, **gdb_structpp_test;
static union GDB_UNION_TEST
{
char c;
short s;
long l;
int bfield : 11; /* collect bitfield */
char arr[4];
union GDB_UNION_TEST *next;
} gdb_union1_test;
void gdb_recursion_test (int, int, int, int, int, int, int);
void gdb_recursion_test (int depth,
int q1,
int q2,
int q3,
int q4,
int q5,
int q6)
{ /* gdb_recursion_test line 0 */
int q = q1; /* gdbtestline 1 */
q1 = q2; /* gdbtestline 2 */
q2 = q3; /* gdbtestline 3 */
q3 = q4; /* gdbtestline 4 */
q4 = q5; /* gdbtestline 5 */
q5 = q6; /* gdbtestline 6 */
q6 = q; /* gdbtestline 7 */
if (depth--) /* gdbtestline 8 */
gdb_recursion_test (depth, q1, q2, q3, q4, q5, q6); /* gdbtestline 9 */
}
ULONG gdb_c_test( ULONG *parm )
{
char *p = "gdb_c_test";
char *ridiculously_long_variable_name_with_equally_long_string_assignment;
register long local_reg = 7;
static unsigned long local_static, local_static_sizeof;
long local_long;
unsigned long *stack_ptr;
unsigned long end_of_stack;
ridiculously_long_variable_name_with_equally_long_string_assignment =
"ridiculously long variable name with equally long string assignment";
local_static = 9;
local_static_sizeof = sizeof (struct GDB_STRUCT_TEST);
local_long = local_reg + 1;
stack_ptr = (unsigned long *) &local_long;
end_of_stack =
(unsigned long) &stack_ptr + sizeof(stack_ptr) + sizeof(end_of_stack) - 1;
printp ("\n$Id$\n");
printp( "%s: arguments = %X, %X, %X, %X, %X, %X\n",
p, parm[ 1 ], parm[ 2 ], parm[ 3 ], parm[ 4 ], parm[ 5 ], parm[ 6 ] );
gdb_char_test = gdb_struct1_test.c = (char) ((long) parm[1] & 0xff);
gdb_short_test = gdb_struct1_test.s = (short) ((long) parm[2] & 0xffff);
gdb_long_test = gdb_struct1_test.l = (long) ((long) parm[3] & 0xffffffff);
gdb_union1_test.l = (long) parm[4];
gdb_arr_test[0] = gdb_struct1_test.arr[0] = (char) ((long) parm[1] & 0xff);
gdb_arr_test[1] = gdb_struct1_test.arr[1] = (char) ((long) parm[2] & 0xff);
gdb_arr_test[2] = gdb_struct1_test.arr[2] = (char) ((long) parm[3] & 0xff);
gdb_arr_test[3] = gdb_struct1_test.arr[3] = (char) ((long) parm[4] & 0xff);
gdb_arr_test[4] = gdb_struct1_test.arr[4] = (char) ((long) parm[5] & 0xff);
gdb_arr_test[5] = gdb_struct1_test.arr[5] = (char) ((long) parm[6] & 0xff);
gdb_struct1_test.bfield = 144;
gdb_struct1_test.next = &gdb_struct2_test;
gdb_structp_test = &gdb_struct1_test;
gdb_structpp_test = &gdb_structp_test;
gdb_recursion_test (3, (long) parm[1], (long) parm[2], (long) parm[3],
(long) parm[4], (long) parm[5], (long) parm[6]);
gdb_char_test = gdb_short_test = gdb_long_test = 0;
gdb_structp_test = (void *) 0;
gdb_structpp_test = (void *) 0;
memset ((char *) &gdb_struct1_test, 0, sizeof (gdb_struct1_test));
memset ((char *) &gdb_struct2_test, 0, sizeof (gdb_struct2_test));
local_static_sizeof = 0;
local_static = 0;
return ( (ULONG) 0 );
}
/*-----------------------------------------------------------------------------
*
* FUNCTION NAME: lan_init
*
*
* DESCRIPTION:
*
*
* RETURN VALUE:
*
*
* USED GLOBAL VARIABLES:
*
*
* AFFECTED GLOBAL VARIABLES/SIDE EFFECTS:
*
*
* NOTES:
*
*
*
*---------------------------------------------------------------------------*/
void lan_init( void )
{
if ( IS_SIDE_A( ) )
{
lan_reset( );
lan_init_queue( &lan_input_queue );
lan_init_queue( &lan_output_queue );
lan_configure( );
}
return;
}
/* end of 'lan_init'
*===========================================================================*/
/*-----------------------------------------------------------------------------
*
* FUNCTION NAME: lan_isr
*
*
* DESCRIPTION:
*
*
* RETURN VALUE: None.
*
*
* USED GLOBAL VARIABLES:
*
*
* AFFECTED GLOBAL VARIABLES/SIDE EFFECTS:
*
*
* NOTES:
*
*
*---------------------------------------------------------------------------*/
void lan_isr( void )
{
UCHAR c;
lan_shadow_imr = 0; /* Disable all UART interrupts. */
*P_LAN_IMR = lan_shadow_imr;
if ( *P_LAN_ISR & M_UART_ISR_RxRDY )
{
gdb_host_comm = VIA_RS232;
c = *P_LAN_RCV;
if ( test_echo )
{
/* ????? */
}
if ( c == CONTROL_C )
{
/* can't stop the target, but we can tell gdb to stop waiting... */
discard_packet( );
putpacket( "S03" ); /* send back SIGINT to the debugger */
}
else
{
lan_add_to_queue( (long) c, &lan_input_queue );
get_gdb_input( (long) c, &lan_input_queue );
}
}
if ( XMT_VIA_BP_ENABLED( ) )
{
c = 0;
while ( (*P_LAN_ISR & M_UART_ISR_TxRDY) && (c = lan_next_queue_char( &lan_output_queue )) )
{
*P_LAN_XMT = c;
++tx_by_intr;
}
if ( c )
{
lan_shadow_imr |= UART_IMR_TxRDY; /* (Re-)Enable 'TxRDY' interrupt from UART. */
}
}
lan_shadow_imr |= UART_IMR_RxRDY; /* Re-Enable 'RxRDY' interrupt from UART. */
*P_LAN_IMR = lan_shadow_imr;
return;
}
/* end of 'lan_isr'
*===========================================================================*/
/*-----------------------------------------------------------------------------
*
* FUNCTION NAME: lan_get_char
*
*
* DESCRIPTION: Fetches a character from the UART.
*
*
* RETURN VALUE: 0 on success, -1 on failure.
*
*
* USED GLOBAL VARIABLES:
*
*
* AFFECTED GLOBAL VARIABLES/SIDE EFFECTS:
*
*
* NOTES:
*
*
*---------------------------------------------------------------------------*/
long lan_get_char( void )
{
long status = -2; /* AGD: nothing found in rcv buffer */
if ( *P_LAN_SR & M_UART_SR_RxRDY )
{
char c = (char) *P_LAN_RCV;
if ( test_echo )
{
LAN_PUT_CHAR ( c );
}
if ( c == CONTROL_C )
{
/* can't stop the target, but we can tell gdb to stop waiting... */
discard_packet( );
putpacket( "S03" ); /* send back SIGINT to the debugger */
status = 0; /* success */
}
else
{
lan_add_to_queue( (long) c, &lan_input_queue );
status = get_gdb_input( (long) c, &lan_input_queue );
}
}
return( status );
}
/* end of 'lan_get_char'
*===========================================================================*/
/*-----------------------------------------------------------------------------
*
* FUNCTION NAME: lan_put_char
*
* DESCRIPTION: Puts a character out via the UART.
*
* RETURN VALUE: 0 on success, -1 on failure.
*
* USED GLOBAL VARIABLES: none.
*
* AFFECTED GLOBAL VARIABLES/SIDE EFFECTS:
*
* NOTES: !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
* !! !!
* !! If 'XMT_VIA_BP_ENABLED()' is FALSE then output is THROWN AWAY. !!
* !! This prevents anyone infinite-looping on this function. !!
* !! !!
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
*
*---------------------------------------------------------------------------*/
long lan_put_char( UCHAR c )
{
long status = -1;
if ( XMT_VIA_BP_ENABLED( ) )
{
if ( *P_LAN_SR & M_UART_SR_TxRDY )
{
lan_add_to_queue( (long) c, &lan_output_queue );
c = lan_next_queue_char( &lan_output_queue );
*P_LAN_XMT = c;
++tx_by_poll;
status = 0;
}
#if 0
else
{
status = 0;
lan_shadow_imr |= UART_IMR_TxRDY; /* Enable 'TxRDY' interrupt from UART. */
*P_LAN_IMR = lan_shadow_imr;
}
#endif
}
else
{
status = 0; /* You lose: input character goes to the bit bucket. */
}
return( status );
}
/* end of 'lan_put_char'
*===========================================================================*/
/*-----------------------------------------------------------------------------
*
* FUNCTION NAME: lan_util
*
* DESCRIPTION:
*
* RETURN VALUE:
*
* USED GLOBAL VARIABLES:
*
* AFFECTED GLOBAL VARIABLES/SIDE EFFECTS:
*
* NOTES:
*
*---------------------------------------------------------------------------*/
ULONG lan_util( ULONG *parm )
{
static const struct {
ULONG rate_code;
UCHAR acr_setting;
UCHAR csr_setting;
} baud_rate_setting [] = {
{ 0x38400, LAN_ACR_SELECT_BRG_0, UART_CSR_BR_38400 },
{ 0x19200, LAN_ACR_SELECT_BRG_1, UART_CSR_BR_19200 },
{ 0x9600, LAN_ACR_SELECT_BRG_0, UART_CSR_BR_9600 },
{ 0x4800, LAN_ACR_SELECT_BRG_0, UART_CSR_BR_4800 }
};
#define BOGUS_P1 0xE1
#define BOGUS_P2 0xE2
ULONG not_done_code;
ULONG opcode;
ULONG parm_1;
ULONG parm_2;
int i;
UCHAR c;
not_done_code = 0;
opcode = parm[ 1 ];
parm_1 = parm[ 2 ];
parm_2 = parm[ 3 ];
switch ( opcode )
{
case LAN_INIT:
{
lan_init( );
printp( "\n\n Interface (Re)Initialized ...\n\n" );
break;
}
case LAN_BAUD:
{
for ( i = 0; i < (int)(sizeof(baud_rate_setting) / sizeof(baud_rate_setting[0])); i ++ )
{
if ( baud_rate_setting[i].rate_code == parm_1 )
{
baud_rate_idx = i;
*P_LAN_ACR = baud_rate_setting[i].acr_setting;
*P_LAN_CSR = baud_rate_setting[i].csr_setting;
printp ( "Baud rate set to %X!\n", baud_rate_setting[i].rate_code );
return( not_done_code );
}
}
printp( "\n\n *** SYNTAX Error - Invalid baudrate (P2)\n\n" );
not_done_code = BOGUS_P2;
break;
}
case LAN_INTR:
{
switch ( parm_1 )
{
case 0x0D: /* Disable 'RxRDY' Interrupts */
{
lan_shadow_imr &= ~UART_IMR_RxRDY;
*P_LAN_IMR = lan_shadow_imr;
printp( "\n\n Receive Ready Interrupts DISABLED ...\n\n" );
break;
}
case 0x0E: /* Enable 'RxRDY' Interrupts */
{
lan_shadow_imr |= UART_IMR_RxRDY;
*P_LAN_IMR = lan_shadow_imr;
printp( "\n\n Receive Ready Interrupts ENABLED ...\n\n" );
break;
}
default:
{
printp( "\n\n *** SYNTAX Error - Invalid P2 (use D or E)\n\n" );
not_done_code = BOGUS_P2;
}
}
break;
}
case LAN_XMT:
{
switch ( parm_1 )
{
case 0x0E: /* Enable Transmission-via-Backplane */
{
if ( !(*P_LAN0TR_REG & M_LAN0TR) )
{
*P_LAN0TR_REG |= M_LAN0TR; /* 0 -> 1 */
}
printp( "\n\n Transmit-via-Backplane ENABLED ...\n\n" );
break;
}
case 0x0D: /* Disable Transmission-via-Backplane */
{
if ( *P_LAN0TR_REG & M_LAN0TR )
{
*P_LAN0TR_REG &= ~M_LAN0TR; /* 1 -> 0 */
}
printp( "\n\n Transmit-via-Backplane DISABLED ...\n\n" );
break;
}
default:
{
printp( "\n\n *** SYNTAX Error - Invalid P2 (use D or E)\n\n" );
not_done_code = BOGUS_P2;
lan_util_menu( );
}
}
break;
}
case LAN_STAT:
{
printp( "\n -- Status --\n\n" );
printp( " Baud Rate: %X *\n", baud_rate_setting[ baud_rate_idx ].rate_code );
printp( " Xmt-via-BP: %s *\n", STATUS( XMT_VIA_BP_ENABLED( ) ) );
printp( " RxRdy Intr: %s *\n", STATUS( (lan_shadow_imr & M_UART_ISR_RxRDY) ) );
/*** printp( " TxRdy Intr: %s\n", STATUS( (lan_shadow_imr & M_UART_ISR_TxRDY) ) ); ***/
printp( " Echo: %s *\n\n", STATUS( test_echo ) );
printp( " IMR: %02X\n", (ULONG) lan_shadow_imr );
printp( " ISR: %02X\n", (ULONG) *P_LAN_ISR );
printp( " SR: %02X\n\n", (ULONG) *P_LAN_SR );
printp( " Input Overflows: %d\n\n", lan_input_queue.overflows );
printp( " Tx by Intr: %d\n", tx_by_intr );
printp( " Tx by Poll: %d\n\n", tx_by_poll );
printp( " * Can be set or toggled via Utility %2X.\n\n", (ULONG) LAN_UTIL_CODE );
break;
}
case LAN_IN:
{
switch ( parm_1 )
{
case 0x0C: /* Clear and Reset Queue */
{
lan_init_queue( &lan_input_queue );
printp( "\n\n Queue CLEARED/RESET ...\n\n" );
break;
}
case 0x0D: /* Display Queue */
{
printp( "\n -- Input Queue --\n" );
printp( "\n Head Index: %8X Tail Index: %8X\n\n ",
(ULONG) lan_input_queue.head_index, (ULONG) lan_input_queue.tail_index );
for ( i = 0; i < MAX_RS232_CHARS; ++i )
{
printp( " %02X", (ULONG) lan_input_queue.buf[ i ] );
if ( 15 == (i % 16) )
{
int j;
printp ( " " );
for ( j = i - 15; j <= i; j++ )
{
if ( lan_input_queue.buf[ j ] >= ' ' &&
lan_input_queue.buf[ j ] < 127 )
printp ( "%c", lan_input_queue.buf[ j ] );
else
printp ( "." );
}
printp( "\n " );
}
else if ( 7 == (i % 8) )
{
printp( " " );
}
}
printp( "\n" );
break;
}
case 0x0F: /* Fetch next character in Queue */
{
c = lan_next_queue_char( &lan_input_queue );
if ( c )
{
printp( "\n\n Next Character: " );
if ( 0x21 <= c && c <= 0x7F )
{
printp( "%c\n\n", (ULONG) c );
}
else if ( 0x20 == ((UCHAR) c) )
{
printp( "<space>\n\n" );
}
else
{
printp( "%02X\n\n", (ULONG) c );
}
}
else
{
printp( "\n\n Input Queue EMPTY ...\n\n" );
}
break;
}
default:
{
printp( "\n\n *** SYNTAX Error - Invalid P2 ...\n\n" );
not_done_code = BOGUS_P2;
break;
}
}
break;
}
case LAN_OUT:
{
switch ( parm_1 )
{
case 0x0C: /* Clear and Reset Queue */
{
lan_init_queue( &lan_output_queue );
printp( "\n\n Queue CLEARED/RESET ...\n\n" );
break;
}
case 0x0D: /* Display Queue */
{
printp( "\n -- Output Queue --\n" );
printp( "\n Head Index: %8X Tail Index: %8X\n\n ",
(ULONG) lan_output_queue.head_index, (ULONG) lan_output_queue.tail_index );
for ( i = 0; i < MAX_RS232_CHARS; ++i )
{
printp( " %02X", (ULONG) lan_output_queue.buf[ i ] );
if ( 15 == (i % 16) )
{
int j;
printp ( " " );
for ( j = i - 15; j <= i; j++ )
{
if ( lan_output_queue.buf[ j ] >= ' ' &&
lan_output_queue.buf[ j ] < 127 )
printp ( "%c", lan_output_queue.buf[ j ] );
else
printp ( "." );
}
printp( "\n " );
}
else if ( 7 == (i % 8) )
{
printp( " " );
}
}
printp( "\n" );
break;
}
case 0x0F: /* Fetch next character in Queue */
{
c = lan_next_queue_char( &lan_output_queue );
if ( c )
{
printp( "\n\n Next Character: " );
if ( 0x21 <= c && c <= 0x7F )
{
printp( "%c\n\n", (ULONG) c );
}
else if ( 0x20 == c )
{
printp( "<space>\n\n" );
}
else
{
printp( "%02X\n\n", (ULONG) c );
}
}
else
{
printp( "\n\n Input Queue EMPTY ...\n\n" );
}
break;
}
default:
{
printp( "\n\n *** SYNTAX Error - Invalid P2 ...\n\n" );
not_done_code = BOGUS_P2;
break;
}
}
break;
}
case LAN_ECHO:
{
switch ( parm_1 )
{
case 0x0E:
{
test_echo = ENABLED;
printp( "\n\n Test echo ENABLED ...\n\n" );
break;
}
case 0x0D:
{
test_echo = DISABLED;
printp( "\n\n Test echo DISABLED ...\n\n" );
break;
}
default:
{
printp( "\n\n *** SYNTAX Error - Invalid P2 ...\n\n" );
not_done_code = BOGUS_P2;
break;
}
}
break;
}
case LAN_PUTC:
{
if ( 0x20 < parm_1 && parm_1 < 0x7F )
{
if ( lan_put_char( (UCHAR) parm_1 ) )
{
printp( "\n\n *** 'lan_put_char' Error ...\n" );
}
else
{
printp( "\n\n O.K. ...\n" );
}
}
else
{
printp( "\n\n *** Error - character must be in the 0x21-0x7E range ...\n" );
not_done_code = BOGUS_P2;
}
break;
}
/***
case LAN_WPM:
{
if ( write_to_protected_mem( (void *) parm_1, (unsigned short) parm_2 ) )
{
printp( "\n Write to protected memory FAILED ...\n" );
}
break;
}
***/
case 0: /* no argument -- print menu */
{
lan_util_menu( );
break;
}
default:
{
parm_2 = 0; /* to supress compiler warning with 'LAN_WPM' case disabled */
printp( "\n\n *** SYNTAX Error - Invalid P1 ...\n\n" );
not_done_code = BOGUS_P1;
break;
}
} /* End of 'switch ( opcode )'. */
return( not_done_code );
}
/* end of 'lan_util'
*===========================================================================*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*
* *
* Local Module Functions *
* *
*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*-----------------------------------------------------------------------------
*
* FUNCTION NAME: lan_reset
*
* DESCRIPTION: Resets the LAN UART by strobing the 'RST_LAN_UART' bit in the
* Shared Control 1 area.
*
* 1 _| ______
* | | |
* Bit | | |
* | | |
* 0 _|______| |______
* |---------------------> t
*
* RETURN VALUE: None.
*
* USED GLOBAL VARIABLES:
*
* AFFECTED GLOBAL VARIABLES/SIDE EFFECTS:
*
* NOTES: H/W configuration requires that a byte in the shared
* control 1 area must be read before being written.
*
*---------------------------------------------------------------------------*/
static void lan_reset( void )
{
while ( *P_RST_LAN_UART_REG & M_RST_LAN_UART )
{
*P_RST_LAN_UART_REG &= ~M_RST_LAN_UART; /* 0 */
}
while ( !(*P_RST_LAN_UART_REG & M_RST_LAN_UART) )
{
*P_RST_LAN_UART_REG |= M_RST_LAN_UART; /* 1 */
}
while ( *P_RST_LAN_UART_REG & M_RST_LAN_UART )
{
*P_RST_LAN_UART_REG &= ~M_RST_LAN_UART; /* 0 */
}
}
/* end of 'lan_reset'
*===========================================================================*/
/*-----------------------------------------------------------------------------
*
* FUNCTION NAME: lan_configure
*
*
* DESCRIPTION:
*
*
* RETURN VALUE:
*
*
* USED GLOBAL VARIABLES:
*
*
* AFFECTED GLOBAL VARIABLES/SIDE EFFECTS:
*
*
* NOTES:
*
*
*
*---------------------------------------------------------------------------*/
static void lan_configure( void )
{
*P_LAN_CR = UART_CR_RESET_MR_PTR; /* Points to MR1. */
*P_LAN_CR = UART_CR_RESET_RVCR; /* Receiver disabled. */
*P_LAN_CR = UART_CR_RESET_XMTR; /* Transmitter disabled. */
*P_LAN_CR = UART_CR_RESET_ERROR_STATUS;
*P_LAN_CR = UART_CR_RESET_BRK_CHG_INT;
*P_LAN_MR1 = DEFAULT_LAN_MR1;
*P_LAN_MR2 = DEFAULT_LAN_MR2;
*P_LAN_ACR = DEFAULT_LAN_ACR;
*P_LAN_CSR = UART_CSR_BR_9600;
baud_rate_idx = 2;
*P_LAN_CTUR = DEFAULT_LAN_CTUR;
*P_LAN_CTLR = DEFAULT_LAN_CTLR;
*P_LAN_CR = (UART_CR_START_CNTR_TIMER | UART_CR_ENABLE_XMTR | UART_CR_ENABLE_RCVR);
lan_shadow_imr = UART_IMR_RxRDY; /* Enable only 'RxRDY' interrupt from UART. */
*P_LAN_IMR = lan_shadow_imr;
tx_by_intr = 0;
tx_by_poll = 0;
return;
}
/* end of 'lan_configure'
*===========================================================================*/
/*-----------------------------------------------------------------------------
*
* FUNCTION NAME: lan_init_queue
*
* DESCRIPTION:
*
* RETURN VALUE: None.
*
* USED GLOBAL VARIABLES:
*
* AFFECTED GLOBAL VARIABLES/SIDE EFFECTS:
*
* NOTES:
*
*---------------------------------------------------------------------------*/
static void lan_init_queue( T_RS232_QUEUE *p_queue )
{
long i;
/*
* We set "head" equal to "tail" implying the queue is empty,
* BUT the "head" and "tail" should each point to valid queue
* positions.
*/
p_queue->head_index = 0;
p_queue->tail_index = 0;
p_queue->overflows = 0;
p_queue->gdb_packet_start = -1;
p_queue->gdb_packet_end = -1;
p_queue->gdb_packet_csum1 = -1;
p_queue->gdb_packet_csum2 = -1;
for ( i = 0; i < MAX_RS232_CHARS; ++i )
{
p_queue->buf[ i ] = 0;
}
return;
}
/* end of 'lan_init_queue'
*===========================================================================*/
/*-----------------------------------------------------------------------------
*
* FUNCTION NAME: lan_add_to_queue
*
*
* DESCRIPTION: Adds the specified character to the tail of the
* specified queue. Observes "oldest thrown on floor"
* rule (i.e. the queue is allowed to "wrap" and the
* input character is unconditionally placed at the
* tail of the queue.
*
*
* RETURN VALUE: None.
*
*
* USED GLOBAL VARIABLES:
*
*
* AFFECTED GLOBAL VARIABLES/SIDE EFFECTS:
*
*
* NOTES:
*
*
*---------------------------------------------------------------------------*/
static void lan_add_to_queue( long c, T_RS232_QUEUE *p_queue )
{
if ( p_queue ) /* Sanity check. */
{
if ( c & 0x000000FF ) /* We don't allow NULL characters to be added to a queue. */
{
/* Insert the new character at the tail of the queue. */
p_queue->buf[ p_queue->tail_index ] = (UCHAR) (c & 0x000000FF);
/* Increment the tail index. */
if ( MAX_RS232_CHARS <= ++(p_queue->tail_index) )
{
p_queue->tail_index = 0;
}
/* Check for wrapping (i.e. overflow). */
if ( p_queue->head_index == p_queue->tail_index )
{
/* If the tail has caught up to the head record the overflow . . . */
++(p_queue->overflows);
/* . . . then increment the head index. */
if ( MAX_RS232_CHARS <= ++(p_queue->head_index) )
{
p_queue->head_index = 0;
}
}
} /* End of 'if ( c & 0x000000FF )'. */
} /* End of 'if ( p_queue )'. */
return;
}
/* end of 'lan_add_to_queue'
*===========================================================================*/
/*-----------------------------------------------------------------------------
*
* FUNCTION NAME: lan_next_queue_char
*
* DESCRIPTION:
*
* RETURN VALUE:
*
* USED GLOBAL VARIABLES:
*
* AFFECTED GLOBAL VARIABLES/SIDE EFFECTS:
*
* NOTES:
*
*---------------------------------------------------------------------------*/
static UCHAR lan_next_queue_char( T_RS232_QUEUE *p_queue )
{
UCHAR c;
c = 0;
if ( p_queue )
{
if ( p_queue->head_index != p_queue->tail_index )
{
/* Return the 'oldest' character in the queue. */
c = p_queue->buf[ p_queue->head_index ];
/* Increment the head index. */
if ( MAX_RS232_CHARS <= ++(p_queue->head_index) )
{
p_queue->head_index = 0;
}
}
} /* End of 'if ( p_queue )'. */
return( c );
}
/* end of 'lan_next_queue_char'
*===========================================================================*/
/*-----------------------------------------------------------------------------
*
* FUNCTION NAME: lan_util_menu
*
* DESCRIPTION: Prints out a brief help on the LAN UART control utility.
*
* RETURN VALUE: None.
*
* USED GLOBAL VARIABLES: None.
*
* AFFECTED GLOBAL VARIABLES/SIDE EFFECTS: None.
*
* NOTES: None.
*
*---------------------------------------------------------------------------*/
static void lan_util_menu( void )
{
/*
* Multiply calling printp() below is made due to the limitations
* of printp(), incapable of handling long formatting constants:
*/
printp( "\n -- Options --\n\n" );
printp( " %2X,'INIT' ............... Reset & (Re)INITIALIZE Interface.\n", (ULONG) LAN_UTIL_CODE );
printp( " %2X,'BAUD',<rate> ........ Set BAUD Rate.\n", (ULONG) LAN_UTIL_CODE );
printp( " %2X,'INTR',<mode> ........ Toggle 'RxRDY' Interrupts.\n", (ULONG) LAN_UTIL_CODE );
printp( " %2X,'XMT',<mode> ......... Toggle TRANSMIT-via-backplane.\n", (ULONG) LAN_UTIL_CODE );
printp( " %2X,'STAT' ............... Display STATUS.\n", (ULONG) LAN_UTIL_CODE );
printp( " %2X,'ECHO',<mode> ........ Enable/Disable Test ECHO.\n", (ULONG) LAN_UTIL_CODE );
printp( " %2X,'IN',<action> ........ Access INPUT Queue.\n", (ULONG) LAN_UTIL_CODE );
printp( " %2X,'OUT',<action> ....... Access OUTPUT Queue.\n\n", (ULONG) LAN_UTIL_CODE );
printp( " %2X,'PUTC',<char> ........ Output a Character (i.e. <char>).\n\n", (ULONG) LAN_UTIL_CODE );
/***
printp( " %2X,'WPM',address,word ... Write Protected Memory Test.\n\n", (ULONG) LAN_UTIL_CODE );
***/
printp( " <rate>: 4800 <mode>: E - enable <action>: C - clear/reset\n" );
printp( " 9600 D - disable D - display\n" );
printp( " 19200 F - fetch next char\n" );
printp( " 38400\n" );
}
/* end of 'lan_util_menu'
*===========================================================================*/
/* Thu Feb 5 17:14:41 EST 1998 CYGNUS...CYGNUS...CYGNUS...CYGNUS...CYGNUS...CYGNUS...CYGNUS...CYGNUS */
static long get_gdb_input( long c, T_RS232_QUEUE * p_input_q )
{
/* Now to detect when we've got a gdb packet... */
if ( '$' == c ) { /* char marks beginning of a packet */
if ( -1 != p_input_q->gdb_packet_start ||
-1 != p_input_q->gdb_packet_end ||
-1 != p_input_q->gdb_packet_csum1 ||
-1 != p_input_q->gdb_packet_csum2 ) { /* PROTOCOL ERROR */
/* NEW: Actually, this probably means that we muffed a packet,
and GDB has already resent it. The thing to do now is to
throw away the one we WERE working on, but immediately start
accepting the new one. Don't NAK, or GDB will have to try
and send it yet a third time! */
/*NACK_PKT( );*/ /*<ETHERNET>*/
discard_packet( ); /* throw away old packet */
lan_add_to_queue ('$', p_input_q); /* put the new "$" back in */
return 0;
} else { /* match new "$" */
p_input_q->gdb_packet_start = p_input_q->tail_index;
p_input_q->gdb_packet_end =
p_input_q->gdb_packet_csum1 =
p_input_q->gdb_packet_csum2 = -1;
}
} else if ( '#' == c ) { /* # marks end of packet (except for checksum) */
if ( -1 == p_input_q->gdb_packet_start ||
-1 != p_input_q->gdb_packet_end ||
-1 != p_input_q->gdb_packet_csum1 ||
-1 != p_input_q->gdb_packet_csum2 ) { /* PROTOCOL ERROR */
/* Garbled packet. Discard, but do not NAK. */
/*NACK_PKT( );*/ /*<ETHERNET>*/
discard_packet( );
return -1;
}
p_input_q->gdb_packet_end = p_input_q->tail_index;
p_input_q->gdb_packet_csum1 = p_input_q->gdb_packet_csum2 = -1;
} else if ( -1 != p_input_q->gdb_packet_start &&
-1 != p_input_q->gdb_packet_end) {
if ( isxdigit( c ) ) { /* char is one of two checksum digits for packet */
if ( -1 == p_input_q->gdb_packet_csum1 &&
LAN_Q_MOD( p_input_q->gdb_packet_end + 1 ) ==
p_input_q->tail_index ) {
/* first checksum digit */
p_input_q->gdb_packet_csum1 = p_input_q->tail_index;
p_input_q->gdb_packet_csum2 = -1;
} else if ( -1 == p_input_q->gdb_packet_csum2 &&
LAN_Q_MOD( p_input_q->gdb_packet_end + 2 ) ==
p_input_q->tail_index ) {
/* second checksum digit: packet is complete! */
p_input_q->gdb_packet_csum2 = p_input_q->tail_index;
getpacket(); /* got a packet -- extract it */
} else { /* probably can't happen (um... three hex digits?) */
/* PROTOCOL ERROR */
/* Not sure how this can happen, but ...
discard it, but do not NAK it. */
/*NACK_PKT( );*/ /*<ETHERNET>*/
discard_packet( );
return -1;
}
} else { /* '#' followed by non-hex char */
/* PROTOCOL ERROR */
/* Bad packet -- discard but do not NAK */
/*NACK_PKT( );*/ /*<ETHERNET>*/
discard_packet( );
return -1;
}
}
return 0;
}
#ifdef STANDALONE
/* stand-alone stand-alone stand-alone stand-alone stand-alone stand-alone
stand-alone stand-alone
stand-alone Enable stand-alone build, for ease of debugging stand-alone
stand-alone stand-alone
stand-alone stand-alone stand-alone stand-alone stand-alone stand-alone */
long write_to_protected_mem (addr, word)
void *addr;
unsigned short word;
{
return 0;
}
char dummy_memory[0x4000];
int main ( void )
{
long c;
lan_init_queue( &lan_input_queue );
printf( "Stand-alone EMC 'stub', pid = %d\n", getpid( ) );
printf( "Start of simulated 'memory': 0x%08x\n", &dummy_memory);
while ( (c = getc( stdin ) ) != EOF )
{
if ( c == '\\' ) /* escape char */
break;
lan_add_to_queue( c, &lan_input_queue );
get_gdb_input (c, &lan_input_queue);
fflush( stdout );
}
printf( "Goodbye!\n" );
exit( 0 );
}
#define SRAM_START ((void *) (&dummy_memory[0] + 0x00000000))
#define SRAM_END ((void *) (&dummy_memory[0] + 0x00000400))
#define RO_AREA_START ((void *) (&dummy_memory[0] + 0x00000100))
#define RO_AREA_END ((void *) (&dummy_memory[0] + 0x00000300))
#define NVD_START ((void *) (&dummy_memory[0] + 0x00003000))
#define NVD_END ((void *) (&dummy_memory[0] + 0x00003100))
#else /* normal stub (not stand-alone) */
#define SRAM_START ((void *) 0x00000000)
#define SRAM_END ((void *) 0x00400000)
#define RO_AREA_START ((void *) 0x00100000)
#define RO_AREA_END ((void *) 0x00300000)
#define NVD_START ((void *) 0x03000000)
#define NVD_END ((void *) 0x03100000)
#endif /* STANDALONE */
/* gdb gdb gdb gdb gdb gdb gdb gdb gdb gdb gdb gdb gdb gdb gdb gdb gdb gdb
gdb gdb
gdb Here begins the gdb stub section. gdb
gdb The following functions were added by Cygnus, gdb
gdb to make this thing act like a gdb stub. gdb
gdb gdb
gdb gdb gdb gdb gdb gdb gdb gdb gdb gdb gdb gdb gdb gdb gdb gdb gdb gdb */
/* ------------------- global defines and data decl's -------------------- */
#define hexchars "0123456789abcdef"
/* there are 180 bytes of registers on a 68020 w/68881 */
/* many of the fpa registers are 12 byte (96 bit) registers */
#define NUMREGBYTES 180
#define NUMREGS 29
#define REGISTER_BYTE(regno) regno
enum regnames { D0, D1, D2, D3, D4, D5, D6, D7,
A0, A1, A2, A3, A4, A5, A6, A7,
PS, PC,
FP0, FP1,
FP2, FP3,
FP4, FP5,
FP6, FP7,
FPCONTROL, FPSTATUS, FPIADDR
};
unsigned long registers[NUMREGBYTES/4];
static long remote_debug;
#define BUFMAX MAX_IO_BUF_SIZE
static char inbuffer[BUFMAX], outbuffer[BUFMAX];
static char spare_buffer[BUFMAX];
struct stub_trace_frame
{
int valid;
unsigned long frame_id;
unsigned long tdp_id;
FRAME_DEF *frame_data;
COLLECTION_FORMAT_DEF *format;
unsigned long traceregs[NUMREGBYTES/4];
unsigned char *stack_data;
unsigned char *memrange_data;
} curframe;
/* ------------------- function prototypes -------------------- */
void handle_request ( char * );
/* ------------------- Implementation -------------------- */
static void
discard_packet( void )
{
lan_input_queue.head_index = lan_input_queue.tail_index;
lan_input_queue.gdb_packet_start =
lan_input_queue.gdb_packet_end =
lan_input_queue.gdb_packet_csum1 =
lan_input_queue.gdb_packet_csum2 = -1;
}
/* Utility function: convert an ASCII isxdigit to a hex nybble */
static long
hex( char ch )
{
if ( (ch >= 'A') && (ch <= 'F') )
return ch - 'A' + 10;
if ( (ch >= 'a') && (ch <= 'f') )
return ch - 'a' + 10;
if ( (ch >= '0') && (ch <= '9') )
return ch - '0';
return -1;
}
static void
getpacket( void )
{
unsigned char our_checksum, their_checksum;
char *copy = inbuffer;
unsigned char c;
our_checksum = 0;
/* first find the '$' */
while ((c = lan_next_queue_char ( &lan_input_queue )) != '$')
if (c == 0) /* ??? Protocol error? (paranoia) */
{
/* PROTOCOL ERROR (missing '$') */
/*NACK_PKT( );*/ /*<ETHERNET>*/
return;
}
/* Now copy the message (up to the '#') */
for (c = lan_next_queue_char ( &lan_input_queue ); /* skip the '$' */
c != 0 && c != '#'; /* stop at the '#' */
c = lan_next_queue_char ( &lan_input_queue ))
{
*copy++ = c;
our_checksum += c;
}
*copy++ = '\0'; /* terminate the copy */
if (c == 0) /* ??? Protocol error? (paranoia) */
{
/* PROTOCOL ERROR (missing '#') */
/*NACK_PKT( );*/ /*<ETHERNET>*/
return;
}
their_checksum = hex( lan_next_queue_char ( &lan_input_queue ) ) << 4;
their_checksum += hex( lan_next_queue_char ( &lan_input_queue ) );
/* Now reset the queue packet-recognition bits */
discard_packet( );
if ( remote_debug ||
our_checksum == their_checksum )
{
ACK_PKT( ); /* good packet */
/* Parse and process the packet */
handle_request( inbuffer );
}
else
/* PROTOCOL ERROR (bad check sum) */
NACK_PKT( );
}
/* EMC will provide a better implementation
(perhaps just of LAN_PUT_CHAR) that does not block.
For now, this works. */
static void
putpacket( char *str )
{
unsigned char checksum;
/* '$'<packet>'#'<checksum> */
if ( VIA_ETHERNET == gdb_host_comm )
{
char *p_out;
long length;
p_out = eth_outbuffer;
length = 0;
if ( YES == gdb_cat_ack )
{
*p_out++ = '+';
++length;
}
gdb_cat_ack = NO;
*p_out++ = '$';
++length;
checksum = 0;
while ( *str )
{
*p_out++ = *str;
++length;
checksum += *str++;
}
*p_out++ = '#';
*p_out++ = hexchars[checksum >> 4];
*p_out = hexchars[checksum % 16];
length += 3;
eth_to_gdb( (UCHAR *) eth_outbuffer, length );
}
else
{
/* via RS-232 */
do {
LAN_PUT_CHAR( '$' );
checksum = 0;
while ( *str )
{
LAN_PUT_CHAR( *str );
checksum += *str++;
}
LAN_PUT_CHAR( '#' );
LAN_PUT_CHAR( hexchars[checksum >> 4] );
LAN_PUT_CHAR( hexchars[checksum % 16] );
} while ( 0 /* get_debug_char( ) != '+' */ );
/* XXX FIXME: not waiting for the ack. */
}
}
/*-----------------------------------------------------------------------------
*
* FUNCTION NAME: gdb_get_eth_input
*
*
* DESCRIPTION:
*
*
* RETURN VALUE: None.
*
*
* USED GLOBAL VARIABLES:
*
*
* AFFECTED GLOBAL VARIABLES/SIDE EFFECTS:
*
*
* NOTES:
*
*
*---------------------------------------------------------------------------*/
void gdb_get_eth_input( unsigned char *buf, long length )
{
gdb_host_comm = VIA_ETHERNET;
for ( ; 0 < length; ++buf, --length)
{
if ( *buf == CONTROL_C )
{
/* can't stop the target, but we can tell gdb to stop waiting... */
discard_packet( );
putpacket( "S03" ); /* send back SIGINT to the debugger */
}
else
{
lan_add_to_queue( (long) *buf, &lan_input_queue );
get_gdb_input( (long) *buf, &lan_input_queue );
}
}
return;
}
/* end of 'gdb_get_eth_input'
*===========================================================================*/
/* STDOUT STDOUT STDOUT STDOUT STDOUT STDOUT STDOUT STDOUT STDOUT STDOUT
Stuff pertaining to simulating stdout by sending chars to gdb to be echoed.
Dear reader:
This code is based on the premise that if GDB receives a packet
from the stub that begins with the character CAPITAL-OH, GDB will
echo the rest of the packet to GDB's console / stdout. This gives
the stub a way to send a message directly to the user. In practice,
(as currently implemented), GDB will only accept such a packet when
it believes the target to be running (ie. when you say STEP or
CONTINUE); at other times it does not expect it. This will probably
change as a side effect of the "asynchronous" behavior.
Functions: gdb_putchar(char ch)
gdb_write(char *str, int len)
gdb_puts(char *str)
gdb_error(char *format, char *parm)
*/
#if 0 /* avoid compiler warning while this is not used */
/* Function: gdb_putchar(int)
Make gdb write a char to stdout.
Returns: the char */
static int
gdb_putchar( long ch )
{
char buf[4];
buf[0] = 'O';
buf[1] = hexchars[ch >> 4];
buf[2] = hexchars[ch & 0x0F];
buf[3] = 0;
putpacket( buf );
return ch;
}
#endif
/* Function: gdb_write(char *, int)
Make gdb write n bytes to stdout (not assumed to be null-terminated).
Returns: number of bytes written */
static int
gdb_write( char *data, long len )
{
char *buf, *cpy;
long i;
buf = outbuffer;
buf[0] = 'O';
i = 0;
while ( i < len )
{
for ( cpy = buf+1;
i < len && cpy < buf + BUFMAX - 3;
i++ )
{
*cpy++ = hexchars[data[i] >> 4];
*cpy++ = hexchars[data[i] & 0x0F];
}
*cpy = 0;
putpacket( buf );
}
return len;
}
/* Function: gdb_puts(char *)
Make gdb write a null-terminated string to stdout.
Returns: the length of the string */
static int
gdb_puts( char *str )
{
return gdb_write( str, strlen( str ) );
}
/* Function: gdb_error(char *, char *)
Send an error message to gdb's stdout.
First string may have 1 (one) optional "%s" in it, which
will cause the optional second string to be inserted. */
#if 0
static void
gdb_error( char *format, char *parm )
{
static char buf[400];
char *cpy;
long len;
if ( remote_debug )
{
if ( format && *format )
len = strlen( format );
else
return; /* empty input */
if ( parm && *parm )
len += strlen( parm );
for ( cpy = buf; *format; )
{
if ( format[0] == '%' && format[1] == 's' ) /* include 2nd string */
{
format += 2; /* advance two chars instead of just one */
while ( parm && *parm )
*cpy++ = *parm++;
}
else
*cpy++ = *format++;
}
*cpy = '\0';
gdb_puts( buf );
}
}
#endif
static void gdb_note (char *, int);
static int error_ret (int, char *, int);
static unsigned long
elinum_to_index (unsigned long elinum)
{
if ((elinum & 0xf0) == 0xd0)
return (elinum & 0x0f);
else if ((elinum & 0xf0) == 0xa0)
return (elinum & 0x0f) + 8;
else
return -1;
}
static long
index_to_elinum (unsigned long index)
{
if (index <= 7)
return index + 0xd0;
else if (index <= 15)
return (index - 8) + 0xa0;
else
return -1;
}
/*
READMEM READMEM READMEM READMEM READMEM READMEM READMEM READMEM READMEM
The following code pertains to reading memory from the target.
Some sort of exception handling should be added to make it safe.
READMEM READMEM READMEM READMEM READMEM READMEM READMEM READMEM READMEM
Safe Memory Access:
All reads and writes into the application's memory will pass thru
get_uchar() or set_uchar(), which check whether accessing their
argument is legal before actual access (thus avoiding a bus error).
*/
enum { SUCCESS = 0, FAIL = -1 };
#if 0
static long get_uchar ( const unsigned char * );
#endif
static long set_uchar ( unsigned char *, unsigned char );
static long read_access_violation ( const void * );
static long write_access_violation ( const void * );
static long read_access_range(const void *, long);
static DTC_RESPONSE find_memory(unsigned char *,long,unsigned char **,long *);
static int
dtc_error_ret (int ret, char *src, DTC_RESPONSE code)
{
if (src)
sprintp (spare_buffer,
"'%s' returned DTC error '%s'.\n", src, get_err_text (code));
else
sprintp (spare_buffer, "DTC error '%s'.\n", get_err_text (code));
gdb_puts (spare_buffer);
return ret;
}
#if 0
/* I think this function is unnecessary since the introduction of
adbg_find_memory_addr_in_frame. */
/* Return the number of expressions in the format associated with a
given trace frame. */
static int
count_frame_exprs (FRAME_DEF *frame)
{
CFD *format;
T_EXPR *expr;
int num_exprs;
/* Get the format from the frame. */
get_frame_format_pointer (frame, &format);
/* Walk the linked list of expressions, and count the number of
expressions we find there. */
num_exprs = 0;
for (expr = format->p_cfd_expr; expr; expr = expr->next)
num_exprs++;
return num_exprs;
}
#endif
#if 0
/* Function: get_frame_addr
*
* Description: If the input memory address was collected in the
* current trace frame, then lookup and return the address
* from within the trace buffer from which the collected byte
* may be retrieved. Else return -1. */
unsigned char *
get_frame_addr ( const unsigned char *addr )
{
unsigned char *base, *regs, *stack, *mem;
CFD *dummy;
DTC_RESPONSE ret;
/* first, see if addr is on the saved piece of stack for curframe */
if (curframe.format->stack_size > 0 &&
(base = (unsigned char *) curframe.traceregs[A7]) <= addr &&
addr < base + curframe.format->stack_size)
{
gdb_puts("STUB: get_frame_addr: call get_addr_to_frame_regs_stack_mem\n");
if ((ret = get_addr_to_frame_regs_stack_mem (curframe.frame_data,
&dummy,
(void *) &regs,
(void *) &stack,
(void *) &mem))
!= OK_TARGET_RESPONSE)
return (void *) dtc_error_ret (-1,
"get_addr_to_frame_regs_stack_mem",
ret);
else
return stack + (addr - base);
}
/* Next, try to find addr in the current frame's expression-
collected memory blocks. I'm sure this is at least quadradic in
time. */
{
int num_exprs = count_frame_exprs (curframe.frame_data);
int expr, block;
/* Try each expression in turn. */
for (expr = 0; expr < num_exprs; expr++)
{
for (block = 0; ; block++)
{
T_EXPR_DATA *data;
if (adbg_get_expr_data (curframe.frame_data,
'x', expr, block,
&data)
!= OK_TARGET_RESPONSE)
break;
else if ((unsigned char *) data->address <= addr
&& addr < ((unsigned char *) data->address + data->size))
{
/* We have found the right block; is it valid data?
Upper-case stamps mean bad data. */
if ('A' <= data->stamp && data->stamp <= 'Z')
{
gdb_puts("STUB: get_frame_addr: adbg_get_expr_data INVALID\n");
return (unsigned char *) -1;
}
else
{
if (remote_debug > 1)
{
sprintp(spare_buffer,
"STUB: get_frame_addr: got it [%x,%x)\n",
data->address, data->address + data->size);
gdb_puts(spare_buffer);
}
return (((unsigned char *) &data->data)
+ (addr - (unsigned char *) data->address));
}
}
}
}
}
/* not found, return error */
return (unsigned char *) -1;
}
/*============================================================*/
static long get_uchar ( const unsigned char * addr )
{
unsigned char *frame_addr;
if ( read_access_violation ( addr ) )
return ( -1 ); /* Access error */
if (curframe.valid) /* if debugging a trace frame? */
{
/* If the requested address was collected in the current frame,
* then fetch and return the data from the trace buffer.
*/
if ((frame_addr = get_frame_addr (addr)) != (unsigned char *) -1)
return ( *frame_addr );
/* If the requested address is in the Code Section,
* let's be magnanimous and read it anyway (else we shall
* not be able to disassemble, find function prologues, etc.)
*/
else if (CS_CODE_START <= (unsigned long) addr &&
(unsigned long) addr < CS_CODE_START + CS_CODE_SIZE)
return (*addr);
else
return ( -1 ); /* "Access error" (the data was not collected) */
}
else
/* Not debugging a trace frame, read the data from live memory. */
return ( *addr ); /* Meaningful result >= 0 */
}
#endif
/*============================================================*/
static long set_uchar ( unsigned char * addr, unsigned char val )
{
long check_result = write_access_violation ( addr );
if ( check_result != 0L )
return ( check_result ); /* Access error */
return ( *addr = val ); /* Successful writing */
}
/*============================================================*/
/*
* Function read_access_violation() below returns TRUE if dereferencing
* its argument for reading would cause a bus error - and FALSE otherwise:
*/
static long read_access_violation ( const void * addr )
{
return ( ( ( addr < SRAM_START ) || ( addr >= SRAM_END ) ) &&
( ( addr < NVD_START ) || ( addr >= NVD_END ) ) );
}
/*============================================================*/
/*
* Function write_access_violation() below returns zero if dereferencing
* its argument for writing is safe, -1 on a soft error (the argument
* falls into the write-protected area), -2 on a hard error (the argument
* points to a non-existent memory location). In other words, it returns
* FALSE when no bus error is expected - and an error code otherwise:
*/
static long write_access_violation ( const void * addr )
{
/*
* The boundaries of the write-protected area have to be received via
* an API provided in the Symmetrix core code. For now, these limits
* are hard-coded:
*/
if ( ( addr >= RO_AREA_START ) && ( addr < RO_AREA_END ) )
return ( -1 ); /* soft error */
if ( ( ( addr < SRAM_START ) || ( addr >= SRAM_END ) ) &&
( ( addr < NVD_START ) || ( addr >= NVD_END ) ) )
return ( -2 ); /* hard error */
return ( 0 );
}
/* read_access_range is like read_access_violation,
but returns the number of bytes we can read w/o faulting.
that is, it checks an address range and tells us what portion
(if any) of the prefix is safe to read without a bus error */
static long
read_access_range(const void *addr, long count)
{
if ((addr >= SRAM_START) && (addr < SRAM_END))
{
if ((char *)addr + count < (char *)SRAM_END)
return (count);
else
return ((char *)SRAM_END - (char *)addr);
}
else if (((char *)addr >= (char *)NVD_START) &&
((char *)addr < (char *)NVD_END))
{
if ((char *)addr + count < (char *)NVD_END)
return (count);
else
return ((char *)NVD_END - (char *)addr);
}
else
return (0);
}
/* Convert the memory pointed to by mem into hex, placing result in buf.
Return SUCCESS or FAIL.
If MAY_FAULT is non-zero, then we should return FAIL in response to
a fault; if zero treat a fault like any other fault in the stub. */
static long
mem2hex(unsigned char *mem, char *buf, long count, long may_fault)
{
long ndx;
long ndx2;
long ch;
long incr;
unsigned char *location;
DTC_RESPONSE status;
if (may_fault)
{
for (ndx = 0, incr = 1; (ndx < count) && (incr > 0); ndx += incr)
{
status = find_memory(mem, count - ndx, &location, &incr);
if (status == OK_TARGET_RESPONSE)
{
if (incr > 0)
{
for (ndx2 = 0; ndx2 < incr; ndx2++)
{
ch = *location++;
*buf++ = hexchars[ch >> 4];
*buf++ = hexchars[ch & 0xf];
}
mem += incr;
}
else if (incr <= 0) /* should never happen */
{
*buf = 0;
return (0);
}
}
else if (status == NOT_FOUND_TARGET_RESPONSE)
{
*buf = 0;
return (ndx); /* return amount copied */
}
else
{
*buf = 0;
return (0); /* XXX: how do we tell the user the status? */
}
}
*buf = 0;
return (count);
}
else
{
for (ndx = 0; ndx < count; ndx++)
{
ch = *mem++;
*buf++ = hexchars[ch >> 4];
*buf++ = hexchars[ch & 0xf];
}
*buf = 0;
return (count); /* we copied everything */
}
}
static DTC_RESPONSE
find_memory(unsigned char *mem, long count,
unsigned char **location, long *incr)
{
DTC_RESPONSE retval;
long length;
/* figure out how much of the memory range we can read w/o faulting */
count = read_access_range(mem, count);
if (count == 0)
return (NOT_FOUND_TARGET_RESPONSE);
if (curframe.valid)
{
unsigned char *mem_block;
unsigned char *mem_addr;
unsigned long mem_size;
unsigned long mem_stamp;
retval = adbg_find_memory_addr_in_frame(curframe.frame_data, mem,
(unsigned long **)&mem_block,
(unsigned long **)&mem_addr,
&mem_size, &mem_stamp);
switch (retval)
{
case OK_TARGET_RESPONSE:
#if 0
printp("FOUND: mem %x block %x addr %x size %d stamp %x\n",
mem, mem_block, mem_addr, mem_size, mem_stamp);
#endif
*location = mem_block + (mem - mem_addr);
length = mem_size - (mem - mem_addr);
if (length < count)
*incr = length;
else
*incr = count;
break;
case NOT_FOUND_TARGET_RESPONSE:
case NEAR_FOUND_TARGET_RESPONSE:
#if 0
printp("NOT FOUND: mem %x, checking code region\n", mem);
#endif
/* check to see if it's in the code region */
if ((CS_CODE_START <= (long)mem) &&
((long)mem < CS_CODE_START + CS_CODE_SIZE))
{
/* some or all of the address range is in the code */
*location = mem;
if ((long)mem + count <= CS_CODE_START + CS_CODE_SIZE)
*incr = count; /* it's totally in the code */
else
/* how much is in the code? */
*incr = CS_CODE_START + CS_CODE_SIZE - (long)mem;
#if 0
printp("FOUND in code region: %x\n", mem);
#endif
retval = OK_TARGET_RESPONSE;
}
else
retval = NOT_FOUND_TARGET_RESPONSE;
break;
default:
#if 0
printp("BAD RETURN: %d\n", retval);
#endif
retval = NOT_FOUND_TARGET_RESPONSE;
break;
}
}
else
{
*location = mem;
*incr = count;
retval = OK_TARGET_RESPONSE;
}
return (retval);
}
/* Convert the hex array pointed to by buf into binary to be placed in mem.
Return SUCCESS or FAIL. */
static long
hex2mem( char *buf, unsigned char *mem, long count, long may_fault )
{
long i, ch;
for ( i=0; i<count; i++ )
{
ch = hex( *buf++ ) << 4;
ch = ch + hex( *buf++ );
if ( may_fault )
{
ch = set_uchar( mem++, ch );
if ( ch < 0 ) /* negative return indicates error */
return FAIL;
}
else
*mem++ = ch;
}
return SUCCESS;
}
/**********************************************/
/* WHILE WE FIND NICE HEX CHARS, BUILD AN INT */
/* RETURN NUMBER OF CHARS PROCESSED */
/**********************************************/
static int
hexToInt( char **ptr, unsigned long *intValue )
{
long numChars = 0;
long hexValue;
*intValue = 0;
while ( **ptr )
{
hexValue = hex( **ptr );
if ( hexValue >=0 )
{
*intValue = (*intValue << 4) | hexValue;
numChars ++;
}
else
break;
(*ptr)++;
}
return numChars;
}
static volatile long gdb_handling_trap1;
static volatile long gdb_handling_sstrace;
static volatile long gdb_signo;
/*
Here is the "callable" stub entry point.
Call this function with a GDB request as an argument,
and it will service the request and return.
May be further broken up as we go along, with individual requests
broken out as separate functions.
*/
static char * handle_trace_query (char *);
static char * handle_trace_set (char *);
static int handle_format (char **request, CFD *format);
static unsigned long crc32 (unsigned char *buf, int len, unsigned long crc);
static char * crc_query (char *);
static char * handle_test (char *);
void
handle_request( char *request )
{
#if 0
remote_debug = 2;
#endif
switch( *request++ )
{
case 'k': /* "kill" */
curframe.valid = FALSE;
putpacket ("");
break;
case 'D': /* "detach" */
curframe.valid = FALSE;
putpacket ("");
break;
default: /* Unknown code. Return an empty reply message. */
putpacket( "" ); /* return empty packet */
break;
case 'H': /* Set thread for subsequent operations.
Hct... c = 'c' for thread used in step and continue;
t... can be -1 for all threads.
c = 'g' for thread used in other operations.
If zero, pick a thread, any thread. */
putpacket( "OK" );
break;
case 'g': /* Read registers.
Each byte of register data is described by
two hex digits. registers are in the
internal order for GDB, and the bytes in a
register are in the same order the machine
uses. */
{
/* Return the values in (one of) the registers cache(s).
Several situations may pertain:
1) We're synchronous, in which case the "registers" array
should actually be current.
2) We're asynchronous, in which case the "registers" array
holds whatever was cached most recently.
3) We're looking at a trace frame that was collected earlier:
we will return those earlier registers.
*/
/* all registers default to zero */
memset (outbuffer, '0', NUMREGBYTES);
outbuffer[NUMREGBYTES] = '\0';
if (curframe.valid) /* debugging a trace frame */
mem2hex( (unsigned char*) curframe.traceregs,
outbuffer, NUMREGBYTES, 0 );
else
mem2hex( (unsigned char*) registers, outbuffer, NUMREGBYTES, 0 );
putpacket( outbuffer );
}
break;
case 'G': /* Write registers.
Gxxxxxxxx Each byte of register data is described by
two hex digits. */
if (curframe.valid) /* debugging a trace frame */
putpacket ("E03"); /* can't write regs into a trace frame! */
else
{
/* Write the values into the local registers cache...
Note that no actual registers are being changed. */
hex2mem( request,
(unsigned char *) registers, NUMREGBYTES, 0 );
putpacket( "OK" );
}
break;
case 'P': /* Write (single) register.
Pnn=xxxxxxxx register nn gets value xxxxxxxx;
two hex digits for each byte in the register
(target byte order). */
if (curframe.valid)
putpacket ("E03"); /* can't write regs into a trace frame! */
else
{
unsigned long regno;
if ( hexToInt( &request, &regno ) && *(request++) == '=' )
{
if ( regno < NUMREGS )
{
hexToInt( &request,
(unsigned long *) &registers[REGISTER_BYTE(regno)]);
putpacket( "OK" );
}
else
putpacket( "E01" ); /* bad packet or regno */
}
}
break;
case 'm': /* Read memory.
mAAAAAAAA,LLLL AAAAAAAA is address, LLLL is length.
Reply can be fewer bytes than requested
if able to read only part of the data. */
{
unsigned long addr, len;
if ( hexToInt( &request, &addr ) &&
*(request++) == ',' &&
hexToInt( &request, &len ) )
{
/* better not overwrite outbuffer! */
if ( len > (BUFMAX / 2) - 5 )
len = (BUFMAX / 2) - 5;
if (mem2hex((unsigned char *) addr, outbuffer, len, 1) == 0) /* XXX: eventually use returned value */
putpacket( "E03" ); /* read fault (access denied) */
else
putpacket( outbuffer ); /* read succeeded */
}
else
putpacket( "E01" ); /* badly formed read request */
}
break;
case 'M': /* Write memory.
Maaaaaaaa,llll:xxxx aaaaaaaa is address, llll is length;
xxxx is data to write. */
{
unsigned long addr, len;
if (curframe.valid) /* can't write memory into a trace frame! */
putpacket ("E03"); /* "access denied" */
else /*** if ( write_access_enabled ) ***/
{
if ( hexToInt( &request, &addr ) &&
*(request++) == ',' &&
hexToInt( &request, &len ) &&
*(request++) == ':' )
{
if (len == 2 &&
addr >= CS_CODE_START &&
addr <= LAST_CS_WORD)
{
unsigned long val;
if ( !hexToInt( &request, &val ) ||
write_to_protected_mem( (void *)addr, val ) )
putpacket( "E03" ); /* write fault (access denied) */
else
putpacket( "OK" ); /* write succeeded */
}
else
{
if ( hex2mem( request, (unsigned char*) addr, len, 1 ) )
putpacket( "E03" ); /* write fault (access denied) */
else
putpacket( "OK" ); /* write succeeded */
}
}
else
putpacket( "E02" ); /* badly formed write request */
}
}
break;
case 'c': /* Continue.
cAAAAAAAA AAAAAAAA is address from which to resume.
If omitted, resume at current PC. */
{
unsigned long addr;
if (curframe.valid)
{
/* Don't continue if debugging a trace frame! */
gdb_puts ("Error: can't continue!\n");
putpacket ("S03");
}
else
{
gdb_signo = 3;
if (isxdigit(request[0]))
{
hexToInt(&request, &addr);
registers[REGISTER_BYTE(PC)] = addr;
}
gdb_handling_trap1 = FALSE;
gdb_handling_sstrace = FALSE;
sss_trace_flag = '\0';
}
}
break;
case 's': /* Step.
sAAAAAAAA AAAAAAAA is address from which to begin stepping.
If omitted, begin stepping at current PC. */
{
unsigned long addr;
if (curframe.valid)
{
/* Don't step if debugging a trace frame! */
gdb_puts ("Error: can't step!\n");
putpacket ("S03");
}
else
{
gdb_signo = 3;
if (isxdigit(request[0]))
{
hexToInt(&request, &addr);
registers[REGISTER_BYTE(PC)] = addr;
}
gdb_handling_trap1 = FALSE;
gdb_handling_sstrace = FALSE;
sss_trace_flag = 't';
}
}
break;
case 'C': /* Continue with signal.
Cxx;AAAAAAAA xx is signal number in hex;
AAAAAAAA is adddress from which to resume.
If ;AAAAAAAA omitted, continue from PC. */
{
unsigned long addr = 0;
if (!gdb_handling_trap1 || curframe.valid)
{
/* Don't continue if not currently in synchronous mode,
or if currently debugging a trace frame! */
gdb_puts( "Error: can't continue!\n" );
putpacket( "S03" ); /* "sigquit" (better idea?) */
}
else
{
gdb_signo = 3;
if ( isxdigit( *request ) )
{
hex2mem( request, (unsigned char *) &gdb_signo, 2, 0 );
request += 2;
if ( *request == ';' && isxdigit( *++request ) )
{
hexToInt( &request, &addr );
registers[REGISTER_BYTE(PC)] = addr;
}
}
gdb_handling_trap1 = FALSE;
gdb_handling_sstrace = FALSE;
sss_trace_flag = '\0';
}
}
break;
case 'S': /* Step with signal.
Sxx;AAAAAAAA xx is signal number in hex;
AAAAAAAA is adddress from which to begin stepping.
If ;AAAAAAAA omitted, begin stepping from PC. */
{
unsigned long addr = 0;
if (!gdb_handling_trap1 || curframe.valid)
{
/* Don't step if not currently in synchronous mode,
or if currently debugging a trace frame! */
gdb_puts( "Error: can't step!\n" );
putpacket( "S03" ); /* "sigquit" (better idea?) */
}
else
{
gdb_signo = 3;
if ( isxdigit( *request ) )
{
hex2mem( request, (unsigned char *) &gdb_signo, 2, 0 );
request += 2;
if ( *request == ';' && isxdigit( *++request ) )
{
hexToInt( &request, &addr );
registers[REGISTER_BYTE(PC)] = addr;
}
}
gdb_handling_trap1 = FALSE;
gdb_handling_sstrace = FALSE;
sss_trace_flag = 't';
}
}
break;
case '?': /* Query the latest reason for stopping.
Should be same reply as was last generated
for step or continue. */
if ( gdb_signo == 0 )
gdb_signo = 3; /* default to SIGQUIT */
outbuffer[ 0 ] = 'S';
outbuffer[ 1 ] = hexchars[ gdb_signo >> 4 ];
outbuffer[ 2 ] = hexchars[ gdb_signo & 0xf ];
outbuffer[ 3 ] = 0;
putpacket( outbuffer );
break;
case 'd': /* Toggle debug mode
I'm sure we can think of something interesting. */
remote_debug = !remote_debug;
putpacket( "" ); /* return empty packet */
break;
case 'q': /* general query */
switch (*request++)
{
default:
putpacket (""); /* nak a request which we don't handle */
break;
case 'T': /* trace query */
putpacket (handle_trace_query (request));
break;
case 'C': /* crc query (?) */
if (*request++ == 'R' &&
*request++ == 'C' &&
*request++ == ':')
putpacket (crc_query (request));
else
putpacket (""); /* unknown query */
break;
}
break;
case 'Q': /* general set */
switch (*request++)
{
default:
putpacket (""); /* nak a request which we don't handle */
break;
case 'T': /* trace */
putpacket (handle_trace_set (request));
break;
}
break;
case 'T':
/* call test function: TAAA,BBB,CCC
A, B, and C are arguments to pass to gdb_c_test. Reply is
"E01" (bad arguments) or "OK" (test function called). */
putpacket (handle_test (request));
break;
}
}
static TDP_SETUP_INFO tdp_temp;
static int trace_running;
/*
* Function msgcmp:
*
* If second argument (str) is matched in first argument,
* then advance first argument past end of str and return "SAME"
* else return "DIFFERENT" without changing first argument.
*
* Return: zero for DIFFERENT, non-zero for SUCCESS
*/
static int
msgcmp (char **msgp, char *str)
{
char *next;
if (msgp != 0 && str != 0) /* input validation */
if ((next = *msgp) != 0)
{
for (;
*next && *str && *next == *str;
next++, str++)
;
if (*str == 0) /* matched all of str in msg */
return (int) (*msgp = next); /* advance msg ptr past str */
}
return 0; /* failure */
}
static char *
handle_trace_query (char *request)
{
if (msgcmp (&request, "Status"))
{
if (adbg_check_if_active ())
{
gdb_puts ("Target trace is running.\n");
return "T1";
}
else
{
gdb_puts ("Target trace not running.\n");
trace_running = 0;
return "T0";
}
}
else /* unknown trace query */
{
return "";
}
}
static void
gdb_note (char *fmt, int arg1)
{
if (remote_debug > 1)
{
sprintp (spare_buffer, fmt, arg1);
gdb_puts (spare_buffer);
}
}
static int
error_ret (int ret, char *fmt, int arg1)
{
if (remote_debug > 0)
{
sprintp (spare_buffer, fmt, arg1);
gdb_puts (spare_buffer);
}
return ret;
}
static int
handle_format (char **request, COLLECTION_FORMAT_DEF *format)
{
MEMRANGE_DEF m;
DTC_RESPONSE ret;
int elinum;
unsigned long regnum;
long bytecodes[(MAX_BYTE_CODES + sizeof (struct t_expr_tag))/ 4];
struct t_expr_tag *t_expr = (struct t_expr_tag *)bytecodes;
if (format->id == 0)
{
if ((ret = get_unused_format_id (&format->id)) != OK_TARGET_RESPONSE)
return dtc_error_ret (-1, "get_unused_format_id", ret);
if (**request == 'R')
{
(*request)++;
hexToInt (request, &format->regs_mask);
}
gdb_note ("STUB: call define_format (id = %d, ", format->id);
gdb_note ("regs_mask = 0x%X);\n", format->regs_mask);
if ((ret = define_format (format)) != OK_TARGET_RESPONSE)
{
sprintp (spare_buffer,
"'define_format': DTC error '%s' for format id %d.\n",
get_err_text (ret),
format->id);
gdb_puts (spare_buffer);
return -1;
}
}
while ((**request == 'M') || (**request == 'X'))
{
switch (**request)
{
case 'M': /* M<regnum>,<offset>,<size> */
(*request)++;
hexToInt(request, &regnum);
if (regnum == 0 || regnum == (unsigned long) -1)
m.typecode = -1;
else if ((elinum = index_to_elinum (regnum)) > 0)
m.typecode = elinum;
else
return error_ret (-1,
"Memrange register %d is not between 0 and 15\n",
regnum);
if (*(*request)++ != ',')
return error_ret (-1,"Malformed memrange (comma #%d missing)\n",1);
hexToInt(request, &m.offset);
if (*(*request)++ != ',')
return error_ret (-1,"Malformed memrange (comma #%d missing)\n",2);
hexToInt(request, &m.size);
gdb_note ("STUB: call add_format_mem_range (typecode = 0x%x, ",
m.typecode);
gdb_note ("offset = 0x%X, ", m.offset);
gdb_note ("size = %d);\n", m.size);
if ((ret = add_format_mem_ranges (format->id, &m)) !=
OK_TARGET_RESPONSE)
{
dtc_error_ret (-1, "add_format_mem_ranges", ret);
sprintp (spare_buffer,
"format id %d: memrange (0x%x, 0x%x, 0x%x).\n",
format->id, m.typecode, m.offset, m.size);
gdb_puts (spare_buffer);
return -1;
}
break;
case 'X': /* X<length>,<bytecodes> */
{
unsigned long length;
(*request)++;
hexToInt(request, &length);
if ((length <= 0) || (length > MAX_BYTE_CODES))
return error_ret (-1,
"Bytecode expression length (%d) too large\n",
length);
if (*(*request)++ != ',')
return error_ret (-1,
"Malformed bytecode expr (comma#%d missing)\n",
1);
t_expr->next = NULL;
/* subtract one to account for expr[0] in header */
t_expr->size = sizeof(struct t_expr_tag) + length - 1;
t_expr->expr_size = length;
hex2mem(*request, &t_expr->expr[0], length, 0);
*request += 2 * length;
build_and_add_expression(format->id, t_expr);
}
break;
}
}
return 0;
}
static char *
handle_trace_set (char *request)
{
long n_frame;
unsigned long frameno, tdp, pc, start, stop;
DTC_RESPONSE ret = -1;
static COLLECTION_FORMAT_DEF tempfmt1;
static char enable;
static char retbuf[20];
if (msgcmp (&request, "init"))
{
gdb_note ("STUB: call clear_trace_state();\n", 0);
curframe.valid = 0; /* all old frames become invalid now */
if ((ret = clear_trace_state ()) == OK_TARGET_RESPONSE)
return "OK";
else
{
sprintp (retbuf, "E2%x", ret);
return (char *) dtc_error_ret ((int) &retbuf,
"clear_trace_state",
ret);
}
}
else if (msgcmp (&request, "Start"))
{
trace_running = 1;
curframe.valid = 0; /* all old frames become invalid now */
gdb_note ("STUB: call start_trace_experiment();\n", 0);
adbg_save_trace_in_nvd ();
if ((ret = start_trace_experiment ()) == OK_TARGET_RESPONSE)
return "OK";
else
{
sprintp (retbuf, "E2%x", ret);
return (char *) dtc_error_ret ((int) &retbuf,
"start_trace_experiment",
ret);
}
}
else if (msgcmp (&request, "Stop"))
{
trace_running = 0;
if (adbg_check_if_active ())
{
gdb_note ("STUB: call end_trace_experiment();\n", 0);
if ((ret = end_trace_experiment ()) == OK_TARGET_RESPONSE)
return "OK";
else
{
sprintp (retbuf, "E2%x", ret);
return (char *) dtc_error_ret ((int) &retbuf,
"end_trace_experiment",
ret);
}
}
else return "OK";
}
/* "TDP:" (The 'T' was consumed in handle_request.) */
else if (msgcmp (&request, "DP:"))
{
/* TDP:<id>:<addr>:{D,E}:<stepcount>:<pass_limit>{R[M,X]+}<tdp-format>
{S{R[M,X]+}}<tp-format>
D -- disable tracepoint (illegal from EMC's point of view)
E -- enable tracepoint?
R -- regs format: R<regs-mask>
M -- memory format: M<regnum>,<offset>,<size>
X -- expr format: X<size>,<bytecodes>
S -- fencepost between trap formats and stepping formats.
*/
/* state variable, required for splitting TDP packets. */
static int doing_step_formats;
/*
* TDP: packets may now be split into multiple packets.
* If a TDP packet is to be continued in another packet, it
* must end in a "-" character. The subsequent continuation
* packet will then begin with a "-" character, between the
* token "TDP:" and the tdp_id field. The ID and address
* will be repeated in each sub-packet. The step_count,
* pass_count, and 'enabled' field must appear in the first
* packet. The boundary between sub-packets may not appear
* between the "S" that denotes the start of stepping "formats",
* and the regs_mask that follows it. The split may also not
* occur in the middle of either a memrange description or a
* bytecode string. -- MVS
*/
if (*request == '-') /* this is a continuation of a
trace definition in progress */
{
unsigned long temp_id, temp_addr;
request++;
if (!(hexToInt (&request, &temp_id) &&
*request++ == ':'))
return "E11"; /* badly formed packet, field 1 */
if (!(hexToInt (&request, (unsigned long *) &temp_addr) &&
*request++ == ':'))
return "E12"; /* badly formed packet, field 2 */
if (temp_id != tdp_temp.id)
return "E11"; /* something wrong: field 1 doesn't match */
if (temp_addr != (unsigned long) tdp_temp.addr)
return "E12"; /* something wrong: field 2 doesn't match */
}
else /* This is a new TDP definition */
{
memset ((char *) &tdp_temp, 0, sizeof (tdp_temp));
memset ((char *) &tempfmt1, 0, sizeof (tempfmt1));
doing_step_formats = FALSE;
if (!(hexToInt (&request, &tdp_temp.id) &&
*request++ == ':'))
return "E11"; /* badly formed packet, field 1 */
if (!(hexToInt (&request, (unsigned long *) &tdp_temp.addr) &&
*request++ == ':'))
return "E12"; /* badly formed packet, field 2 */
if (!(((enable = *request++) == 'D' || enable == 'E') &&
*request++ == ':'))
return "E13"; /* badly formed packet, field 3 */
#if 0
if (enable == 'D')
{
gdb_puts ("Disabling of tracepoints not supported by EMC target\n");
return "E20";
}
#endif
if (!(hexToInt (&request, &tdp_temp.stepcount) &&
*request++ == ':'))
return "E14"; /* badly formed packet, field 4 */
if (!hexToInt (&request, &tdp_temp.pass_limit))
return "E15"; /* badly formed packet, field 5 */
}
/* Typically, the first group of collection descriptors
refers to the trap collection. There is an "S" token
to act as a fencepost between collection descriptors for
the trap, and those for the single-stepping.
However, when the packet is split up into several packets,
this "S" token may already have been seen in a previous
sub-packet; so we have to remember it in a state variable. */
if (*request == 'R' || *request == 'M' || *request == 'X')
{
if (handle_format (&request, &tempfmt1))
return "E16";
if (doing_step_formats)
tdp_temp.tp_format_p = tempfmt1.id;
else
tdp_temp.tdp_format_p = tempfmt1.id;
}
/* When we see the "S" token, we remember it in a state variable
(in case the packet is split up and continued in another message),
and discard all current state from the collection "format". */
if (*request == 'S')
{
doing_step_formats = TRUE;
/* discard prev format and start a new one */
memset ((char *) &tempfmt1, 0, sizeof (tempfmt1));
request++;
/* Having seen the "S" fencepost, it is now possible that
we will see some more collection descriptors pertaining
to the stepping collection. */
if (*request == 'R' || *request == 'M' || *request == 'X')
{
if (handle_format (&request, &tempfmt1))
return "E17";
/* new format ID is tp_format */
tdp_temp.tp_format_p = tempfmt1.id;
}
}
if (*request == '-') /* this TDP definition will be continued. */
sprintp (retbuf, "OK");
else if (enable == 'E') /* end of TDP definition: pass to ADBG (if enabled!) */
{
gdb_note ("STUB: call define_tdp (id %d, ", tdp_temp.id);
gdb_note ("addr 0x%X, ", (int) tdp_temp.addr);
gdb_note ("passc %d, ", tdp_temp.pass_limit);
gdb_note ("stepc %d, ", tdp_temp.stepcount);
gdb_note ("TDP fmt #%d, ", tdp_temp.tdp_format_p);
gdb_note ("TP fmt #%d);\n", tdp_temp.tp_format_p);
ret = define_tdp (tdp_temp.id, &tdp_temp, 0);
if (ret == OK_TARGET_RESPONSE)
{
sprintp (retbuf, "OK");
}
else
{
sprintp (spare_buffer,
"'define_tdp' returned DTC error '%s' for tracepoint %d.\n",
get_err_text (ret),
tdp_temp.id);
gdb_puts (spare_buffer);
sprintp (retbuf, "E2%x", ret);
}
/* Redundant, but let's try to make sure this state gets discarded. */
{
memset ((char *) &tdp_temp, 0, sizeof (tdp_temp));
memset ((char *) &tempfmt1, 0, sizeof (tempfmt1));
}
}
else /* ADBG_DTC does not support disabled tracepoints -- ignore it. */
gdb_note ("STUB: ignoring disabled tracepoint %d.\n", tdp_temp.id);
return retbuf;
}
else if (msgcmp (&request, "Frame:"))
{
ret = OK_TARGET_RESPONSE;
if (msgcmp (&request, "pc:"))
{
if (!hexToInt (&request, &pc))
return "E10"; /* badly formed packet */
n_frame = curframe.valid ? curframe.frame_id + 1 : 0;
gdb_note ("STUB: call fetch_trace_frame_pc (id %d, ", n_frame);
gdb_note ("pc 0x%X);\n", pc);
ret = fetch_trace_frame_with_pc (&n_frame,
(void *) pc,
&curframe.format,
&curframe.frame_data);
}
else if (msgcmp (&request, "tdp:"))
{
if (!hexToInt (&request, &tdp))
return "E10"; /* badly formed packet */
n_frame = curframe.valid ? curframe.frame_id + 1: 0;
gdb_note ("STUB: call fetch_trace_frame_tdp (id %d, ", n_frame);
gdb_note ("tdp 0x%X);\n", tdp);
ret = fetch_trace_frame_with_tdp (&n_frame,
tdp,
&curframe.format,
&curframe.frame_data);
}
else if (msgcmp (&request, "range:"))
{
if (!(hexToInt (&request, &start) &&
*request++ == ':'))
return "E11"; /* badly formed packet, field 1 */
else if (!hexToInt (&request, &stop))
return "E12"; /* badly formed packet, field 2 */
n_frame = curframe.valid ? curframe.frame_id + 1: 0;
gdb_note ("STUB: call fetch_trace_frame_range (id %d, ", n_frame);
gdb_note ("start 0x%X, ", start);
gdb_note ("stop 0x%X);\n", stop);
ret = fetch_trace_frame_with_pc_in_range (&n_frame,
(void *) start,
(void *) stop,
&curframe.format,
&curframe.frame_data);
}
else if (msgcmp (&request, "outside:"))
{
if (!(hexToInt (&request, &start) &&
*request++ == ':'))
return "E11"; /* badly formed packet, field 1 */
else if (!hexToInt (&request, &stop))
return "E12"; /* badly formed packet, field 2 */
n_frame = curframe.valid ? curframe.frame_id + 1: 0;
gdb_note ("STUB: call fetch_trace_frame_outside (id %d, ", n_frame);
gdb_note ("start 0x%X, ", start);
gdb_note ("stop 0x%X);\n", stop);
ret = fetch_trace_frame_with_pc_outside (&n_frame,
(void *) start,
(void *) stop,
&curframe.format,
&curframe.frame_data);
}
else /* simple TFind by frame number: */
{
if (!hexToInt (&request, &frameno))
return "E10"; /* badly formed packet */
if (frameno != (unsigned long) -1)
{
gdb_note ("STUB: call fetch_trace_frame (id %d);\n", frameno);
ret = fetch_trace_frame (n_frame = frameno,
&curframe.format,
&curframe.frame_data);
#if 0
printp("STUB: fetch_trace_frame: return %d\n", ret);
#endif
}
else /* discard any trace frame, debug "the real world" */
{
if (curframe.valid)
gdb_note ("STUB: discard current trace frame #%d.\n",
curframe.frame_id);
curframe.valid = 0;
return "OK";
}
}
if (ret == OK_TARGET_RESPONSE) /* fetch_trace_frame succeeded */
{ /* setup for debugging the trace frame */
curframe.valid = 1;
curframe.frame_id = n_frame;
curframe.tdp_id = curframe.frame_data->id;
memset ((char *) &curframe.traceregs, 0,
sizeof (curframe.traceregs));
curframe.traceregs[PC] = (unsigned long)
curframe.frame_data->program_counter;
if (curframe.format)
{
unsigned long regs_mask = curframe.format->regs_mask;
unsigned long *regs, *stack, *mem;
unsigned long regno, index = 0;
CFD *dummy;
if ((ret = get_addr_to_frame_regs_stack_mem
(curframe.frame_data, &dummy, &regs, &stack, &mem))
!= OK_TARGET_RESPONSE)
{
curframe.valid = 0;
sprintp (retbuf, "E2%x", ret);
return (char *)
dtc_error_ret ((int) &retbuf,
"get_addr_to_frame_regs_stack_mem",
ret);
}
if (remote_debug > 1)
{ /* echo what we've found to gdb console */
sprintp (spare_buffer,
"STUB: Found frame %d, TDP %d, format %d (%s):\n",
curframe.frame_id,
curframe.tdp_id & 0x7fffffff,
curframe.format->id,
curframe.tdp_id & 0x80000000 ?
"trap frame" : "stepping frame");
gdb_puts (spare_buffer);
}
/* copy trace frame regs into stub's data format */
for (regno = 0, index = 0;
regno < 16;
regno++, regs_mask >>= 1)
if (regs_mask & 1) /* got a collected register */
{
curframe.traceregs[regno] = regs[index++];
if (remote_debug > 1)
{
sprintp (spare_buffer,
" Collected 0x%08x for register %d.\n",
curframe.traceregs[regno], regno);
gdb_puts (spare_buffer);
}
}
if (remote_debug > 1)
{
long midx, ridx, len;
MEMRANGE_DEF *mrange;
unsigned char *data, *base;
if (curframe.format->stack_size > 0)
{
len = curframe.format->stack_size;
sprintp (spare_buffer,
" Collected %d bytes of stack at 0x%x:\n",
len, curframe.traceregs[A7]);
gdb_puts (spare_buffer);
/* print stack data, but stay under msg len */
if (len >= (NUMREGBYTES/2 - 2))
len = (NUMREGBYTES/2 - 3);
mem2hex ((unsigned char *) stack,
spare_buffer, len, 0);
spare_buffer [len * 2] = '\n';
spare_buffer [len * 2 + 1] = '\0'; /* EOS */
gdb_puts (spare_buffer);
}
else
gdb_puts ("Stack not collected\n");
for (midx = 0;
get_addr_to_a_mem_range (curframe.frame_data,
midx,
&mrange,
(void **) &data)
== OK_TARGET_RESPONSE;
midx++)
{
if ((mrange->typecode == 0) ||
(mrange->typecode == (unsigned long) -1))
{
sprintp (spare_buffer,
" Collected %d bytes at MEM: 0x%x:\n",
mrange->size, mrange->offset);
base = (unsigned char *) mrange->offset;
}
else
{
if ((ridx = elinum_to_index (mrange->typecode)) > 0)
base = (unsigned char *) curframe.traceregs[ridx]
+ (long) mrange->offset;
else
{
sprintp (spare_buffer,
"STUB: bad typecode in memrange #%d: (0x%x,0x%x,0x%x).\n",
midx,
mrange->typecode,
mrange->offset,
mrange->size);
gdb_puts (spare_buffer);
continue;
}
sprintp (spare_buffer,
" Collected %d bytes at 0x%x (REG %X + %d):\n",
mrange->size,
base,
mrange->typecode,
mrange->offset);
}
gdb_puts (spare_buffer);
len = mrange->size;
if (len >= (NUMREGBYTES/2 - 2))
len = (NUMREGBYTES/2 - 3);
mem2hex (data, spare_buffer, len, 0);
spare_buffer [len * 2] = '\n';
spare_buffer [len * 2 + 1] = '\0'; /* EOS */
gdb_puts (spare_buffer);
}
}
}
sprintp (retbuf, "F%xT%x", n_frame, curframe.tdp_id & 0x7fffffff);
return retbuf;
}
else if (ret == NOT_FOUND_TARGET_RESPONSE)
{
/* Here's a question: if the fetch_trace_frame call failed
(which probably means a bad "TFIND" command from GDB),
should we remain focused on the previous frame (if any),
or should we revert to "no current frame"?
*/
return "F-1";
}
else
{
sprintp (retbuf, "E2%x", ret);
return (char *) dtc_error_ret ((int) &retbuf,
"fetch_trace_frame[...]",
ret);
}
}
else /* unknown trace command */
{
return "";
}
}
/* Table used by the crc32 function to calcuate the checksum. */
static unsigned long crc32_table[256];
static int crc_mem_err;
static unsigned long
crc32 (buf, len, crc)
unsigned char *buf;
int len;
unsigned long crc;
{
crc_mem_err = FALSE;
if (! crc32_table[1])
{
/* Initialize the CRC table and the decoding table. */
int i, j;
unsigned int c;
for (i = 0; i < 256; i++)
{
for (c = i << 24, j = 8; j > 0; --j)
c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1);
crc32_table[i] = c;
}
}
while (len--)
{
if (read_access_violation (buf))
{
crc_mem_err = TRUE;
return -1;
}
crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ *buf++) & 255];
}
return crc;
}
static char *
crc_query (cmd)
char *cmd;
{
unsigned long startmem, len, crc;
static char buf[32];
if (hexToInt (&cmd, &startmem) &&
*cmd++ == ',' &&
hexToInt (&cmd, &len))
{
crc = crc32 ((unsigned char *) startmem, len, 0xffffffff);
if (!crc_mem_err)
{
sprintp (buf, "C%08x", crc);
return buf;
}
/* else error, fall thru */
}
sprintp (buf, "E01");
return buf;
}
static char *
handle_test (request)
char *request;
{
ULONG args[7];
int i;
/* Parse the arguments, a comma-separated list of hex numbers, into
ARGS. Parse at most six arguments. */
i = 1;
if (*request != '\0')
while (i < 7)
{
if (! hexToInt (&request, &args[i++]))
return "E01";
if (*request == '\0')
break;
if (*request++ != ',')
return "E01";
}
/* Fill the rest of the args array with zeros. This is what the
INLINES command processor does with omitted arguments. */
for (; i < 7; i++)
args[i] = 0;
gdb_c_test (args);
return "OK";
}
/* GDB_TRAP_1_HANDLER
By the time this is called, the registers have been saved in "registers",
and the interrupt priority has been set to permit serial UART interrupts.
However, since no gdb request has yet been received, and there is no
equivalent of getpacket for us to wait on, we can't sit here waiting
for packets and processing them.
In fact, the ONLY thing for us to do here is sit and wait.
As gdb sends packet requests, they will handle themselves at the
interrupt level. When gdb decides we can continue, it will reset
the global variable "gdb_handling_trap1", and we will return
(whereupon registers will be restored etc.) */
void gdb_trap_1_handler( void )
{
gdb_handling_trap1 = TRUE;
sss_trace_flag = '\0'; /* shut off "trace bit" (indirectly) */
gdb_signo = 5;
putpacket( "S05" );
while ( gdb_handling_trap1 )
;
return;
}
void gdb_trace_handler( void )
{
sss_trace_flag = '\0'; /* shut off "trace bit" (indirectly) */
gdb_handling_trap1 = TRUE;
gdb_handling_sstrace = TRUE;
gdb_signo = 5;
putpacket( "S05" );
while ( gdb_handling_trap1 )
;
return;
}
Reference in New Issue View Git Blame Copy Permalink