getdata.c

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

      return (0);
   } 

   for (i=1; i<(string_length-1); i=i+1)
    if (isxdigit(memory_str[i]) == 0)
       return (EMBADADDR);

   if ((isxdigit(memory_str[(string_length-1)]) == 0) &&
       (memory_str[(string_length-1)] != 'i') &&
       (memory_str[(string_length-1)] != 'm') &&
       (memory_str[(string_length-1)] != 'u') &&
       (memory_str[(string_length-1)] != 'p') &&
       (memory_str[(string_length-1)] != 'r'))
      return (EMBADADDR);

   fields = sscanf(memory_str, "%lx%c%c", &addr, &i_r, &error);

   addr_29k->address = addr;

   if (fields == 1) {
      addr_29k->memory_space = default_space;
      }
   else
   if (fields == 2) {
      if ((i_r == '\0') || (i_r == 'm'))
         addr_29k->memory_space = D_MEM;
      else
      if (i_r == 'r')
         addr_29k->memory_space = I_ROM;
      else
      if (i_r == 'i')
         addr_29k->memory_space = I_MEM;
      else
      if (i_r == 'p')
	 if ((target_config.processor_id & 0xf1) >= 0x50)
            addr_29k->memory_space = GENERIC_SPACE;
	 else
            addr_29k->memory_space = I_O;
      else
      if (i_r == 'u')
         addr_29k->memory_space = GENERIC_SPACE;
      else
         return (EMBADADDR);
      }
   else
      return (EMBADADDR);

   return (0);      
   }  /* end get_memory_29k() */



/*
** This function is used to convert a string denoting an
** 29k register into an addr_29k_t memory space / address pair.
*/

int
get_register_29k(reg_str, addr_29k)
   char   *reg_str;
   struct  addr_29k_t  *addr_29k;
   {
   int     fields;
   ADDR32  reg_number;
   char    error;

   addr_29k->memory_space = -1;
   addr_29k->address = -1;

   reg_number = 0;
   error = '\0';

   if (strlen(reg_str) > 8)
      return (EMBADREG);

   if (strncmp(reg_str, "lr", 2) == 0)
      addr_29k->memory_space = LOCAL_REG;
   else
   if (strncmp(reg_str, "ar", 2) == 0)
      addr_29k->memory_space = ABSOLUTE_REG;
   else
   if (strncmp(reg_str, "gr", 2) == 0)
      addr_29k->memory_space = GLOBAL_REG;
   else
   if (strncmp(reg_str, "sr", 2) == 0)
      addr_29k->memory_space = A_SPCL_REG;
   else
   if (strncmp(reg_str, "tr", 2) == 0)
      addr_29k->memory_space = TLB_REG;
   else
   if (strncmp(reg_str, "xr", 2) == 0)
     addr_29k->memory_space = COPROC_REG;

   /* Get register number */
   if (addr_29k->memory_space != -1) {
      fields = sscanf(&(reg_str[2]), "%ld%c", &reg_number, &error);
      if ((fields == 1) &&
          (error == '\0')) 
         addr_29k->address = reg_number;
         else
            addr_29k->memory_space = -1;
      }

   if (addr_29k->memory_space == -1)
      return (EMBADREG);
      else
         return (0);      
   }  /* end get_register_29k() */




/*
** This function is used to get the special register aliases
** ("cps", "vab", "ops", etc ...) in addition to the registers
** described in get_addr_29k() above.
*/

int
get_alias_29k(reg_str, addr_29k)
   char   *reg_str;
   struct  addr_29k_t  *addr_29k;
   {
   int     i;
   int     result;
   int     found;

   addr_29k->memory_space = -1;
   addr_29k->address = -1;

   if (strlen(reg_str) > 8)
      return (EMBADREG);

   /* Check for logical PC */
   if ((strcmp("pc", reg_str) == 0) ||
       (strcmp("PC", reg_str) == 0)) {
         addr_29k->memory_space = PC_SPACE;
         addr_29k->address = (ADDR32) 0;
	 return (0);
   }
   /* Search for a special register alias */
   i=0;
   found = FALSE;
   while ((i<256) && (found != TRUE)) {
      result = strcmp(spreg[i], reg_str);
      if (result == 0) {
         found = TRUE;
         addr_29k->memory_space = A_SPCL_REG;
         addr_29k->address = (ADDR32) i;
         }
      i = i + 1;
      }  /* end while */

   if (found == TRUE)
      return (0);      
      else
         return (EMBADREG);

   }  /* end get_alias_29k() */





/*
** This function is used to read in a 32 bit hex word.
** This word is input as an ASCII string and converted
** into an INT32 data_word.  If the conversion is successful,
** a zero is returned, otherwise a -1 is returned.
*/

