/* The common simulator framework for GDB, the GNU Debugger.
- Copyright 2002, 2007 Free Software Foundation, Inc.
+ Copyright 2002-2021 Free Software Foundation, Inc.
Contributed by Andrew Cagney and Red Hat.
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
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
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. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+/* This must come before any other includes. */
+#include "defs.h"
#include "hw-main.h"
#include "hw-base.h"
#include "sim-io.h"
#include "sim-assert.h"
-#ifdef HAVE_STRING_H
#include <string.h>
-#else
-#ifdef HAVE_STRINGS_H
-#include <strings.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;
{
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:
{
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);
}
{
/* 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)
hw_abort (me, "property \"%s\" not found", property);
if (entry->property->type != ihandle_property
cells = H2BE_cell (hw_instance_to_external (ihandle));
hw_set_property (me, property, ihandle_property,
&cells, sizeof (cells));
-
+
}
#endif
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);
+ 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));
node = hw_find_property (me, property);
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);
+ 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));
-
+
/* check things sane */
node = hw_find_property (me, property);
if (node == NULL)
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)
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",
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)
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",
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);
}
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;
}
if (index == 0)
{
*string = node->array;
- ASSERT (strlen(*string) + 1 == node->sizeof_array);
+ ASSERT (strlen (*string) + 1 == node->sizeof_array);
return 1;
}
break;
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));
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 / deliverable / binutils-gdb.git / blobdiff