dump.c

gdb是linux下的一个远程调试环境.能让你很方便地调试linux下的代码.

static char _[] = " @(#)dump.c	5.20 93/07/30 16:38:27, Srini, AMD ";
/******************************************************************************
 * Copyright 1991 Advanced Micro Devices, Inc.
 *
 * This software is the property of Advanced Micro Devices, Inc  (AMD)  which
 * specifically  grants the user the right to modify, use and distribute this
 * software provided this notice is not removed or altered.  All other rights
 * are reserved by AMD.
 *
 * AMD MAKES NO WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, WITH REGARD TO THIS
 * SOFTWARE.  IN NO EVENT SHALL AMD BE LIABLE FOR INCIDENTAL OR CONSEQUENTIAL
 * DAMAGES IN CONNECTION WITH OR ARISING FROM THE FURNISHING, PERFORMANCE, OR
 * USE OF THIS SOFTWARE.
 *
 * So that all may benefit from your experience, please report  any  problems
 * or  suggestions about this software to the 29K Technical Support Center at
 * 800-29-29-AMD (800-292-9263) in the USA, or 0800-89-1131  in  the  UK,  or
 * 0031-11-1129 in Japan, toll free.  The direct dial number is 512-462-4118.
 *
 * Advanced Micro Devices, Inc.
 * 29K Support Products
 * Mail Stop 573
 * 5900 E. Ben White Blvd.
 * Austin, TX 78741
 * 800-292-9263
 *****************************************************************************
 *      Engineer: Srini Subramanian.
 *****************************************************************************
 ** 
 **       This code provides dump routines to output data in
 **       hex / ASCII formats. 
 **
 *****************************************************************************
 */

#include <stdio.h>
#include <ctype.h>
#include <memory.h>
#include "main.h"
#include "macros.h"
#include "monitor.h"
#include "miniint.h"
#include "memspcs.h"
#include "error.h"


#ifdef MSDOS
#include <stdlib.h>
#include <string.h>
#else
#include <string.h>
#endif

int   get_addr_29k PARAMS((char *, struct addr_29k_t *));
int   addr_29k_ok PARAMS((struct addr_29k_t *));
int   print_addr_29k PARAMS((INT32, ADDR32));

int   dump_mem_word PARAMS((INT32 mspace, ADDR32 addr, INT32 bytes, BYTE *buf));
int   dump_reg_word PARAMS((INT32 mspace, ADDR32 addr, INT32 bytes, BYTE *buf));
int   dump_mem_half PARAMS((INT32 mspace, ADDR32 addr, INT32 bytes, BYTE *buf));
int   dump_reg_half PARAMS((INT32 mspace, ADDR32 addr, INT32 bytes, BYTE *buf));
int   dump_mem_byte PARAMS((INT32 mspace, ADDR32 addr, INT32 bytes, BYTE *buf));
int   dump_reg_byte PARAMS((INT32 mspace, ADDR32 addr, INT32 bytes, BYTE *buf));
int   dump_mem_float PARAMS((INT32 mspace, ADDR32 addr, INT32 bytes, BYTE *buf));
int   dump_reg_float PARAMS((INT32 mspace, ADDR32 addr, INT32 bytes, BYTE *buf));
int   dump_mem_double PARAMS((INT32 mspace, ADDR32 addr, INT32 bytes, BYTE *buf));
int   dump_reg_double PARAMS((INT32 mspace, ADDR32 addr, INT32 bytes, BYTE *buf));

int   get_data PARAMS((BYTE *, BYTE *, int));
int   dump_ASCII PARAMS((char *, int, BYTE *, int));


/*
** The function below is used in dumping data.  This function is
** called in the main command loop parser of the monitor.  The
** parameters passed to this function are:
**
** token - This is an array of pointers to strings.  Each string
**         referenced by this array is a "token" of the user's
**         input, translated to lower case.
**
** token_count - This is the number of tokens in "token".
**
** This function reduces the tokens to three parameters:
** memory_space, address and byte_count.  The address parameter is
** aligned as follows:
**
**    - All register accesses are byte aligned.  The address,
**      however, accesses 32 bit words.  The valued in these
**      registers are displayed in formats determined by the
**      first token.
**
**    - Memory addresses are aligned and displayed according
**      to the dump format as specified in the first token.
** 
**
*/