int
get_word(buffer, data_word)
   char    *buffer;
   INT32   *data_word;
   {
   int      fields;
   char     error;

   /* No more than eight (hex) characters */
   if (strlen(buffer) > 8)
      return (EMSYNTAX);

   fields = sscanf(buffer, "%lx%c", data_word, &error);

   if (fields != 1)
      return (EMSYNTAX);

   return (0);

   }  /* end get_word() */



int
get_half(buffer, data_half)
   char    *buffer;
   INT16   *data_half;
   {
   int      fields;
   char     error;
   INT16      temp_int;

   /* No more than four (hex) characters */
   if (strlen(buffer) > 4)
      return (EMSYNTAX);

   fields = sscanf(buffer, "%hx%c", &temp_int, &error);

   if (fields != 1)
      return (EMSYNTAX);

   *data_half = (INT16) temp_int;

   return (0);

   }  /* end get_half() */


int
get_byte(buffer, data_byte)
   char    *buffer;
   BYTE    *data_byte;
   {
   int      fields;
   char     error;
   int      temp_int;

   /* No more than two (hex) characters */
   if (strlen(buffer) > 2)
      return (EMSYNTAX);

   fields = sscanf(buffer, "%x%c", &temp_int, &error);

   if (fields != 1)
      return (EMSYNTAX);

   *data_byte = (BYTE) temp_int;

   return (0);

   }  /* end get_byte() */


int
get_float(buffer, data_float)
   char    *buffer;
   float   *data_float;
   {
   int      fields;
   char     error;

   fields = sscanf(buffer, "%f%c", data_float, &error);

   if (fields != 1)
      return (EMSYNTAX);

   return (0);

   }  /* end get_float() */


int
get_double(buffer, data_double)
   char    *buffer;
   double  *data_double;
   {
   int      fields;
   char     error;

   fields = sscanf(buffer, "%lf%c", data_double, &error);

   if (fields != 1)
      return (EMSYNTAX);

   return (0);


   }  /* end get_double() */




/*
** This function is used to read in a 32 bit decimal word.
** This word is input as an ASCII string and converted
** into an INT32 data_word.  If the conversion is successful,
** a zero is returned, otherwise a -1 is returned.
** This function is very similar to get_word().
*/

int
get_word_decimal(buffer, data_word)
   char    *buffer;
   INT32   *data_word;
   {
   int      fields;
   char     error;

   /* No more than eight (hex) characters */
   if (strlen(buffer) > 8)
      return (EMSYNTAX);

   fields = sscanf(buffer, "%ld%c", data_word, &error);

   if (fields != 1)
      return (EMSYNTAX);

   return (0);

   }  /* end get_word_decimal() */


/*
** This function is used to copy data from into and out
** of the message buffers.  If necessary, endian
** conversion is performed.
*/

int
set_data(out_data, in_data, size)
   BYTE  *out_data;
   BYTE  *in_data;
   int    size;
   {
   int  i;

   if (host_config.host_endian == host_config.target_endian)
      for (i=0; i<size; i=i+1)
         out_data[i] = in_data[i];
      else
         for (i=0; i<size; i=i+1)
            out_data[i] = in_data[((size-1)-i)];

   return (0);      
   }  /* end set_data() */




/*
** This function is used to get data.
** If necessary, endian conversion is performed.
*/

int
get_data(out_data, in_data, size)
   BYTE  *out_data;
   BYTE  *in_data;
   int    size;
   {
   int  i;

   if (host_config.host_endian == host_config.target_endian)
      for (i=0; i<size; i=i+1)
         out_data[i] = in_data[i];
      else
         for (i=0; i<size; i=i+1)
            out_data[i] = in_data[((size-1)-i)];

   return (0);      
   }  /* end get_data() */



/*
** This function is used to swap the bytes in a 32 bit
** word.  This will convert "little endian" (IBM-PC / Intel)
** words to "big endian" (Sun / Motorola) words.
*/

void
convert32(byte)
   BYTE *byte;
   {
   BYTE temp;

   temp = byte[0];  /* Swap bytes 0 and 3 */
   byte[0] = byte[3];
   byte[3] = temp;
   temp = byte[1];  /* Swap bytes 1 and 2 */
   byte[1] = byte[2];
   byte[2] = temp;
   }   /* end convert32() */


/*
** This function is used to swap the bytes in a 16 bit
** word.  This will convert "little endian" (IBM-PC / Intel)
** half words to "big endian" (Sun / Motorola) half words.
*/

void
convert16(byte)
   BYTE *byte;
   {
   BYTE temp;

   temp = byte[0];  /* Swap bytes 0 and 1 */
   byte[0] = byte[1];
   byte[1] = temp;

   }   /* end convert16() */