dump.c

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

   /*
   ** 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) {
         fprintf(stderr, "\n\n");
	 if (io_config.echo_mode == (INT32) TRUE)
         fprintf(io_config.echo_file, "\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 + 1;
         }

      /* 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 + 1;

         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_reg_word() */



/*
** This function is used to dump memory as half words.
*/

int
dump_mem_half(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;
   INT16    data_half;
   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) {
         fprintf(stderr, "\n\n");
	 if (io_config.echo_mode == (INT32) TRUE)
         fprintf(io_config.echo_file, "\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(INT16));
         ASCII_index = ASCII_index + sizeof(INT16);
         address = address + sizeof(INT16);
         }

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

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

         /* We have to cast to INT32 to print out a hex halfword */
         /* (the Sun libraries sign extend to 32 bits) */
         data_word = (INT32) data_half;
         data_word = (data_word & 0x0000ffff);
         fprintf(stderr, "%04x ", data_word);
	 if (io_config.echo_mode == (INT32) TRUE)
         fprintf(io_config.echo_file, "%04x ", data_word);

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

         address = address + sizeof(INT16);

         byte_count = byte_count + sizeof(INT16);

         }  /* 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_half() */



/*
** This function is used to dump registers as half words.
*/

int
dump_reg_half(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;

   /*
   ** 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) {
         fprintf(stderr, "\n\n");
	 if (io_config.echo_mode == (INT32) TRUE)
         fprintf(io_config.echo_file, "\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(INT16));
         ASCII_index = ASCII_index + sizeof(INT16);

         address = address + 1;
         }

      /* 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, "%04lx %04lx ",
                ((data_word >> 16) & 0xffff),
                (data_word & 0xffff));
	 if (io_config.echo_mode == (INT32) TRUE)
         fprintf(io_config.echo_file, "%04lx %04lx ",
                ((data_word >> 16) & 0xffff),
                (data_word & 0xffff));

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

         address = address + 1;

         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_reg_half() */



/*
** This function is used to dump memory as bytes.
*/

int
dump_mem_byte(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;
   BYTE     data_byte;
   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) {
         fprintf(stderr, "\n\n");
	 if (io_config.echo_mode == (INT32) TRUE)
         fprintf(io_config.echo_file, "\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(BYTE));
         ASCII_index = ASCII_index + sizeof(BYTE);
         address = address + sizeof(BYTE);
         }

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

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

         fprintf(stderr, "%02x ", data_byte);
	 if (io_config.echo_mode == (INT32) TRUE)
         fprintf(io_config.echo_file, "%02x ", data_byte);

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

         address = address + sizeof(BYTE);

         byte_count = byte_count + sizeof(BYTE);

         }  /* 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_byte() */



/*
** This function is used to dump registers as bytes.
*/

int
dump_reg_byte(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;

   /*
   ** 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) {
         fprintf(stderr, "\n\n");
	 if (io_config.echo_mode == (INT32) TRUE)
         fprintf(io_config.echo_file, "\n\n");
         return (0);
         }

      /* Print out ASCII data */
      if ((address & address_mask) == address) {