INT32
dump_cmd(token, token_count)
   char   *token[];
   int     token_count;
   {
   static INT32  memory_space=D_MEM;
   static ADDR32 address=0;
   INT32  byte_count=64;
   int    result;
   struct addr_29k_t addr_29k_start;
   struct addr_29k_t addr_29k_end;
   int    dump_format;
   int    object_size;
   ADDR32 align_mask;

   INT32	retval;
   INT32	hostendian;
   INT32	bytes_returned;
   BYTE		*read_buffer;

   /*
   ** What is the dump format?
   */

   if ((strcmp(token[0], "d") == 0) ||
       (strcmp(token[0], "dw") == 0)) {
      dump_format = WORD_FORMAT;
      object_size = sizeof(INT32);
      align_mask = 0xfffffffc;
      }
   else
   if (strcmp(token[0], "dh") == 0) {
      dump_format = HALF_FORMAT;
      object_size = sizeof(INT16);
      align_mask = 0xfffffffe;
      }
   else
   if (strcmp(token[0], "db") == 0) {
      dump_format = BYTE_FORMAT;
      object_size = sizeof(BYTE);
      align_mask = 0xffffffff;
      }
   else
   if (strcmp(token[0], "df") == 0) {
      dump_format = FLOAT_FORMAT;
      object_size = sizeof(float);
      align_mask = 0xfffffffc;
      }
   else
   if (strcmp(token[0], "dd") == 0) {
      dump_format = DOUBLE_FORMAT;
      object_size = sizeof(double);
      align_mask = 0xfffffff8;
      }
   else
      return(EMSYNTAX);

   /*
   ** Get start address and byte count
   */

   if (token_count == 1) {
      if (ISREG(memory_space))
         address = address + (byte_count/4);
      else
      if (ISMEM(memory_space))
         address = address + byte_count;
      else
         return(EMBADADDR);
      /* Check the start address */
      addr_29k_start.address = address;
      addr_29k_start.memory_space = memory_space;
      result = addr_29k_ok(&addr_29k_start);
      if (result != 0)
         return (result);
      }
   else
   if (token_count == 2) {
      result = get_addr_29k(token[1], &addr_29k_start);
      if (result != 0)
         return (EMSYNTAX);
      /* Check the start address */
      result = addr_29k_ok(&addr_29k_start);
      if (result != 0)
         return (result);

      memory_space = addr_29k_start.memory_space;
      /* Make sure we have an even multiple of object_size */
      if (ISREG(memory_space)) {
         address = addr_29k_start.address;
         byte_count = (byte_count + (object_size - 1)) & 0xfffffffc;
         }
      else
      if (ISMEM(memory_space)) {
         address = addr_29k_start.address & align_mask;
         byte_count = (byte_count + (object_size - 1)) & align_mask;
         }
      else
         return(EMBADADDR);
      }
   else
   if (token_count == 3) {
      result = get_addr_29k(token[1], &addr_29k_start);
      if (result != 0)
         return (EMSYNTAX);
      /* Only check the start address */
      result = addr_29k_ok(&addr_29k_start);
      if (result != 0)
         return (result);
      result = get_addr_29k(token[2], &addr_29k_end);
      if (result != 0)
         return (EMSYNTAX);

      if (addr_29k_start.memory_space != addr_29k_end.memory_space)
         return (EMBADADDR);
      if (addr_29k_start.address > addr_29k_end.address)
         return (EMBADADDR);

      memory_space = addr_29k_start.memory_space;
      if (ISREG(memory_space)) {
         address = addr_29k_start.address;
         byte_count = (addr_29k_end.address -
                       addr_29k_start.address + 1) * 4;
         }
      else
      if (ISMEM(memory_space)) {
         address = addr_29k_start.address & align_mask;
         byte_count = ((addr_29k_end.address & align_mask) -
                       (addr_29k_start.address & align_mask) +
                      object_size);
         }
      else
         return(EMBADADDR);

      }
   else
   /* Too many args */
      return (EMSYNTAX);


   /*
   ** Get data
   */

   /* Will the data overflow the message buffer? Done by TIP ??*/
   if ((read_buffer = (BYTE *) malloc((unsigned int) byte_count)) == NULL) {
       warning(EMALLOC);
       return(FAILURE);
   };

   hostendian = FALSE;
   if ((retval = Mini_read_req(memory_space,
				address,
				byte_count / object_size,
				(INT16) object_size, 
				&bytes_returned,
				read_buffer,
				hostendian)) != SUCCESS) {
	return(FAILURE);
   };
  
   bytes_returned = bytes_returned * object_size;
    
    /* Continue if SUCCESSful */
    
   /*
   ** Call data format routines
   */

   if ISMEM(memory_space) {
      if (dump_format == WORD_FORMAT)
         result = dump_mem_word(memory_space,
				address,
				bytes_returned,
				read_buffer);
      else
      if (dump_format == HALF_FORMAT)
         result = dump_mem_half(memory_space,
				address,
				bytes_returned,
				read_buffer);
      else
      if (dump_format == BYTE_FORMAT)
         result = dump_mem_byte(memory_space,
				address,
				bytes_returned,
				read_buffer);
      else
      if (dump_format == FLOAT_FORMAT)
         result = dump_mem_float(memory_space,
				address,
				bytes_returned,
				read_buffer);
      else
      if (dump_format == DOUBLE_FORMAT)
         result = dump_mem_double(memory_space,
				address,
				bytes_returned,
				read_buffer);
      }
   else
   if ISREG(memory_space) {
      if (dump_format == WORD_FORMAT)
         result = dump_reg_word(memory_space,
				address,
				bytes_returned,
				read_buffer);
      else
      if (dump_format == HALF_FORMAT)
         result = dump_reg_half(memory_space,
				address,
				bytes_returned,
				read_buffer);
      else
      if (dump_format == BYTE_FORMAT)
         result = dump_reg_byte(memory_space,
				address,
				bytes_returned,
				read_buffer);
      else
      if (dump_format == FLOAT_FORMAT)
         result = dump_reg_float(memory_space,
				address,
				bytes_returned,
				read_buffer);
      else
      if (dump_format == DOUBLE_FORMAT)
         result = dump_reg_double(memory_space,
				address,
				bytes_returned,
				read_buffer);
      }
   else
      return(EMBADADDR);

   (void) free ((char *) read_buffer);
   return (result);

   }  /* end dump_cmd() */



