gdb/target/target.c

   1 /* String reading
   2
   3    Copyright (C) 2022-2023 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   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.
  11
  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.
  16
  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/>.  */
  19
  20 #include "gdbsupport/common-defs.h"
  21 #include "target/target.h"
  22
  23 /* Read LEN bytes of target memory at address MEMADDR, placing the
  24    results in GDB's memory at MYADDR.  Returns a count of the bytes
  25    actually read, and optionally a target_xfer_status value in the
  26    location pointed to by ERRPTR if ERRPTR is non-null.  */
  27
  28 static int
  29 partial_memory_read (CORE_ADDR memaddr, gdb_byte *myaddr,
  30                      int len, int *errptr)
  31 {
  32   int nread;                    /* Number of bytes actually read.  */
  33   int errcode;                  /* Error from last read.  */
  34
  35   /* First try a complete read.  */
  36   errcode = target_read_memory (memaddr, myaddr, len);
  37   if (errcode == 0)
  38     {
  39       /* Got it all.  */
  40       nread = len;
  41     }
  42   else
  43     {
  44       /* Loop, reading one byte at a time until we get as much as we can.  */
  45       for (errcode = 0, nread = 0; len > 0 && errcode == 0; nread++, len--)
  46         {
  47           errcode = target_read_memory (memaddr++, myaddr++, 1);
  48         }
  49       /* If an error, the last read was unsuccessful, so adjust count.  */
  50       if (errcode != 0)
  51         {
  52           nread--;
  53         }
  54     }
  55   if (errptr != NULL)
  56     {
  57       *errptr = errcode;
  58     }
  59   return (nread);
  60 }
  61
  62 /* See target/target.h.  */
  63
  64 int
  65 target_read_string (CORE_ADDR addr, int len, int width,
  66                     unsigned int fetchlimit,
  67                     gdb::unique_xmalloc_ptr<gdb_byte> *buffer,
  68                     int *bytes_read)
  69 {
  70   int errcode;                  /* Errno returned from bad reads.  */
  71   unsigned int nfetch;          /* Chars to fetch / chars fetched.  */
  72   gdb_byte *bufptr;             /* Pointer to next available byte in
  73                                    buffer.  */
  74
  75   /* Loop until we either have all the characters, or we encounter
  76      some error, such as bumping into the end of the address space.  */
  77
  78   buffer->reset (nullptr);
  79
  80   if (len > 0)
  81     {
  82       /* We want fetchlimit chars, so we might as well read them all in
  83          one operation.  */
  84       unsigned int fetchlen = std::min ((unsigned) len, fetchlimit);
  85
  86       buffer->reset ((gdb_byte *) xmalloc (fetchlen * width));
  87       bufptr = buffer->get ();
  88
  89       nfetch = partial_memory_read (addr, bufptr, fetchlen * width, &errcode)
  90         / width;
  91       addr += nfetch * width;
  92       bufptr += nfetch * width;
  93     }
  94   else if (len == -1)
  95     {
  96       unsigned long bufsize = 0;
  97       unsigned int chunksize;   /* Size of each fetch, in chars.  */
  98       int found_nul;            /* Non-zero if we found the nul char.  */
  99       gdb_byte *limit;          /* First location past end of fetch buffer.  */
 100
 101       found_nul = 0;
 102       /* We are looking for a NUL terminator to end the fetching, so we
 103          might as well read in blocks that are large enough to be efficient,
 104          but not so large as to be slow if fetchlimit happens to be large.
 105          So we choose the minimum of 8 and fetchlimit.  We used to use 200
 106          instead of 8 but 200 is way too big for remote debugging over a
 107           serial line.  */
 108       chunksize = std::min (8u, fetchlimit);
 109
 110       do
 111         {
 112           nfetch = std::min ((unsigned long) chunksize, fetchlimit - bufsize);
 113
 114           if (*buffer == NULL)
 115             buffer->reset ((gdb_byte *) xmalloc (nfetch * width));
 116           else
 117             buffer->reset ((gdb_byte *) xrealloc (buffer->release (),
 118                                                   (nfetch + bufsize) * width));
 119
 120           bufptr = buffer->get () + bufsize * width;
 121           bufsize += nfetch;
 122
 123           /* Read as much as we can.  */
 124           nfetch = partial_memory_read (addr, bufptr, nfetch * width, &errcode)
 125                     / width;
 126
 127           /* Scan this chunk for the null character that terminates the string
 128              to print.  If found, we don't need to fetch any more.  Note
 129              that bufptr is explicitly left pointing at the next character
 130              after the null character, or at the next character after the end
 131              of the buffer.  */
 132
 133           limit = bufptr + nfetch * width;
 134           while (bufptr < limit)
 135             {
 136               bool found_nonzero = false;
 137
 138               for (int i = 0; !found_nonzero && i < width; ++i)
 139                 if (bufptr[i] != 0)
 140                   found_nonzero = true;
 141
 142               addr += width;
 143               bufptr += width;
 144               if (!found_nonzero)
 145                 {
 146                   /* We don't care about any error which happened after
 147                      the NUL terminator.  */
 148                   errcode = 0;
 149                   found_nul = 1;
 150                   break;
 151                 }
 152             }
 153         }
 154       while (errcode == 0       /* no error */
 155              && bufptr - buffer->get () < fetchlimit * width    /* no overrun */
 156              && !found_nul);    /* haven't found NUL yet */
 157     }
 158   else
 159     {                           /* Length of string is really 0!  */
 160       /* We always allocate *buffer.  */
 161       buffer->reset ((gdb_byte *) xmalloc (1));
 162       bufptr = buffer->get ();
 163       errcode = 0;
 164     }
 165
 166   /* bufptr and addr now point immediately beyond the last byte which we
 167      consider part of the string (including a '\0' which ends the string).  */
 168   *bytes_read = bufptr - buffer->get ();
 169
 170   return errcode;
 171 }
 172
 173 /* See target/target.h.  */
 174
 175 gdb::unique_xmalloc_ptr<char>
 176 target_read_string (CORE_ADDR memaddr, int len, int *bytes_read)
 177 {
 178   gdb::unique_xmalloc_ptr<gdb_byte> buffer;
 179
 180   int ignore;
 181   if (bytes_read == nullptr)
 182     bytes_read = &ignore;
 183
 184   /* Note that the endian-ness does not matter here.  */
 185   int errcode = target_read_string (memaddr, -1, 1, len, &buffer, bytes_read);
 186   if (errcode != 0)
 187     return {};
 188
 189   return gdb::unique_xmalloc_ptr<char> ((char *) buffer.release ());
 190 }
 191
 192 /* See target/target.h.  */
 193
 194 std::string
 195 to_string (gdb_thread_options options)
 196 {
 197   static constexpr gdb_thread_options::string_mapping mapping[] = {
 198     MAP_ENUM_FLAG (GDB_THREAD_OPTION_CLONE),
 199     MAP_ENUM_FLAG (GDB_THREAD_OPTION_EXIT),
 200   };
 201   return options.to_string (mapping);
 202 }