Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / memattr.c
1 /* Memory attributes support, for GDB.
2
3    Copyright (C) 2001-2013 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 "defs.h"
21 #include "command.h"
22 #include "gdbcmd.h"
23 #include "memattr.h"
24 #include "target.h"
25 #include "value.h"
26 #include "language.h"
27 #include "vec.h"
28 #include "gdb_string.h"
29 #include "breakpoint.h"
30 #include "cli/cli-utils.h"
31
32 const struct mem_attrib default_mem_attrib =
33 {
34   MEM_RW,                       /* mode */
35   MEM_WIDTH_UNSPECIFIED,
36   0,                            /* hwbreak */
37   0,                            /* cache */
38   0,                            /* verify */
39   -1 /* Flash blocksize not specified.  */
40 };
41
42 const struct mem_attrib unknown_mem_attrib =
43 {
44   MEM_NONE,                     /* mode */
45   MEM_WIDTH_UNSPECIFIED,
46   0,                            /* hwbreak */
47   0,                            /* cache */
48   0,                            /* verify */
49   -1 /* Flash blocksize not specified.  */
50 };
51
52
53 VEC(mem_region_s) *mem_region_list, *target_mem_region_list;
54 static int mem_number = 0;
55
56 /* If this flag is set, the memory region list should be automatically
57    updated from the target.  If it is clear, the list is user-controlled
58    and should be left alone.  */
59 static int mem_use_target = 1;
60
61 /* If this flag is set, we have tried to fetch the target memory regions
62    since the last time it was invalidated.  If that list is still
63    empty, then the target can't supply memory regions.  */
64 static int target_mem_regions_valid;
65
66 /* If this flag is set, gdb will assume that memory ranges not
67    specified by the memory map have type MEM_NONE, and will
68    emit errors on all accesses to that memory.  */
69 static int inaccessible_by_default = 1;
70
71 static void
72 show_inaccessible_by_default (struct ui_file *file, int from_tty,
73                               struct cmd_list_element *c,
74                               const char *value)
75 {
76   if (inaccessible_by_default)
77     fprintf_filtered (file, _("Unknown memory addresses will "
78                               "be treated as inaccessible.\n"));
79   else
80     fprintf_filtered (file, _("Unknown memory addresses "
81                               "will be treated as RAM.\n"));          
82 }
83
84
85 /* Predicate function which returns true if LHS should sort before RHS
86    in a list of memory regions, useful for VEC_lower_bound.  */
87
88 static int
89 mem_region_lessthan (const struct mem_region *lhs,
90                      const struct mem_region *rhs)
91 {
92   return lhs->lo < rhs->lo;
93 }
94
95 /* A helper function suitable for qsort, used to sort a
96    VEC(mem_region_s) by starting address.  */
97
98 int
99 mem_region_cmp (const void *untyped_lhs, const void *untyped_rhs)
100 {
101   const struct mem_region *lhs = untyped_lhs;
102   const struct mem_region *rhs = untyped_rhs;
103
104   if (lhs->lo < rhs->lo)
105     return -1;
106   else if (lhs->lo == rhs->lo)
107     return 0;
108   else
109     return 1;
110 }
111
112 /* Allocate a new memory region, with default settings.  */
113
114 void
115 mem_region_init (struct mem_region *new)
116 {
117   memset (new, 0, sizeof (struct mem_region));
118   new->enabled_p = 1;
119   new->attrib = default_mem_attrib;
120 }
121
122 /* This function should be called before any command which would
123    modify the memory region list.  It will handle switching from
124    a target-provided list to a local list, if necessary.  */
125
126 static void
127 require_user_regions (int from_tty)
128 {
129   struct mem_region *m;
130   int ix, length;
131
132   /* If we're already using a user-provided list, nothing to do.  */
133   if (!mem_use_target)
134     return;
135
136   /* Switch to a user-provided list (possibly a copy of the current
137      one).  */
138   mem_use_target = 0;
139
140   /* If we don't have a target-provided region list yet, then
141      no need to warn.  */
142   if (mem_region_list == NULL)
143     return;
144
145   /* Otherwise, let the user know how to get back.  */
146   if (from_tty)
147     warning (_("Switching to manual control of memory regions; use "
148                "\"mem auto\" to fetch regions from the target again."));
149
150   /* And create a new list for the user to modify.  */
151   length = VEC_length (mem_region_s, target_mem_region_list);
152   mem_region_list = VEC_alloc (mem_region_s, length);
153   for (ix = 0; VEC_iterate (mem_region_s, target_mem_region_list, ix, m); ix++)
154     VEC_quick_push (mem_region_s, mem_region_list, m);
155 }
156
157 /* This function should be called before any command which would
158    read the memory region list, other than those which call
159    require_user_regions.  It will handle fetching the
160    target-provided list, if necessary.  */
161
162 static void
163 require_target_regions (void)
164 {
165   if (mem_use_target && !target_mem_regions_valid)
166     {
167       target_mem_regions_valid = 1;
168       target_mem_region_list = target_memory_map ();
169       mem_region_list = target_mem_region_list;
170     }
171 }
172
173 static void
174 create_mem_region (CORE_ADDR lo, CORE_ADDR hi,
175                    const struct mem_attrib *attrib)
176 {
177   struct mem_region new;
178   int i, ix;
179
180   /* lo == hi is a useless empty region.  */
181   if (lo >= hi && hi != 0)
182     {
183       printf_unfiltered (_("invalid memory region: low >= high\n"));
184       return;
185     }
186
187   mem_region_init (&new);
188   new.lo = lo;
189   new.hi = hi;
190
191   ix = VEC_lower_bound (mem_region_s, mem_region_list, &new,
192                         mem_region_lessthan);
193
194   /* Check for an overlapping memory region.  We only need to check
195      in the vicinity - at most one before and one after the
196      insertion point.  */
197   for (i = ix - 1; i < ix + 1; i++)
198     {
199       struct mem_region *n;
200
201       if (i < 0)
202         continue;
203       if (i >= VEC_length (mem_region_s, mem_region_list))
204         continue;
205
206       n = VEC_index (mem_region_s, mem_region_list, i);
207
208       if ((lo >= n->lo && (lo < n->hi || n->hi == 0)) 
209           || (hi > n->lo && (hi <= n->hi || n->hi == 0))
210           || (lo <= n->lo && ((hi >= n->hi && n->hi != 0) || hi == 0)))
211         {
212           printf_unfiltered (_("overlapping memory region\n"));
213           return;
214         }
215     }
216
217   new.number = ++mem_number;
218   new.attrib = *attrib;
219   VEC_safe_insert (mem_region_s, mem_region_list, ix, &new);
220 }
221
222 /*
223  * Look up the memory region cooresponding to ADDR.
224  */
225 struct mem_region *
226 lookup_mem_region (CORE_ADDR addr)
227 {
228   static struct mem_region region;
229   struct mem_region *m;
230   CORE_ADDR lo;
231   CORE_ADDR hi;
232   int ix;
233
234   require_target_regions ();
235
236   /* First we initialize LO and HI so that they describe the entire
237      memory space.  As we process the memory region chain, they are
238      redefined to describe the minimal region containing ADDR.  LO
239      and HI are used in the case where no memory region is defined
240      that contains ADDR.  If a memory region is disabled, it is
241      treated as if it does not exist.  The initial values for LO
242      and HI represent the bottom and top of memory.  */
243
244   lo = 0;
245   hi = 0;
246
247   /* Either find memory range containing ADDRESS, or set LO and HI
248      to the nearest boundaries of an existing memory range.
249      
250      If we ever want to support a huge list of memory regions, this
251      check should be replaced with a binary search (probably using
252      VEC_lower_bound).  */
253   for (ix = 0; VEC_iterate (mem_region_s, mem_region_list, ix, m); ix++)
254     {
255       if (m->enabled_p == 1)
256         {
257           /* If the address is in the memory region, return that
258              memory range.  */
259           if (addr >= m->lo && (addr < m->hi || m->hi == 0))
260             return m;
261
262           /* This (correctly) won't match if m->hi == 0, representing
263              the top of the address space, because CORE_ADDR is unsigned;
264              no value of LO is less than zero.  */
265           if (addr >= m->hi && lo < m->hi)
266             lo = m->hi;
267
268           /* This will never set HI to zero; if we're here and ADDR
269              is at or below M, and the region starts at zero, then ADDR
270              would have been in the region.  */
271           if (addr <= m->lo && (hi == 0 || hi > m->lo))
272             hi = m->lo;
273         }
274     }
275
276   /* Because no region was found, we must cons up one based on what
277      was learned above.  */
278   region.lo = lo;
279   region.hi = hi;
280
281   /* When no memory map is defined at all, we always return 
282      'default_mem_attrib', so that we do not make all memory 
283      inaccessible for targets that don't provide a memory map.  */
284   if (inaccessible_by_default && !VEC_empty (mem_region_s, mem_region_list))
285     region.attrib = unknown_mem_attrib;
286   else
287     region.attrib = default_mem_attrib;
288
289   return &region;
290 }
291
292 /* Invalidate any memory regions fetched from the target.  */
293
294 void
295 invalidate_target_mem_regions (void)
296 {
297   if (!target_mem_regions_valid)
298     return;
299
300   target_mem_regions_valid = 0;
301   VEC_free (mem_region_s, target_mem_region_list);
302   if (mem_use_target)
303     mem_region_list = NULL;
304 }
305
306 /* Clear memory region list.  */
307
308 static void
309 mem_clear (void)
310 {
311   VEC_free (mem_region_s, mem_region_list);
312 }
313 \f
314
315 static void
316 mem_command (char *args, int from_tty)
317 {
318   CORE_ADDR lo, hi;
319   char *tok;
320   struct mem_attrib attrib;
321
322   if (!args)
323     error_no_arg (_("No mem"));
324
325   /* For "mem auto", switch back to using a target provided list.  */
326   if (strcmp (args, "auto") == 0)
327     {
328       if (mem_use_target)
329         return;
330
331       if (mem_region_list != target_mem_region_list)
332         {
333           mem_clear ();
334           mem_region_list = target_mem_region_list;
335         }
336
337       mem_use_target = 1;
338       return;
339     }
340
341   require_user_regions (from_tty);
342
343   tok = strtok (args, " \t");
344   if (!tok)
345     error (_("no lo address"));
346   lo = parse_and_eval_address (tok);
347
348   tok = strtok (NULL, " \t");
349   if (!tok)
350     error (_("no hi address"));
351   hi = parse_and_eval_address (tok);
352
353   attrib = default_mem_attrib;
354   while ((tok = strtok (NULL, " \t")) != NULL)
355     {
356       if (strcmp (tok, "rw") == 0)
357         attrib.mode = MEM_RW;
358       else if (strcmp (tok, "ro") == 0)
359         attrib.mode = MEM_RO;
360       else if (strcmp (tok, "wo") == 0)
361         attrib.mode = MEM_WO;
362
363       else if (strcmp (tok, "8") == 0)
364         attrib.width = MEM_WIDTH_8;
365       else if (strcmp (tok, "16") == 0)
366         {
367           if ((lo % 2 != 0) || (hi % 2 != 0))
368             error (_("region bounds not 16 bit aligned"));
369           attrib.width = MEM_WIDTH_16;
370         }
371       else if (strcmp (tok, "32") == 0)
372         {
373           if ((lo % 4 != 0) || (hi % 4 != 0))
374             error (_("region bounds not 32 bit aligned"));
375           attrib.width = MEM_WIDTH_32;
376         }
377       else if (strcmp (tok, "64") == 0)
378         {
379           if ((lo % 8 != 0) || (hi % 8 != 0))
380             error (_("region bounds not 64 bit aligned"));
381           attrib.width = MEM_WIDTH_64;
382         }
383
384 #if 0
385       else if (strcmp (tok, "hwbreak") == 0)
386         attrib.hwbreak = 1;
387       else if (strcmp (tok, "swbreak") == 0)
388         attrib.hwbreak = 0;
389 #endif
390
391       else if (strcmp (tok, "cache") == 0)
392         attrib.cache = 1;
393       else if (strcmp (tok, "nocache") == 0)
394         attrib.cache = 0;
395
396 #if 0
397       else if (strcmp (tok, "verify") == 0)
398         attrib.verify = 1;
399       else if (strcmp (tok, "noverify") == 0)
400         attrib.verify = 0;
401 #endif
402
403       else
404         error (_("unknown attribute: %s"), tok);
405     }
406
407   create_mem_region (lo, hi, &attrib);
408 }
409 \f
410
411 static void
412 mem_info_command (char *args, int from_tty)
413 {
414   struct mem_region *m;
415   struct mem_attrib *attrib;
416   int ix;
417
418   if (mem_use_target)
419     printf_filtered (_("Using memory regions provided by the target.\n"));
420   else
421     printf_filtered (_("Using user-defined memory regions.\n"));
422
423   require_target_regions ();
424
425   if (!mem_region_list)
426     {
427       printf_unfiltered (_("There are no memory regions defined.\n"));
428       return;
429     }
430
431   printf_filtered ("Num ");
432   printf_filtered ("Enb ");
433   printf_filtered ("Low Addr   ");
434   if (gdbarch_addr_bit (target_gdbarch ()) > 32)
435     printf_filtered ("        ");
436   printf_filtered ("High Addr  ");
437   if (gdbarch_addr_bit (target_gdbarch ()) > 32)
438     printf_filtered ("        ");
439   printf_filtered ("Attrs ");
440   printf_filtered ("\n");
441
442   for (ix = 0; VEC_iterate (mem_region_s, mem_region_list, ix, m); ix++)
443     {
444       char *tmp;
445
446       printf_filtered ("%-3d %-3c\t",
447                        m->number,
448                        m->enabled_p ? 'y' : 'n');
449       if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
450         tmp = hex_string_custom ((unsigned long) m->lo, 8);
451       else
452         tmp = hex_string_custom ((unsigned long) m->lo, 16);
453       
454       printf_filtered ("%s ", tmp);
455
456       if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
457         {
458           if (m->hi == 0)
459             tmp = "0x100000000";
460           else
461             tmp = hex_string_custom ((unsigned long) m->hi, 8);
462         }
463       else
464         {
465           if (m->hi == 0)
466             tmp = "0x10000000000000000";
467           else
468             tmp = hex_string_custom ((unsigned long) m->hi, 16);
469         }
470
471       printf_filtered ("%s ", tmp);
472
473       /* Print a token for each attribute.
474
475        * FIXME: Should we output a comma after each token?  It may
476        * make it easier for users to read, but we'd lose the ability
477        * to cut-and-paste the list of attributes when defining a new
478        * region.  Perhaps that is not important.
479        *
480        * FIXME: If more attributes are added to GDB, the output may
481        * become cluttered and difficult for users to read.  At that
482        * time, we may want to consider printing tokens only if they
483        * are different from the default attribute.  */
484
485       attrib = &m->attrib;
486       switch (attrib->mode)
487         {
488         case MEM_RW:
489           printf_filtered ("rw ");
490           break;
491         case MEM_RO:
492           printf_filtered ("ro ");
493           break;
494         case MEM_WO:
495           printf_filtered ("wo ");
496           break;
497         case MEM_FLASH:
498           printf_filtered ("flash blocksize 0x%x ", attrib->blocksize);
499           break;
500         }
501
502       switch (attrib->width)
503         {
504         case MEM_WIDTH_8:
505           printf_filtered ("8 ");
506           break;
507         case MEM_WIDTH_16:
508           printf_filtered ("16 ");
509           break;
510         case MEM_WIDTH_32:
511           printf_filtered ("32 ");
512           break;
513         case MEM_WIDTH_64:
514           printf_filtered ("64 ");
515           break;
516         case MEM_WIDTH_UNSPECIFIED:
517           break;
518         }
519
520 #if 0
521       if (attrib->hwbreak)
522         printf_filtered ("hwbreak");
523       else
524         printf_filtered ("swbreak");
525 #endif
526
527       if (attrib->cache)
528         printf_filtered ("cache ");
529       else
530         printf_filtered ("nocache ");
531
532 #if 0
533       if (attrib->verify)
534         printf_filtered ("verify ");
535       else
536         printf_filtered ("noverify ");
537 #endif
538
539       printf_filtered ("\n");
540
541       gdb_flush (gdb_stdout);
542     }
543 }
544 \f
545
546 /* Enable the memory region number NUM.  */
547
548 static void
549 mem_enable (int num)
550 {
551   struct mem_region *m;
552   int ix;
553
554   for (ix = 0; VEC_iterate (mem_region_s, mem_region_list, ix, m); ix++)
555     if (m->number == num)
556       {
557         m->enabled_p = 1;
558         return;
559       }
560   printf_unfiltered (_("No memory region number %d.\n"), num);
561 }
562
563 static void
564 mem_enable_command (char *args, int from_tty)
565 {
566   int num;
567   struct mem_region *m;
568   int ix;
569
570   require_user_regions (from_tty);
571
572   target_dcache_invalidate ();
573
574   if (args == NULL || *args == '\0')
575     { /* Enable all mem regions.  */
576       for (ix = 0; VEC_iterate (mem_region_s, mem_region_list, ix, m); ix++)
577         m->enabled_p = 1;
578     }
579   else
580     {
581       struct get_number_or_range_state state;
582
583       init_number_or_range (&state, args);
584       while (!state.finished)
585         {
586           num = get_number_or_range (&state);
587           mem_enable (num);
588         }
589     }
590 }
591 \f
592
593 /* Disable the memory region number NUM.  */
594
595 static void
596 mem_disable (int num)
597 {
598   struct mem_region *m;
599   int ix;
600
601   for (ix = 0; VEC_iterate (mem_region_s, mem_region_list, ix, m); ix++)
602     if (m->number == num)
603       {
604         m->enabled_p = 0;
605         return;
606       }
607   printf_unfiltered (_("No memory region number %d.\n"), num);
608 }
609
610 static void
611 mem_disable_command (char *args, int from_tty)
612 {
613   int num;
614   struct mem_region *m;
615   int ix;
616
617   require_user_regions (from_tty);
618
619   target_dcache_invalidate ();
620
621   if (args == NULL || *args == '\0')
622     {
623       for (ix = 0; VEC_iterate (mem_region_s, mem_region_list, ix, m); ix++)
624         m->enabled_p = 0;
625     }
626   else
627     {
628       struct get_number_or_range_state state;
629
630       init_number_or_range (&state, args);
631       while (!state.finished)
632         {
633           num = get_number_or_range (&state);
634           mem_disable (num);
635         }
636     }
637 }
638
639 /* Delete the memory region number NUM.  */
640
641 static void
642 mem_delete (int num)
643 {
644   struct mem_region *m;
645   int ix;
646
647   if (!mem_region_list)
648     {
649       printf_unfiltered (_("No memory region number %d.\n"), num);
650       return;
651     }
652
653   for (ix = 0; VEC_iterate (mem_region_s, mem_region_list, ix, m); ix++)
654     if (m->number == num)
655       break;
656
657   if (m == NULL)
658     {
659       printf_unfiltered (_("No memory region number %d.\n"), num);
660       return;
661     }
662
663   VEC_ordered_remove (mem_region_s, mem_region_list, ix);
664 }
665
666 static void
667 mem_delete_command (char *args, int from_tty)
668 {
669   int num;
670   struct get_number_or_range_state state;
671
672   require_user_regions (from_tty);
673
674   target_dcache_invalidate ();
675
676   if (args == NULL || *args == '\0')
677     {
678       if (query (_("Delete all memory regions? ")))
679         mem_clear ();
680       dont_repeat ();
681       return;
682     }
683
684   init_number_or_range (&state, args);
685   while (!state.finished)
686     {
687       num = get_number_or_range (&state);
688       mem_delete (num);
689     }
690
691   dont_repeat ();
692 }
693
694 static void
695 dummy_cmd (char *args, int from_tty)
696 {
697 }
698 \f
699 extern initialize_file_ftype _initialize_mem; /* -Wmissing-prototype */
700
701 static struct cmd_list_element *mem_set_cmdlist;
702 static struct cmd_list_element *mem_show_cmdlist;
703
704 void
705 _initialize_mem (void)
706 {
707   add_com ("mem", class_vars, mem_command, _("\
708 Define attributes for memory region or reset memory region handling to\n\
709 target-based.\n\
710 Usage: mem auto\n\
711        mem <lo addr> <hi addr> [<mode> <width> <cache>],\n\
712 where <mode>  may be rw (read/write), ro (read-only) or wo (write-only),\n\
713       <width> may be 8, 16, 32, or 64, and\n\
714       <cache> may be cache or nocache"));
715
716   add_cmd ("mem", class_vars, mem_enable_command, _("\
717 Enable memory region.\n\
718 Arguments are the code numbers of the memory regions to enable.\n\
719 Usage: enable mem <code number>...\n\
720 Do \"info mem\" to see current list of code numbers."), &enablelist);
721
722   add_cmd ("mem", class_vars, mem_disable_command, _("\
723 Disable memory region.\n\
724 Arguments are the code numbers of the memory regions to disable.\n\
725 Usage: disable mem <code number>...\n\
726 Do \"info mem\" to see current list of code numbers."), &disablelist);
727
728   add_cmd ("mem", class_vars, mem_delete_command, _("\
729 Delete memory region.\n\
730 Arguments are the code numbers of the memory regions to delete.\n\
731 Usage: delete mem <code number>...\n\
732 Do \"info mem\" to see current list of code numbers."), &deletelist);
733
734   add_info ("mem", mem_info_command,
735             _("Memory region attributes"));
736
737   add_prefix_cmd ("mem", class_vars, dummy_cmd, _("\
738 Memory regions settings"),
739                   &mem_set_cmdlist, "set mem ",
740                   0/* allow-unknown */, &setlist);
741   add_prefix_cmd ("mem", class_vars, dummy_cmd, _("\
742 Memory regions settings"),
743                   &mem_show_cmdlist, "show mem  ",
744                   0/* allow-unknown */, &showlist);
745
746   add_setshow_boolean_cmd ("inaccessible-by-default", no_class,
747                                   &inaccessible_by_default, _("\
748 Set handling of unknown memory regions."), _("\
749 Show handling of unknown memory regions."), _("\
750 If on, and some memory map is defined, debugger will emit errors on\n\
751 accesses to memory not defined in the memory map. If off, accesses to all\n\
752 memory addresses will be allowed."),
753                                 NULL,
754                                 show_inaccessible_by_default,
755                                 &mem_set_cmdlist,
756                                 &mem_show_cmdlist);
757 }