/*
** Functions used by dump_cmd()
*/


/*
** This function is used to dump 32 bit words of data.
** the address is printed, followed by the data, grouped
** into 8 character long strings, each representing one
** 32 bit word.  Space for four 32-bit words is reserved
** on each line.  Following the hex data, an ASCII
** representation of the data is printed.
*/

int
dump_mem_word(memory_space, read_address, bytes_returned, read_buffer)
   INT32  memory_space;
   ADDR32 read_address;
   INT32  bytes_returned;
   BYTE   *read_buffer;
   {
   int      result;
   ADDR32   address;
   ADDR32   start_address;
   ADDR32   end_address;
   ADDR32   last_print_address;
   ADDR32   address_mask;
   INT32    byte_count;
   INT32    data_word;
   struct   addr_29k_t addr_29k;
   int      ASCII_index;
   char     ASCII_buffer[20];

   byte_count = 0;
   ASCII_index = 0;
   ASCII_buffer[0] = '\0';

   address_mask = 0xfffffff0;
   start_address = read_address;
   end_address = read_address + bytes_returned;
   last_print_address = (end_address + 0xf) & address_mask;
   address = start_address & address_mask;

   /*
   ** Loop while data available
   */

   while (address <= last_print_address) {

      /* Exit if address not valid */
      addr_29k.memory_space = memory_space;
      addr_29k.address = address;
      result = addr_29k_ok(&addr_29k);
      if (result != 0) {
	 if (io_config.echo_mode == (INT32) TRUE)
         fprintf(io_config.echo_file, "\n\n");
         fprintf(stderr, "\n\n");
         return (0);
         }

      /* Print out ASCII data */
      if ((address & address_mask) == address) {
         fprintf(stderr, "  %s\n", ASCII_buffer);
	 if (io_config.echo_mode == (INT32) TRUE)
         fprintf(io_config.echo_file, "  %s\n", ASCII_buffer);
         ASCII_index = 0;
         }

      /* Print address in margin */
      if (((address & address_mask) == address) &&
          (address  != last_print_address)) {
         result = print_addr_29k(memory_space, address);
         if (result != 0)
            return (EMBADADDR);
         }

      /* Do leading and trailing spaces (if necessary) */
      if ((address < start_address) ||
          (address >= end_address)) {
         fprintf(stderr, "         ");
	 if (io_config.echo_mode == (INT32) TRUE)
         fprintf(io_config.echo_file, "         ");
         result = dump_ASCII(ASCII_buffer, ASCII_index,
                             (BYTE *) NULL, sizeof(INT32)); 
         ASCII_index = ASCII_index + sizeof(INT32);
         address = address + sizeof(INT32);
         }

      /* Print out hex data */
      if ((address >= start_address) &&
          (address < end_address)) {

         result = get_data((BYTE *)&data_word,
                           &read_buffer[byte_count],
                           sizeof(INT32));
         if (result != 0)
            return (EMBADADDR);

         fprintf(stderr, "%08lx ", data_word);
	 if (io_config.echo_mode == (INT32) TRUE)
         fprintf(io_config.echo_file, "%08lx ", data_word);

         /* Build ASCII srting */
         result = dump_ASCII(ASCII_buffer,
                             ASCII_index,
                             &read_buffer[byte_count],
                             sizeof(INT32)); 
         ASCII_index = ASCII_index + sizeof(INT32);

         address = address + sizeof(INT32);

         byte_count = byte_count + sizeof(INT32);

         }  /* end if */

      }  /* end while */

   fprintf(stderr, "\n");
   if (io_config.echo_mode == (INT32) TRUE)
   fprintf(io_config.echo_file, "\n");

   return (0);

   }  /* end dump_mem_word() */


int
dump_reg_word(memory_space, read_address, bytes_returned, read_buffer)
   INT32  memory_space;
   ADDR32 read_address;
   INT32  bytes_returned;
   BYTE   *read_buffer;
   {
   int      result;
   ADDR32   address;
   ADDR32   start_address;
   ADDR32   end_address;
   ADDR32   last_print_address;
   ADDR32   address_mask;
   INT32    byte_count;
   INT32    data_word;
   struct   addr_29k_t addr_29k;
   int      ASCII_index;
   char     ASCII_buffer[20];

   byte_count = 0;
   ASCII_index = 0;
   ASCII_buffer[0] = '\0';

   address_mask = 0xfffffffc;
   start_address = read_address;
   end_address = read_address + (bytes_returned / 4);
   last_print_address = (end_address + 0x3) & address_mask;
   address = start_address & address_mask;