/* Memory attributes support, for GDB.
- Copyright (C) 2001, 2002 Free Software Foundation, Inc.
+ Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006
+ Free Software Foundation, Inc.
This file is part of GDB.
#include "target.h"
#include "value.h"
#include "language.h"
+#include "vec.h"
#include "gdb_string.h"
const struct mem_attrib default_mem_attrib =
MEM_WIDTH_UNSPECIFIED,
0, /* hwbreak */
0, /* cache */
- 0 /* verify */
+ 0, /* verify */
+ -1 /* Flash blocksize not specified. */
};
-static struct mem_region *mem_region_chain = NULL;
+VEC(mem_region_s) *mem_region_list, *target_mem_region_list;
static int mem_number = 0;
-static struct mem_region *
+/* If this flag is set, the memory region list should be automatically
+ updated from the target. If it is clear, the list is user-controlled
+ and should be left alone. */
+static int mem_use_target = 1;
+
+/* If this flag is set, we have tried to fetch the target memory regions
+ since the last time it was invalidated. If that list is still
+ empty, then the target can't supply memory regions. */
+static int target_mem_regions_valid;
+
+/* Predicate function which returns true if LHS should sort before RHS
+ in a list of memory regions, useful for VEC_lower_bound. */
+
+static int
+mem_region_lessthan (const struct mem_region *lhs,
+ const struct mem_region *rhs)
+{
+ return lhs->lo < rhs->lo;
+}
+
+/* A helper function suitable for qsort, used to sort a
+ VEC(mem_region_s) by starting address. */
+
+int
+mem_region_cmp (const void *untyped_lhs, const void *untyped_rhs)
+{
+ const struct mem_region *lhs = untyped_lhs;
+ const struct mem_region *rhs = untyped_rhs;
+
+ if (lhs->lo < rhs->lo)
+ return -1;
+ else if (lhs->lo == rhs->lo)
+ return 0;
+ else
+ return 1;
+}
+
+/* Allocate a new memory region, with default settings. */
+
+void
+mem_region_init (struct mem_region *new)
+{
+ memset (new, 0, sizeof (struct mem_region));
+ new->enabled_p = 1;
+ new->attrib = default_mem_attrib;
+}
+
+/* This function should be called before any command which would
+ modify the memory region list. It will handle switching from
+ a target-provided list to a local list, if necessary. */
+
+static void
+require_user_regions (int from_tty)
+{
+ struct mem_region *m;
+ int ix, length;
+
+ /* If we're already using a user-provided list, nothing to do. */
+ if (!mem_use_target)
+ return;
+
+ /* Switch to a user-provided list (possibly a copy of the current
+ one). */
+ mem_use_target = 0;
+
+ /* If we don't have a target-provided region list yet, then
+ no need to warn. */
+ if (mem_region_list == NULL)
+ return;
+
+ /* Otherwise, let the user know how to get back. */
+ if (from_tty)
+ warning (_("Switching to manual control of memory regions; use "
+ "\"mem auto\" to fetch regions from the target again."));
+
+ /* And create a new list for the user to modify. */
+ length = VEC_length (mem_region_s, target_mem_region_list);
+ mem_region_list = VEC_alloc (mem_region_s, length);
+ for (ix = 0; VEC_iterate (mem_region_s, target_mem_region_list, ix, m); ix++)
+ VEC_quick_push (mem_region_s, mem_region_list, m);
+}
+
+/* This function should be called before any command which would
+ read the memory region list, other than those which call
+ require_user_regions. It will handle fetching the
+ target-provided list, if necessary. */
+
+static void
+require_target_regions (void)
+{
+ if (mem_use_target && !target_mem_regions_valid)
+ {
+ target_mem_regions_valid = 1;
+ target_mem_region_list = target_memory_map ();
+ mem_region_list = target_mem_region_list;
+ }
+}
+
+static void
create_mem_region (CORE_ADDR lo, CORE_ADDR hi,
const struct mem_attrib *attrib)
{
- struct mem_region *n, *new;
+ struct mem_region new;
+ int i, ix;
/* lo == hi is a useless empty region */
if (lo >= hi && hi != 0)
{
printf_unfiltered (_("invalid memory region: low >= high\n"));
- return NULL;
+ return;
}
- n = mem_region_chain;
- while (n)
+ mem_region_init (&new);
+ new.lo = lo;
+ new.hi = hi;
+
+ ix = VEC_lower_bound (mem_region_s, mem_region_list, &new,
+ mem_region_lessthan);
+
+ /* Check for an overlapping memory region. We only need to check
+ in the vicinity - at most one before and one after the
+ insertion point. */
+ for (i = ix - 1; i < ix + 1; i++)
{
- /* overlapping node */
+ struct mem_region *n;
+
+ if (i < 0)
+ continue;
+ if (i >= VEC_length (mem_region_s, mem_region_list))
+ continue;
+
+ n = VEC_index (mem_region_s, mem_region_list, i);
+
if ((lo >= n->lo && (lo < n->hi || n->hi == 0))
|| (hi > n->lo && (hi <= n->hi || n->hi == 0))
|| (lo <= n->lo && (hi >= n->hi || hi == 0)))
{
printf_unfiltered (_("overlapping memory region\n"));
- return NULL;
+ return;
}
- n = n->next;
}
- new = xmalloc (sizeof (struct mem_region));
- new->lo = lo;
- new->hi = hi;
- new->number = ++mem_number;
- new->enabled_p = 1;
- new->attrib = *attrib;
-
- /* link in new node */
- new->next = mem_region_chain;
- mem_region_chain = new;
-
- return new;
-}
-
-static void
-delete_mem_region (struct mem_region *m)
-{
- xfree (m);
+ new.number = ++mem_number;
+ new.attrib = *attrib;
+ VEC_safe_insert (mem_region_s, mem_region_list, ix, &new);
}
/*
struct mem_region *m;
CORE_ADDR lo;
CORE_ADDR hi;
+ int ix;
+
+ require_target_regions ();
/* First we initialize LO and HI so that they describe the entire
memory space. As we process the memory region chain, they are
redefined to describe the minimal region containing ADDR. LO
and HI are used in the case where no memory region is defined
that contains ADDR. If a memory region is disabled, it is
- treated as if it does not exist. */
+ treated as if it does not exist. The initial values for LO
+ and HI represent the bottom and top of memory. */
- lo = (CORE_ADDR) 0;
- hi = (CORE_ADDR) ~ 0;
+ lo = 0;
+ hi = 0;
- for (m = mem_region_chain; m; m = m->next)
+ /* If we ever want to support a huge list of memory regions, this
+ check should be replaced with a binary search (probably using
+ VEC_lower_bound). */
+ for (ix = 0; VEC_iterate (mem_region_s, mem_region_list, ix, m); ix++)
{
if (m->enabled_p == 1)
{
if (addr >= m->lo && (addr < m->hi || m->hi == 0))
return m;
+ /* This (correctly) won't match if m->hi == 0, representing
+ the top of the address space, because CORE_ADDR is unsigned;
+ no value of LO is less than zero. */
if (addr >= m->hi && lo < m->hi)
lo = m->hi;
- if (addr <= m->lo && hi > m->lo)
+ /* This will never set HI to zero; if we're here and ADDR
+ is at or below M, and the region starts at zero, then ADDR
+ would have been in the region. */
+ if (addr <= m->lo && (hi == 0 || hi > m->lo))
hi = m->lo;
}
}
region.attrib = default_mem_attrib;
return ®ion;
}
+
+/* Invalidate any memory regions fetched from the target. */
+
+void
+invalidate_target_mem_regions (void)
+{
+ struct mem_region *m;
+ int ix;
+
+ if (!target_mem_regions_valid)
+ return;
+
+ target_mem_regions_valid = 0;
+ VEC_free (mem_region_s, target_mem_region_list);
+ if (mem_use_target)
+ mem_region_list = NULL;
+}
+
+/* Clear memory region list */
+
+static void
+mem_clear (void)
+{
+ VEC_free (mem_region_s, mem_region_list);
+}
\f
static void
if (!args)
error_no_arg (_("No mem"));
+ /* For "mem auto", switch back to using a target provided list. */
+ if (strcmp (args, "auto") == 0)
+ {
+ if (mem_use_target)
+ return;
+
+ if (mem_region_list != target_mem_region_list)
+ {
+ mem_clear ();
+ mem_region_list = target_mem_region_list;
+ }
+
+ mem_use_target = 1;
+ return;
+ }
+
+ require_user_regions (from_tty);
+
tok = strtok (args, " \t");
if (!tok)
error (_("no lo address"));
{
struct mem_region *m;
struct mem_attrib *attrib;
+ int ix;
+
+ if (mem_use_target)
+ printf_filtered (_("Using memory regions provided by the target.\n"));
+ else
+ printf_filtered (_("Using user-defined memory regions.\n"));
- if (!mem_region_chain)
+ require_target_regions ();
+
+ if (!mem_region_list)
{
printf_unfiltered (_("There are no memory regions defined.\n"));
return;
printf_filtered ("Attrs ");
printf_filtered ("\n");
- for (m = mem_region_chain; m; m = m->next)
+ for (ix = 0; VEC_iterate (mem_region_s, mem_region_list, ix, m); ix++)
{
char *tmp;
printf_filtered ("%-3d %-3c\t",
case MEM_WO:
printf_filtered ("wo ");
break;
+ case MEM_FLASH:
+ printf_filtered ("flash blocksize 0x%x ", attrib->blocksize);
+ break;
}
switch (attrib->width)
mem_enable (int num)
{
struct mem_region *m;
+ int ix;
- for (m = mem_region_chain; m; m = m->next)
+ for (ix = 0; VEC_iterate (mem_region_s, mem_region_list, ix, m); ix++)
if (m->number == num)
{
m->enabled_p = 1;
char *p1;
int num;
struct mem_region *m;
+ int ix;
+
+ require_user_regions (from_tty);
dcache_invalidate (target_dcache);
if (p == 0)
{
- for (m = mem_region_chain; m; m = m->next)
+ for (ix = 0; VEC_iterate (mem_region_s, mem_region_list, ix, m); ix++)
m->enabled_p = 1;
}
else
mem_disable (int num)
{
struct mem_region *m;
+ int ix;
- for (m = mem_region_chain; m; m = m->next)
+ for (ix = 0; VEC_iterate (mem_region_s, mem_region_list, ix, m); ix++)
if (m->number == num)
{
m->enabled_p = 0;
char *p1;
int num;
struct mem_region *m;
+ int ix;
+
+ require_user_regions (from_tty);
dcache_invalidate (target_dcache);
if (p == 0)
{
- for (m = mem_region_chain; m; m = m->next)
+ for (ix = 0; VEC_iterate (mem_region_s, mem_region_list, ix, m); ix++)
m->enabled_p = 0;
}
else
}
}
-/* Clear memory region list */
-
-static void
-mem_clear (void)
-{
- struct mem_region *m;
-
- while ((m = mem_region_chain) != 0)
- {
- mem_region_chain = m->next;
- delete_mem_region (m);
- }
-}
-
/* Delete the memory region number NUM. */
static void
mem_delete (int num)
{
struct mem_region *m1, *m;
+ int ix;
- if (!mem_region_chain)
+ if (!mem_region_list)
{
printf_unfiltered (_("No memory region number %d.\n"), num);
return;
}
- if (mem_region_chain->number == num)
+ for (ix = 0; VEC_iterate (mem_region_s, mem_region_list, ix, m); ix++)
+ if (m->number == num)
+ break;
+
+ if (m == NULL)
{
- m1 = mem_region_chain;
- mem_region_chain = m1->next;
- delete_mem_region (m1);
+ printf_unfiltered (_("No memory region number %d.\n"), num);
+ return;
}
- else
- for (m = mem_region_chain; m->next; m = m->next)
- {
- if (m->next->number == num)
- {
- m1 = m->next;
- m->next = m1->next;
- delete_mem_region (m1);
- break;
- }
- }
+
+ VEC_ordered_remove (mem_region_s, mem_region_list, ix);
}
static void
char *p1;
int num;
+ require_user_regions (from_tty);
+
dcache_invalidate (target_dcache);
if (p == 0)
_initialize_mem (void)
{
add_com ("mem", class_vars, mem_command, _("\
-Define attributes for memory region.\n\
-Usage: mem <lo addr> <hi addr> [<mode> <width> <cache>], \n\
+Define attributes for memory region or reset memory region handling to\n\
+target-based.\n\
+Usage: mem auto\n\
+ mem <lo addr> <hi addr> [<mode> <width> <cache>], \n\
where <mode> may be rw (read/write), ro (read-only) or wo (write-only), \n\
<width> may be 8, 16, 32, or 64, and \n\
<cache> may be cache or nocache"));
projects / binutils-gdb.git / blobdiff