Automatic date update in version.in
[platform/upstream/binutils.git] / gdb / target-memory.c
1 /* Parts of target interface that deal with accessing memory and memory-like
2    objects.
3
4    Copyright (C) 2006-2014 Free Software Foundation, Inc.
5
6    This file is part of GDB.
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
20
21 #include "defs.h"
22 #include "vec.h"
23 #include "target.h"
24 #include "memory-map.h"
25
26 #include <sys/time.h>
27
28 static int
29 compare_block_starting_address (const void *a, const void *b)
30 {
31   const struct memory_write_request *a_req = a;
32   const struct memory_write_request *b_req = b;
33
34   if (a_req->begin < b_req->begin)
35     return -1;
36   else if (a_req->begin == b_req->begin)
37     return 0;
38   else
39     return 1;
40 }
41
42 /* Adds to RESULT all memory write requests from BLOCK that are
43    in [BEGIN, END) range.
44
45    If any memory request is only partially in the specified range,
46    that part of the memory request will be added.  */
47
48 static void
49 claim_memory (VEC(memory_write_request_s) *blocks,
50               VEC(memory_write_request_s) **result,
51               ULONGEST begin,
52               ULONGEST end)
53 {
54   int i;
55   ULONGEST claimed_begin;
56   ULONGEST claimed_end;
57   struct memory_write_request *r;
58
59   for (i = 0; VEC_iterate (memory_write_request_s, blocks, i, r); ++i)
60     {
61       /* If the request doesn't overlap [BEGIN, END), skip it.  We
62          must handle END == 0 meaning the top of memory; we don't yet
63          check for R->end == 0, which would also mean the top of
64          memory, but there's an assertion in
65          target_write_memory_blocks which checks for that.  */
66
67       if (begin >= r->end)
68         continue;
69       if (end != 0 && end <= r->begin)
70         continue;
71
72       claimed_begin = max (begin, r->begin);
73       if (end == 0)
74         claimed_end = r->end;
75       else
76         claimed_end = min (end, r->end);
77
78       if (claimed_begin == r->begin && claimed_end == r->end)
79         VEC_safe_push (memory_write_request_s, *result, r);
80       else
81         {
82           struct memory_write_request *n =
83             VEC_safe_push (memory_write_request_s, *result, NULL);
84
85           *n = *r;
86           n->begin = claimed_begin;
87           n->end = claimed_end;
88           n->data += claimed_begin - r->begin;
89         }
90     }
91 }
92
93 /* Given a vector of struct memory_write_request objects in BLOCKS,
94    add memory requests for flash memory into FLASH_BLOCKS, and for
95    regular memory to REGULAR_BLOCKS.  */
96
97 static void
98 split_regular_and_flash_blocks (VEC(memory_write_request_s) *blocks,
99                                 VEC(memory_write_request_s) **regular_blocks,
100                                 VEC(memory_write_request_s) **flash_blocks)
101 {
102   struct mem_region *region;
103   CORE_ADDR cur_address;
104
105   /* This implementation runs in O(length(regions)*length(blocks)) time.
106      However, in most cases the number of blocks will be small, so this does
107      not matter.
108
109      Note also that it's extremely unlikely that a memory write request
110      will span more than one memory region, however for safety we handle
111      such situations.  */
112
113   cur_address = 0;
114   while (1)
115     {
116       VEC(memory_write_request_s) **r;
117
118       region = lookup_mem_region (cur_address);
119       r = region->attrib.mode == MEM_FLASH ? flash_blocks : regular_blocks;
120       cur_address = region->hi;
121       claim_memory (blocks, r, region->lo, region->hi);
122
123       if (cur_address == 0)
124         break;
125     }
126 }
127
128 /* Given an ADDRESS, if BEGIN is non-NULL this function sets *BEGIN
129    to the start of the flash block containing the address.  Similarly,
130    if END is non-NULL *END will be set to the address one past the end
131    of the block containing the address.  */
132
133 static void
134 block_boundaries (CORE_ADDR address, CORE_ADDR *begin, CORE_ADDR *end)
135 {
136   struct mem_region *region;
137   unsigned blocksize;
138
139   region = lookup_mem_region (address);
140   gdb_assert (region->attrib.mode == MEM_FLASH);
141   blocksize = region->attrib.blocksize;
142   if (begin)
143     *begin = address / blocksize * blocksize;
144   if (end)
145     *end = (address + blocksize - 1) / blocksize * blocksize;
146 }
147
148 /* Given the list of memory requests to be WRITTEN, this function
149    returns write requests covering each group of flash blocks which must
150    be erased.  */
151
152 static VEC(memory_write_request_s) *
153 blocks_to_erase (VEC(memory_write_request_s) *written)
154 {
155   unsigned i;
156   struct memory_write_request *ptr;
157
158   VEC(memory_write_request_s) *result = NULL;
159
160   for (i = 0; VEC_iterate (memory_write_request_s, written, i, ptr); ++i)
161     {
162       CORE_ADDR begin, end;
163
164       block_boundaries (ptr->begin, &begin, 0);
165       block_boundaries (ptr->end - 1, 0, &end);
166
167       if (!VEC_empty (memory_write_request_s, result)
168           && VEC_last (memory_write_request_s, result)->end >= begin)
169         {
170           VEC_last (memory_write_request_s, result)->end = end;
171         }
172       else
173         {
174           struct memory_write_request *n =
175             VEC_safe_push (memory_write_request_s, result, NULL);
176
177           memset (n, 0, sizeof (struct memory_write_request));
178           n->begin = begin;
179           n->end = end;
180         }
181     }
182
183   return result;
184 }
185
186 /* Given ERASED_BLOCKS, a list of blocks that will be erased with
187    flash erase commands, and WRITTEN_BLOCKS, the list of memory
188    addresses that will be written, compute the set of memory addresses
189    that will be erased but not rewritten (e.g. padding within a block
190    which is only partially filled by "load").  */
191
192 static VEC(memory_write_request_s) *
193 compute_garbled_blocks (VEC(memory_write_request_s) *erased_blocks,
194                         VEC(memory_write_request_s) *written_blocks)
195 {
196   VEC(memory_write_request_s) *result = NULL;
197
198   unsigned i, j;
199   unsigned je = VEC_length (memory_write_request_s, written_blocks);
200   struct memory_write_request *erased_p;
201
202   /* Look at each erased memory_write_request in turn, and
203      see what part of it is subsequently written to.
204
205      This implementation is O(length(erased) * length(written)).  If
206      the lists are sorted at this point it could be rewritten more
207      efficiently, but the complexity is not generally worthwhile.  */
208
209   for (i = 0;
210        VEC_iterate (memory_write_request_s, erased_blocks, i, erased_p);
211        ++i)
212     {
213       /* Make a deep copy -- it will be modified inside the loop, but
214          we don't want to modify original vector.  */
215       struct memory_write_request erased = *erased_p;
216
217       for (j = 0; j != je;)
218         {
219           struct memory_write_request *written
220             = VEC_index (memory_write_request_s,
221                          written_blocks, j);
222
223           /* Now try various cases.  */
224
225           /* If WRITTEN is fully to the left of ERASED, check the next
226              written memory_write_request.  */
227           if (written->end <= erased.begin)
228             {
229               ++j;
230               continue;
231             }
232
233           /* If WRITTEN is fully to the right of ERASED, then ERASED
234              is not written at all.  WRITTEN might affect other
235              blocks.  */
236           if (written->begin >= erased.end)
237             {
238               VEC_safe_push (memory_write_request_s, result, &erased);
239               goto next_erased;
240             }
241
242           /* If all of ERASED is completely written, we can move on to
243              the next erased region.  */
244           if (written->begin <= erased.begin
245               && written->end >= erased.end)
246             {
247               goto next_erased;
248             }
249
250           /* If there is an unwritten part at the beginning of ERASED,
251              then we should record that part and try this inner loop
252              again for the remainder.  */
253           if (written->begin > erased.begin)
254             {
255               struct memory_write_request *n =
256                 VEC_safe_push (memory_write_request_s, result, NULL);
257
258               memset (n, 0, sizeof (struct memory_write_request));
259               n->begin = erased.begin;
260               n->end = written->begin;
261               erased.begin = written->begin;
262               continue;
263             }
264
265           /* If there is an unwritten part at the end of ERASED, we
266              forget about the part that was written to and wait to see
267              if the next write request writes more of ERASED.  We can't
268              push it yet.  */
269           if (written->end < erased.end)
270             {
271               erased.begin = written->end;
272               ++j;
273               continue;
274             }
275         }
276
277       /* If we ran out of write requests without doing anything about
278          ERASED, then that means it's really erased.  */
279       VEC_safe_push (memory_write_request_s, result, &erased);
280
281     next_erased:
282       ;
283     }
284
285   return result;
286 }
287
288 static void
289 cleanup_request_data (void *p)
290 {
291   VEC(memory_write_request_s) **v = p;
292   struct memory_write_request *r;
293   int i;
294
295   for (i = 0; VEC_iterate (memory_write_request_s, *v, i, r); ++i)
296     xfree (r->data);
297 }
298
299 static void
300 cleanup_write_requests_vector (void *p)
301 {
302   VEC(memory_write_request_s) **v = p;
303
304   VEC_free (memory_write_request_s, *v);
305 }
306
307 int
308 target_write_memory_blocks (VEC(memory_write_request_s) *requests,
309                             enum flash_preserve_mode preserve_flash_p,
310                             void (*progress_cb) (ULONGEST, void *))
311 {
312   struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
313   VEC(memory_write_request_s) *blocks = VEC_copy (memory_write_request_s,
314                                                   requests);
315   unsigned i;
316   int err = 0;
317   struct memory_write_request *r;
318   VEC(memory_write_request_s) *regular = NULL;
319   VEC(memory_write_request_s) *flash = NULL;
320   VEC(memory_write_request_s) *erased, *garbled;
321
322   /* END == 0 would represent wraparound: a write to the very last
323      byte of the address space.  This file was not written with that
324      possibility in mind.  This is fixable, but a lot of work for a
325      rare problem; so for now, fail noisily here instead of obscurely
326      later.  */
327   for (i = 0; VEC_iterate (memory_write_request_s, requests, i, r); ++i)
328     gdb_assert (r->end != 0);
329
330   make_cleanup (cleanup_write_requests_vector, &blocks);
331
332   /* Sort the blocks by their start address.  */
333   qsort (VEC_address (memory_write_request_s, blocks),
334          VEC_length (memory_write_request_s, blocks),
335          sizeof (struct memory_write_request), compare_block_starting_address);
336
337   /* Split blocks into list of regular memory blocks,
338      and list of flash memory blocks.  */
339   make_cleanup (cleanup_write_requests_vector, &regular);
340   make_cleanup (cleanup_write_requests_vector, &flash);
341   split_regular_and_flash_blocks (blocks, &regular, &flash);
342
343   /* If a variable is added to forbid flash write, even during "load",
344      it should be checked here.  Similarly, if this function is used
345      for other situations besides "load" in which writing to flash
346      is undesirable, that should be checked here.  */
347
348   /* Find flash blocks to erase.  */
349   erased = blocks_to_erase (flash);
350   make_cleanup (cleanup_write_requests_vector, &erased);
351
352   /* Find what flash regions will be erased, and not overwritten; then
353      either preserve or discard the old contents.  */
354   garbled = compute_garbled_blocks (erased, flash);
355   make_cleanup (cleanup_request_data, &garbled);
356   make_cleanup (cleanup_write_requests_vector, &garbled);
357
358   if (!VEC_empty (memory_write_request_s, garbled))
359     {
360       if (preserve_flash_p == flash_preserve)
361         {
362           struct memory_write_request *r;
363
364           /* Read in regions that must be preserved and add them to
365              the list of blocks we read.  */
366           for (i = 0; VEC_iterate (memory_write_request_s, garbled, i, r); ++i)
367             {
368               gdb_assert (r->data == NULL);
369               r->data = xmalloc (r->end - r->begin);
370               err = target_read_memory (r->begin, r->data, r->end - r->begin);
371               if (err != 0)
372                 goto out;
373
374               VEC_safe_push (memory_write_request_s, flash, r);
375             }
376
377           qsort (VEC_address (memory_write_request_s, flash),
378                  VEC_length (memory_write_request_s, flash),
379                  sizeof (struct memory_write_request),
380                  compare_block_starting_address);
381         }
382     }
383
384   /* We could coalesce adjacent memory blocks here, to reduce the
385      number of write requests for small sections.  However, we would
386      have to reallocate and copy the data pointers, which could be
387      large; large sections are more common in loadable objects than
388      large numbers of small sections (although the reverse can be true
389      in object files).  So, we issue at least one write request per
390      passed struct memory_write_request.  The remote stub will still
391      have the opportunity to batch flash requests.  */
392
393   /* Write regular blocks.  */
394   for (i = 0; VEC_iterate (memory_write_request_s, regular, i, r); ++i)
395     {
396       LONGEST len;
397
398       len = target_write_with_progress (current_target.beneath,
399                                         TARGET_OBJECT_MEMORY, NULL,
400                                         r->data, r->begin, r->end - r->begin,
401                                         progress_cb, r->baton);
402       if (len < (LONGEST) (r->end - r->begin))
403         {
404           /* Call error?  */
405           err = -1;
406           goto out;
407         }
408     }
409
410   if (!VEC_empty (memory_write_request_s, erased))
411     {
412       /* Erase all pages.  */
413       for (i = 0; VEC_iterate (memory_write_request_s, erased, i, r); ++i)
414         target_flash_erase (r->begin, r->end - r->begin);
415
416       /* Write flash data.  */
417       for (i = 0; VEC_iterate (memory_write_request_s, flash, i, r); ++i)
418         {
419           LONGEST len;
420
421           len = target_write_with_progress (&current_target,
422                                             TARGET_OBJECT_FLASH, NULL,
423                                             r->data, r->begin,
424                                             r->end - r->begin,
425                                             progress_cb, r->baton);
426           if (len < (LONGEST) (r->end - r->begin))
427             error (_("Error writing data to flash"));
428         }
429
430       target_flash_done ();
431     }
432
433  out:
434   do_cleanups (back_to);
435
436   return err;
437 }