-/* This file is part of the program psim.
+/* The common simulator framework for GDB, the GNU Debugger.
- Copyright (C) 1994-1998, Andrew Cagney <cagney@highland.com.au>
+ Copyright 2002-2013 Free Software Foundation, Inc.
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
+ Contributed by Andrew Cagney and Red Hat.
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
- */
+ This file is part of GDB.
-#include "sim-main.h"
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
-#include "hw-device.h"
-#include "hw-properties.h"
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+#include "hw-main.h"
+#include "hw-base.h"
+
+#include "sim-io.h"
#include "sim-assert.h"
#ifdef HAVE_STRING_H
#endif
#endif
-#define TRACE(A,B)
-
/* property entries */
-struct hw_property_data {
+struct hw_property_data
+{
struct hw_property_data *next;
struct hw_property *property;
const void *init_array;
unsigned sizeof_init_array;
};
+void
+create_hw_property_data (struct hw *me)
+{
+}
+
+void
+delete_hw_property_data (struct hw *me)
+{
+}
+
+
/* Device Properties: */
static struct hw_property_data *
{
struct hw_property_data *new_entry = NULL;
struct hw_property *new_value = NULL;
-
+
/* find the list end */
struct hw_property_data **insertion_point = &me->properties_of_hw;
while (*insertion_point != NULL)
return;
insertion_point = &(*insertion_point)->next;
}
-
+
/* create a new value */
new_value = HW_ZALLOC (me, struct hw_property);
new_value->name = (char *) strdup (property);
new_value->owner = me;
new_value->original = original;
new_value->disposition = disposition;
-
+
/* insert the value into the list */
new_entry = HW_ZALLOC (me, struct hw_property_data);
*insertion_point = new_entry;
{
ASSERT (property->init_array != NULL);
ASSERT (property->property->array == NULL);
- ASSERT(property->property->disposition == permenant_object);
+ ASSERT (property->property->disposition == permenant_object);
switch (property->property->type)
{
case array_property:
{
const struct hw_property *node;
node = hw_find_property (me, property);
- if (node == NULL
- || node->type != array_property)
- hw_abort(me, "property %s not found or of wrong type", property);
+ if (node == NULL)
+ hw_abort (me, "property \"%s\" not found", property);
+ if (node->type != array_property)
+ hw_abort (me, "property \"%s\" of wrong type (array)", property);
return node;
}
{
signed32 new_boolean = (boolean ? -1 : 0);
hw_add_property (me, property, boolean_property,
- &new_boolean, sizeof(new_boolean),
- &new_boolean, sizeof(new_boolean),
+ &new_boolean, sizeof (new_boolean),
+ &new_boolean, sizeof (new_boolean),
NULL, permenant_object);
}
const struct hw_property *node;
unsigned_cell boolean;
node = hw_find_property (me, property);
- if (node == NULL || node->type != boolean_property)
- hw_abort (me, "property %s not found or of wrong type", property);
+ if (node == NULL)
+ hw_abort (me, "property \"%s\" not found", property);
+ if (node->type != boolean_property)
+ hw_abort (me, "property \"%s\" of wrong type (boolean)", property);
ASSERT (sizeof (boolean) == node->sizeof_array);
memcpy (&boolean, node->array, sizeof (boolean));
return boolean;
{
/* enter the full path as the init array */
hw_add_property (me, property, ihandle_property,
- ihandle->full_path, strlen(ihandle->full_path) + 1,
+ ihandle->full_path, strlen (ihandle->full_path) + 1,
NULL, 0,
NULL, permenant_object);
}
ihandle_runtime_property_spec *ihandle)
{
struct hw_property_data *entry = find_property_data (me, property);
- TRACE (trace_devices,
- ("hw_find_ihandle_runtime_property(me=0x%lx, property=%s)\n",
- (long)me, property));
- if (entry == NULL
- || entry->property->type != ihandle_property
+ HW_TRACE ((me, "hw_find_ihandle_runtime_property(property=%s)\n", property));
+ if (entry == NULL)
+ hw_abort (me, "property \"%s\" not found", property);
+ if (entry->property->type != ihandle_property
|| entry->property->disposition != permenant_object)
- hw_abort (me, "property %s not found or of wrong type", property);
+ hw_abort (me, "property \"%s\" of wrong type", property);
ASSERT (entry->init_array != NULL);
/* the full path */
ihandle->full_path = entry->init_array;
cells = H2BE_cell (hw_instance_to_external (ihandle));
hw_set_property (me, property, ihandle_property,
&cells, sizeof (cells));
-
+
}
#endif
hw_instance *instance;
node = hw_find_property (me, property);
- if (node == NULL || node->type != ihandle_property)
- hw_abort(me, "property %s not found or of wrong type", property);
+ if (node == NULL)
+ hw_abort (me, "property \"%s\" not found", property);
+ if (node->type != ihandle_property)
+ hw_abort (me, "property \"%s\" of wrong type (ihandle)", property);
if (node->array == NULL)
- hw_abort(me, "runtime property %s not yet initialized", property);
+ hw_abort (me, "runtime property \"%s\" not yet initialized", property);
- ASSERT (sizeof(ihandle) == node->sizeof_array);
- memcpy (&ihandle, node->array, sizeof(ihandle));
- instance = external_to_hw_instance (me, BE2H_cell(ihandle));
+ ASSERT (sizeof (ihandle) == node->sizeof_array);
+ memcpy (&ihandle, node->array, sizeof (ihandle));
+ instance = external_to_hw_instance (me, BE2H_cell (ihandle));
ASSERT (instance != NULL);
return instance;
}
{
H2BE (integer);
hw_add_property (me, property, integer_property,
- &integer, sizeof(integer),
- &integer, sizeof(integer),
+ &integer, sizeof (integer),
+ &integer, sizeof (integer),
NULL, permenant_object);
}
{
const struct hw_property *node;
signed_cell integer;
- TRACE (trace_devices,
- ("hw_find_integer(me=0x%lx, property=%s)\n",
- (long)me, property));
+ HW_TRACE ((me, "hw_find_integer(property=%s)\n", property));
node = hw_find_property (me, property);
- if (node == NULL || node->type != integer_property)
- hw_abort (me, "property %s not found or of wrong type", property);
- ASSERT (sizeof(integer) == node->sizeof_array);
+ if (node == NULL)
+ hw_abort (me, "property \"%s\" not found", property);
+ if (node->type != integer_property)
+ hw_abort (me, "property \"%s\" of wrong type (integer)", property);
+ ASSERT (sizeof (integer) == node->sizeof_array);
memcpy (&integer, node->array, sizeof (integer));
return BE2H_cell (integer);
}
const struct hw_property *node;
int sizeof_integer = sizeof (*integer);
signed_cell *cell;
- TRACE (trace_devices,
- ("hw_find_integer(me=0x%lx, property=%s)\n",
- (long)me, property));
-
+ HW_TRACE ((me, "hw_find_integer(property=%s)\n", property));
+
/* check things sane */
node = hw_find_property (me, property);
- if (node == NULL
- || (node->type != integer_property
- && node->type != array_property))
- hw_abort (me, "property %s not found or of wrong type", property);
+ if (node == NULL)
+ hw_abort (me, "property \"%s\" not found", property);
+ if (node->type != integer_property
+ && node->type != array_property)
+ hw_abort (me, "property \"%s\" of wrong type (integer or array)", property);
if ((node->sizeof_array % sizeof_integer) != 0)
- hw_abort (me, "property %s contains an incomplete number of cells", property);
+ hw_abort (me, "property \"%s\" contains an incomplete number of cells", property);
if (node->sizeof_array <= sizeof_integer * index)
return 0;
-
+
/* Find and convert the value */
cell = ((signed_cell*)node->array) + index;
*integer = BE2H_cell (*cell);
-
+
return node->sizeof_array / sizeof_integer;
}
int nr_cells)
{
int i;
- ASSERT(nr_cells == unit->nr_cells);
+ ASSERT (nr_cells == unit->nr_cells);
for (i = 0; i < unit->nr_cells; i++)
{
*cell = H2BE_cell (unit->cells[i]);
int nr_cells)
{
int i;
- memset(unit, 0, sizeof(*unit));
+ memset (unit, 0, sizeof (*unit));
unit->nr_cells = nr_cells;
for (i = 0; i < unit->nr_cells; i++)
{
unsigned_cell *cells = hw_zalloc (me, sizeof_cells);
unsigned_cell *cell;
int i;
-
+
/* copy the property elements over */
cell = cells;
for (i = 0; i < nr_ranges; i++)
cell = unit_address_to_cells (&range->child_address, cell,
hw_unit_nr_address_cells (me));
/* copy the parent address */
- cell = unit_address_to_cells (&range->parent_address, cell,
+ cell = unit_address_to_cells (&range->parent_address, cell,
hw_unit_nr_address_cells (hw_parent (me)));
/* copy the size */
- cell = unit_address_to_cells (&range->size, cell,
+ cell = unit_address_to_cells (&range->size, cell,
hw_unit_nr_size_cells (me));
}
ASSERT (cell == &cells[nr_range_property_cells (me, nr_ranges)]);
-
+
/* add it */
hw_add_property (me, property, range_array_property,
cells, sizeof_cells,
cells, sizeof_cells,
NULL, permenant_object);
-
+
hw_free (me, cells);
}
unsigned sizeof_entry = (nr_range_property_cells (me, 1)
* sizeof (unsigned_cell));
const unsigned_cell *cells;
-
+
/* locate the property */
node = hw_find_property (me, property);
- if (node == NULL || node->type != range_array_property)
- hw_abort (me, "property %s not found or of wrong type", property);
-
+ if (node == NULL)
+ hw_abort (me, "property \"%s\" not found", property);
+ if (node->type != range_array_property)
+ hw_abort (me, "property \"%s\" of wrong type (range array)", property);
+
/* aligned ? */
if ((node->sizeof_array % sizeof_entry) != 0)
- hw_abort (me, "property %s contains an incomplete number of entries",
+ hw_abort (me, "property \"%s\" contains an incomplete number of entries",
property);
-
+
/* within bounds? */
if (node->sizeof_array < sizeof_entry * (index + 1))
return 0;
-
+
/* find the range of interest */
cells = (unsigned_cell*)((char*)node->array + sizeof_entry * index);
-
+
/* copy the child address out - converting as we go */
cells = cells_to_unit_address (cells, &range->child_address,
hw_unit_nr_address_cells (me));
-
+
/* copy the parent address out - converting as we go */
cells = cells_to_unit_address (cells, &range->parent_address,
hw_unit_nr_address_cells (hw_parent (me)));
-
+
/* copy the size - converting as we go */
cells = cells_to_unit_address (cells, &range->size,
hw_unit_nr_size_cells (me));
-
+
return node->sizeof_array / sizeof_entry;
}
nr_reg_property_cells (struct hw *me,
int nr_regs)
{
- return (hw_unit_nr_address_cells (hw_parent(me))
- + hw_unit_nr_size_cells (hw_parent(me))
+ return (hw_unit_nr_address_cells (hw_parent (me))
+ + hw_unit_nr_size_cells (hw_parent (me))
) * nr_regs;
}
unsigned_cell *cells = hw_zalloc (me, sizeof_cells);
unsigned_cell *cell;
int i;
-
+
/* copy the property elements over */
cell = cells;
for (i = 0; i < nr_regs; i++)
hw_unit_nr_size_cells (hw_parent (me)));
}
ASSERT (cell == &cells[nr_reg_property_cells (me, nr_regs)]);
-
+
/* add it */
hw_add_property (me, property, reg_array_property,
cells, sizeof_cells,
cells, sizeof_cells,
NULL, permenant_object);
-
+
hw_free (me, cells);
}
unsigned sizeof_entry = (nr_reg_property_cells (me, 1)
* sizeof (unsigned_cell));
const unsigned_cell *cells;
-
+
/* locate the property */
node = hw_find_property (me, property);
- if (node == NULL || node->type != reg_array_property)
- hw_abort (me, "property %s not found or of wrong type", property);
-
+ if (node == NULL)
+ hw_abort (me, "property \"%s\" not found", property);
+ if (node->type != reg_array_property)
+ hw_abort (me, "property \"%s\" of wrong type (reg array)", property);
+
/* aligned ? */
if ((node->sizeof_array % sizeof_entry) != 0)
- hw_abort (me, "property %s contains an incomplete number of entries",
+ hw_abort (me, "property \"%s\" contains an incomplete number of entries",
property);
-
+
/* within bounds? */
if (node->sizeof_array < sizeof_entry * (index + 1))
return 0;
-
+
/* find the range of interest */
cells = (unsigned_cell*)((char*)node->array + sizeof_entry * index);
-
+
/* copy the address out - converting as we go */
cells = cells_to_unit_address (cells, ®->address,
hw_unit_nr_address_cells (hw_parent (me)));
-
+
/* copy the size out - converting as we go */
cells = cells_to_unit_address (cells, ®->size,
hw_unit_nr_size_cells (hw_parent (me)));
-
+
return node->sizeof_array / sizeof_entry;
}
const char *string)
{
hw_add_property (me, property, string_property,
- string, strlen(string) + 1,
- string, strlen(string) + 1,
+ string, strlen (string) + 1,
+ string, strlen (string) + 1,
NULL, permenant_object);
}
const struct hw_property *node;
const char *string;
node = hw_find_property (me, property);
- if (node == NULL || node->type != string_property)
- hw_abort (me, "property %s not found or of wrong type", property);
+ if (node == NULL)
+ hw_abort (me, "property \"%s\" not found", property);
+ if (node->type != string_property)
+ hw_abort (me, "property \"%s\" of wrong type (string)", property);
string = node->array;
- ASSERT (strlen(string) + 1 == node->sizeof_array);
+ ASSERT (strlen (string) + 1 == node->sizeof_array);
return string;
}
char *array;
char *chp;
if (nr_strings == 0)
- hw_abort (me, "property %s must be non-null", property);
+ hw_abort (me, "property \"%s\" must be non-null", property);
/* total up the size of the needed array */
for (sizeof_array = 0, string_nr = 0;
string_nr < nr_strings;
const struct hw_property *node;
node = hw_find_property (me, property);
if (node == NULL)
- hw_abort (me, "property %s not found", property);
+ hw_abort (me, "property \"%s\" not found", property);
switch (node->type)
{
default:
- hw_abort (me, "property %s of wrong type", property);
+ hw_abort (me, "property \"%s\" of wrong type", property);
break;
case string_property:
if (index == 0)
{
*string = node->array;
- ASSERT (strlen(*string) + 1 == node->sizeof_array);
+ ASSERT (strlen (*string) + 1 == node->sizeof_array);
return 1;
}
break;
case array_property:
if (node->sizeof_array == 0
|| ((char*)node->array)[node->sizeof_array - 1] != '\0')
- hw_abort (me, "property %s invalid for string array", property);
+ hw_abort (me, "property \"%s\" invalid for string array", property);
/* FALL THROUGH */
case string_array_property:
ASSERT (node->sizeof_array > 0);
const struct hw_property *original)
{
struct hw_property_data *master;
- TRACE (trace_devices,
- ("hw_add_duplicate_property(me=0x%lx, property=%s, ...)\n",
- (long)me, property));
+ HW_TRACE ((me, "hw_add_duplicate_property(property=%s, ...)\n", property));
if (original->disposition != permenant_object)
hw_abort (me, "Can only duplicate permenant objects");
/* find the original's master */
while (master->property != original)
{
master = master->next;
- ASSERT(master != NULL);
+ ASSERT (master != NULL);
}
/* now duplicate it */
hw_add_property (me, property,
projects / thirdparty / binutils-gdb.git / blobdiff