]> Git Repo - binutils.git/blob - gdb/target/target.c
Automatic date update in version.in
[binutils.git] / gdb / target / target.c
1 /* String reading
2
3    Copyright (C) 2022 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 }
This page took 0.035504 seconds and 4 git commands to generate.