gdb/common/rsp-low.c - gdb

Global variables defined

Functions defined

Source code

  1. /* Low-level RSP routines for GDB, the GNU debugger.

  3.    Copyright (C) 1988-2015 Free Software Foundation, Inc.

  5.    This file is part of GDB.

  7.    This program is free software; you can redistribute it and/or modify
  8.    it under the terms of the GNU General Public License as published by
  9.    the Free Software Foundation; either version 3 of the License, or
  10.    (at your option) any later version.

  12.    This program is distributed in the hope that it will be useful,
  13.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.    GNU General Public License for more details.

  17.    You should have received a copy of the GNU General Public License
  18.    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

  20. #include "common-defs.h"
  21. #include "rsp-low.h"

  23. /* See rsp-low.h.  */

  25. int
  26. ‌fromhex (int a)
  27. {
  28.   if (a >= '0' && a <= '9')
  29.     return a - '0';
  30.   else if (a >= 'a' && a <= 'f')
  31.     return a - 'a' + 10;
  32.   else if (a >= 'A' && a <= 'F')
  33.     return a - 'A' + 10;
  34.   else
  35.     error (_("Reply contains invalid hex digit %d"), a);
  36. }

  38. /* See rsp-low.h.  */

  40. int
  41. ‌tohex (int nib)
  42. {
  43.   if (nib < 10)
  44.     return '0' + nib;
  45.   else
  46.     return 'a' + nib - 10;
  47. }

  49. /* Encode 64 bits in 16 chars of hex.  */

  51. ‌static const char hexchars[] = "0123456789abcdef";

  53. static int
  54. ‌ishex (int ch, int *val)
  55. {
  56.   if ((ch >= 'a') && (ch <= 'f'))
  57.     {
  58.       *val = ch - 'a' + 10;
  59.       return 1;
  60.     }
  61.   if ((ch >= 'A') && (ch <= 'F'))
  62.     {
  63.       *val = ch - 'A' + 10;
  64.       return 1;
  65.     }
  66.   if ((ch >= '0') && (ch <= '9'))
  67.     {
  68.       *val = ch - '0';
  69.       return 1;
  70.     }
  71.   return 0;
  72. }

  74. /* See rsp-low.h.  */

  76. char *
  77. ‌pack_nibble (char *buf, int nibble)
  78. {
  79.   *buf++ = hexchars[(nibble & 0x0f)];
  80.   return buf;
  81. }

  83. /* See rsp-low.h.  */

  85. char *
  86. ‌pack_hex_byte (char *pkt, int byte)
  87. {
  88.   *pkt++ = hexchars[(byte >> 4) & 0xf];
  89.   *pkt++ = hexchars[(byte & 0xf)];
  90.   return pkt;
  91. }

  93. /* See rsp-low.h.  */

  95. char *
  96. ‌unpack_varlen_hex (char *buff,        /* packet to parse */
  97.                    ULONGEST *result)
  98. {
  99.   int nibble;
  100.   ULONGEST retval = 0;

  102.   while (ishex (*buff, &nibble))
  103.     {
  104.       buff++;
  105.       retval = retval << 4;
  106.       retval |= nibble & 0x0f;
  107.     }
  108.   *result = retval;
  109.   return buff;
  110. }

  112. /* See rsp-low.h.  */

  114. int
  115. ‌hex2bin (const char *hex, gdb_byte *bin, int count)
  116. {
  117.   int i;

  119.   for (i = 0; i < count; i++)
  120.     {
  121.       if (hex[0] == 0 || hex[1] == 0)
  122.         {
  123.           /* Hex string is short, or of uneven length.
  124.              Return the count that has been converted so far.  */
  125.           return i;
  126.         }
  127.       *bin++ = fromhex (hex[0]) * 16 + fromhex (hex[1]);
  128.       hex += 2;
  129.     }
  130.   return i;
  131. }

  133. /* See rsp-low.h.  */

  135. int
  136. ‌bin2hex (const gdb_byte *bin, char *hex, int count)
  137. {
  138.   int i;

  140.   for (i = 0; i < count; i++)
  141.     {
  142.       *hex++ = tohex ((*bin >> 4) & 0xf);
  143.       *hex++ = tohex (*bin++ & 0xf);
  144.     }
  145.   *hex = 0;
  146.   return i;
  147. }

  149. /* See rsp-low.h.  */

  151. int
  152. ‌remote_escape_output (const gdb_byte *buffer, int len,
  153.                       gdb_byte *out_buf, int *out_len,
  154.                       int out_maxlen)
  155. {
  156.   int input_index, output_index;

  158.   output_index = 0;
  159.   for (input_index = 0; input_index < len; input_index++)
  160.     {
  161.       gdb_byte b = buffer[input_index];

  163.       if (b == '$' || b == '#' || b == '}' || b == '*')
  164.         {
  165.           /* These must be escaped.  */
  166.           if (output_index + 2 > out_maxlen)
  167.             break;
  168.           out_buf[output_index++] = '}';
  169.           out_buf[output_index++] = b ^ 0x20;
  170.         }
  171.       else
  172.         {
  173.           if (output_index + 1 > out_maxlen)
  174.             break;
  175.           out_buf[output_index++] = b;
  176.         }
  177.     }

  179.   *out_len = input_index;
  180.   return output_index;
  181. }

  183. /* See rsp-low.h.  */

  185. int
  186. ‌remote_unescape_input (const gdb_byte *buffer, int len,
  187.                        gdb_byte *out_buf, int out_maxlen)
  188. {
  189.   int input_index, output_index;
  190.   int escaped;

  192.   output_index = 0;
  193.   escaped = 0;
  194.   for (input_index = 0; input_index < len; input_index++)
  195.     {
  196.       gdb_byte b = buffer[input_index];

  198.       if (output_index + 1 > out_maxlen)
  199.         error (_("Received too much data from the target."));

  201.       if (escaped)
  202.         {
  203.           out_buf[output_index++] = b ^ 0x20;
  204.           escaped = 0;
  205.         }
  206.       else if (b == '}')
  207.         escaped = 1;
  208.       else
  209.         out_buf[output_index++] = b;
  210.     }

  212.   if (escaped)
  213.     error (_("Unmatched escape character in target response."));

  215.   return output_index;
  216. }