/* Allocate a new GDBARCH-associated type structure and fill it
with some defaults. Space for the type structure is allocated
- on the heap. */
+ on the obstack associated with GDBARCH. */
struct type *
alloc_type_arch (struct gdbarch *gdbarch)
/* Alloc the structure and start off with all fields zeroed. */
- type = XCNEW (struct type);
- TYPE_MAIN_TYPE (type) = XCNEW (struct main_type);
+ type = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct type);
+ TYPE_MAIN_TYPE (type) = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct main_type);
TYPE_OBJFILE_OWNED (type) = 0;
TYPE_OWNER (type).gdbarch = gdbarch;
return type;
}
+/* See gdbtypes.h. */
+
+unsigned int
+type_length_units (struct type *type)
+{
+ struct gdbarch *arch = get_type_arch (type);
+ int unit_size = gdbarch_addressable_memory_unit_size (arch);
+
+ return TYPE_LENGTH (type) / unit_size;
+}
+
/* Alloc a new type instance structure, fill it with some defaults,
and point it at OLDTYPE. Allocate the new type instance from the
same place as OLDTYPE. */
}
TYPE_NFIELDS (fn) = nparams;
- TYPE_FIELDS (fn) = TYPE_ZALLOC (fn, nparams * sizeof (struct field));
+ TYPE_FIELDS (fn)
+ = (struct field *) TYPE_ZALLOC (fn, nparams * sizeof (struct field));
for (i = 0; i < nparams; ++i)
TYPE_FIELD_TYPE (fn, i) = param_types[i];
int
get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp)
{
- CHECK_TYPEDEF (type);
+ type = check_typedef (type);
switch (TYPE_CODE (type))
{
case TYPE_CODE_RANGE:
return 1;
}
+/* Assuming that TYPE is a discrete type and VAL is a valid integer
+ representation of a value of this type, save the corresponding
+ position number in POS.
+
+ Its differs from VAL only in the case of enumeration types. In
+ this case, the position number of the value of the first listed
+ enumeration literal is zero; the position number of the value of
+ each subsequent enumeration literal is one more than that of its
+ predecessor in the list.
+
+ Return 1 if the operation was successful. Return zero otherwise,
+ in which case the value of POS is unmodified.
+*/
+
+int
+discrete_position (struct type *type, LONGEST val, LONGEST *pos)
+{
+ if (TYPE_CODE (type) == TYPE_CODE_ENUM)
+ {
+ int i;
+
+ for (i = 0; i < TYPE_NFIELDS (type); i += 1)
+ {
+ if (val == TYPE_FIELD_ENUMVAL (type, i))
+ {
+ *pos = i;
+ return 1;
+ }
+ }
+ /* Invalid enumeration value. */
+ return 0;
+ }
+ else
+ {
+ *pos = val;
+ return 1;
+ }
+}
+
/* Create an array type using either a blank type supplied in
RESULT_TYPE, or creating a new type, inheriting the objfile from
RANGE_TYPE.
TYPE_CODE (result_type) = TYPE_CODE_ARRAY;
TYPE_TARGET_TYPE (result_type) = element_type;
- if (has_static_range (TYPE_RANGE_DATA (range_type)))
+ if (has_static_range (TYPE_RANGE_DATA (range_type))
+ && (!type_not_associated (result_type)
+ && !type_not_allocated (result_type)))
{
LONGEST low_bound, high_bound;
if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
low_bound = high_bound = 0;
- CHECK_TYPEDEF (element_type);
+ element_type = check_typedef (element_type);
/* Be careful when setting the array length. Ada arrays can be
empty arrays with the high_bound being smaller than the low_bound.
In such cases, the array length should be zero. */
TYPE_CODE (result_type) = TYPE_CODE_SET;
TYPE_NFIELDS (result_type) = 1;
- TYPE_FIELDS (result_type) = TYPE_ZALLOC (result_type, sizeof (struct field));
+ TYPE_FIELDS (result_type)
+ = (struct field *) TYPE_ZALLOC (result_type, sizeof (struct field));
if (!TYPE_STUB (domain_type))
{
const char *name;
struct objfile *objfile;
- CHECK_TYPEDEF (type);
+ type = check_typedef (type);
name = type_name_no_tag (type);
if (name != NULL)
struct type *type;
sym = lookup_symbol_in_language (name, block, VAR_DOMAIN,
- language->la_language, NULL);
+ language->la_language, NULL).symbol;
if (sym != NULL && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
return SYMBOL_TYPE (sym);
lookup_unsigned_typename (const struct language_defn *language,
struct gdbarch *gdbarch, const char *name)
{
- char *uns = alloca (strlen (name) + 10);
+ char *uns = (char *) alloca (strlen (name) + 10);
strcpy (uns, "unsigned ");
strcpy (uns + 9, name);
struct gdbarch *gdbarch, const char *name)
{
struct type *t;
- char *uns = alloca (strlen (name) + 8);
+ char *uns = (char *) alloca (strlen (name) + 8);
strcpy (uns, "signed ");
strcpy (uns + 7, name);
{
struct symbol *sym;
- sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
+ sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0).symbol;
if (sym == NULL)
{
struct symbol *sym;
struct type *t;
- sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
+ sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0).symbol;
if (sym == NULL)
error (_("No union type named %s."), name);
{
struct symbol *sym;
- sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
+ sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0).symbol;
if (sym == NULL)
{
error (_("No enum type named %s."), name);
strcat (nam, TYPE_NAME (type));
strcat (nam, " >"); /* FIXME, extra space still introduced in gcc? */
- sym = lookup_symbol (nam, block, VAR_DOMAIN, 0);
+ sym = lookup_symbol (nam, block, VAR_DOMAIN, 0).symbol;
if (sym == NULL)
{
for (;;)
{
- CHECK_TYPEDEF (type);
+ type = check_typedef (type);
if (TYPE_CODE (type) != TYPE_CODE_PTR
&& TYPE_CODE (type) != TYPE_CODE_REF)
break;
{
unsigned int n;
- CHECK_TYPEDEF (type);
+ type = check_typedef (type);
gdb_assert (TYPE_CODE (type) == TYPE_CODE_INT && TYPE_UNSIGNED (type));
gdb_assert (TYPE_LENGTH (type) <= sizeof (ULONGEST));
{
unsigned int n;
- CHECK_TYPEDEF (type);
+ type = check_typedef (type);
gdb_assert (TYPE_CODE (type) == TYPE_CODE_INT && !TYPE_UNSIGNED (type));
gdb_assert (TYPE_LENGTH (type) <= sizeof (LONGEST));
int
internal_type_vptr_fieldno (struct type *type)
{
- CHECK_TYPEDEF (type);
+ type = check_typedef (type);
gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
|| TYPE_CODE (type) == TYPE_CODE_UNION);
if (!HAVE_CPLUS_STRUCT (type))
void
set_type_vptr_fieldno (struct type *type, int fieldno)
{
- CHECK_TYPEDEF (type);
+ type = check_typedef (type);
gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
|| TYPE_CODE (type) == TYPE_CODE_UNION);
if (!HAVE_CPLUS_STRUCT (type))
struct type *
internal_type_vptr_basetype (struct type *type)
{
- CHECK_TYPEDEF (type);
+ type = check_typedef (type);
gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
|| TYPE_CODE (type) == TYPE_CODE_UNION);
gdb_assert (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_CPLUS_STUFF);
void
set_type_vptr_basetype (struct type *type, struct type *basetype)
{
- CHECK_TYPEDEF (type);
+ type = check_typedef (type);
gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
|| TYPE_CODE (type) == TYPE_CODE_UNION);
if (!HAVE_CPLUS_STRUCT (type))
int
get_vptr_fieldno (struct type *type, struct type **basetypep)
{
- CHECK_TYPEDEF (type);
+ type = check_typedef (type);
if (TYPE_VPTR_FIELDNO (type) < 0)
{
|| TYPE_DATA_LOCATION_KIND (type) == PROP_LOCLIST))
return 1;
+ if (TYPE_ASSOCIATED_PROP (type))
+ return 1;
+
+ if (TYPE_ALLOCATED_PROP (type))
+ return 1;
+
switch (TYPE_CODE (type))
{
case TYPE_CODE_RANGE:
gdb_assert (TYPE_CODE (dyn_range_type) == TYPE_CODE_RANGE);
prop = &TYPE_RANGE_DATA (dyn_range_type)->low;
- if (dwarf2_evaluate_property (prop, addr_stack, &value))
+ if (dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
{
low_bound.kind = PROP_CONST;
low_bound.data.const_val = value;
}
prop = &TYPE_RANGE_DATA (dyn_range_type)->high;
- if (dwarf2_evaluate_property (prop, addr_stack, &value))
+ if (dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
{
high_bound.kind = PROP_CONST;
high_bound.data.const_val = value;
struct type *elt_type;
struct type *range_type;
struct type *ary_dim;
+ struct dynamic_prop *prop;
gdb_assert (TYPE_CODE (type) == TYPE_CODE_ARRAY);
+ type = copy_type (type);
+
elt_type = type;
range_type = check_typedef (TYPE_INDEX_TYPE (elt_type));
range_type = resolve_dynamic_range (range_type, addr_stack);
+ /* Resolve allocated/associated here before creating a new array type, which
+ will update the length of the array accordingly. */
+ prop = TYPE_ALLOCATED_PROP (type);
+ if (prop != NULL && dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
+ {
+ TYPE_DYN_PROP_ADDR (prop) = value;
+ TYPE_DYN_PROP_KIND (prop) = PROP_CONST;
+ }
+ prop = TYPE_ASSOCIATED_PROP (type);
+ if (prop != NULL && dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
+ {
+ TYPE_DYN_PROP_ADDR (prop) = value;
+ TYPE_DYN_PROP_KIND (prop) = PROP_CONST;
+ }
+
ary_dim = check_typedef (TYPE_TARGET_TYPE (elt_type));
if (ary_dim != NULL && TYPE_CODE (ary_dim) == TYPE_CODE_ARRAY)
- elt_type = resolve_dynamic_array (TYPE_TARGET_TYPE (type), addr_stack);
+ elt_type = resolve_dynamic_array (ary_dim, addr_stack);
else
elt_type = TYPE_TARGET_TYPE (type);
- return create_array_type (copy_type (type),
- elt_type,
- range_type);
+ return create_array_type_with_stride (type, elt_type, range_type,
+ TYPE_FIELD_BITSIZE (type, 0));
}
/* Resolve dynamic bounds of members of the union TYPE to static
resolved_type = copy_type (type);
TYPE_FIELDS (resolved_type)
- = TYPE_ALLOC (resolved_type,
- TYPE_NFIELDS (resolved_type) * sizeof (struct field));
+ = (struct field *) TYPE_ALLOC (resolved_type,
+ TYPE_NFIELDS (resolved_type)
+ * sizeof (struct field));
memcpy (TYPE_FIELDS (resolved_type),
TYPE_FIELDS (type),
TYPE_NFIELDS (resolved_type) * sizeof (struct field));
resolved_type = copy_type (type);
TYPE_FIELDS (resolved_type)
- = TYPE_ALLOC (resolved_type,
- TYPE_NFIELDS (resolved_type) * sizeof (struct field));
+ = (struct field *) TYPE_ALLOC (resolved_type,
+ TYPE_NFIELDS (resolved_type)
+ * sizeof (struct field));
memcpy (TYPE_FIELDS (resolved_type),
TYPE_FIELDS (type),
TYPE_NFIELDS (resolved_type) * sizeof (struct field));
" (invalid location kind)"));
pinfo.type = check_typedef (TYPE_FIELD_TYPE (type, i));
+ pinfo.valaddr = addr_stack->valaddr;
pinfo.addr = addr_stack->addr;
pinfo.next = addr_stack;
TYPE_LENGTH (resolved_type)
= (resolved_type_bit_length + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT;
+ /* The Ada language uses this field as a cache for static fixed types: reset
+ it as RESOLVED_TYPE must have its own static fixed type. */
+ TYPE_TARGET_TYPE (resolved_type) = NULL;
+
return resolved_type;
}
{
struct type *real_type = check_typedef (type);
struct type *resolved_type = type;
- const struct dynamic_prop *prop;
+ struct dynamic_prop *prop;
CORE_ADDR value;
if (!is_dynamic_type_internal (real_type, top_level))
struct property_addr_info pinfo;
pinfo.type = check_typedef (TYPE_TARGET_TYPE (type));
- pinfo.addr = read_memory_typed_address (addr_stack->addr, type);
+ pinfo.valaddr = NULL;
+ if (addr_stack->valaddr != NULL)
+ pinfo.addr = extract_typed_address (addr_stack->valaddr, type);
+ else
+ pinfo.addr = read_memory_typed_address (addr_stack->addr, type);
pinfo.next = addr_stack;
resolved_type = copy_type (type);
/* Resolve data_location attribute. */
prop = TYPE_DATA_LOCATION (resolved_type);
- if (dwarf2_evaluate_property (prop, addr_stack, &value))
+ if (prop != NULL
+ && dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
{
- TYPE_DATA_LOCATION_ADDR (resolved_type) = value;
- TYPE_DATA_LOCATION_KIND (resolved_type) = PROP_CONST;
+ TYPE_DYN_PROP_ADDR (prop) = value;
+ TYPE_DYN_PROP_KIND (prop) = PROP_CONST;
}
- else
- TYPE_DATA_LOCATION (resolved_type) = NULL;
return resolved_type;
}
/* See gdbtypes.h */
struct type *
-resolve_dynamic_type (struct type *type, CORE_ADDR addr)
+resolve_dynamic_type (struct type *type, const gdb_byte *valaddr,
+ CORE_ADDR addr)
{
- struct property_addr_info pinfo = {check_typedef (type), addr, NULL};
+ struct property_addr_info pinfo
+ = {check_typedef (type), valaddr, addr, NULL};
return resolve_dynamic_type_internal (type, &pinfo, 1);
}
+/* See gdbtypes.h */
+
+struct dynamic_prop *
+get_dyn_prop (enum dynamic_prop_node_kind prop_kind, const struct type *type)
+{
+ struct dynamic_prop_list *node = TYPE_DYN_PROP_LIST (type);
+
+ while (node != NULL)
+ {
+ if (node->prop_kind == prop_kind)
+ return &node->prop;
+ node = node->next;
+ }
+ return NULL;
+}
+
+/* See gdbtypes.h */
+
+void
+add_dyn_prop (enum dynamic_prop_node_kind prop_kind, struct dynamic_prop prop,
+ struct type *type, struct objfile *objfile)
+{
+ struct dynamic_prop_list *temp;
+
+ gdb_assert (TYPE_OBJFILE_OWNED (type));
+
+ temp = XOBNEW (&objfile->objfile_obstack, struct dynamic_prop_list);
+ temp->prop_kind = prop_kind;
+ temp->prop = prop;
+ temp->next = TYPE_DYN_PROP_LIST (type);
+
+ TYPE_DYN_PROP_LIST (type) = temp;
+}
+
+
/* Find the real type of TYPE. This function returns the real type,
after removing all layers of typedefs, and completing opaque or stub
types. Completion changes the TYPE argument, but stripping of
stub_noname_complaint ();
return make_qualified_type (type, instance_flags, NULL);
}
- sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0);
+ sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0).symbol;
if (sym)
TYPE_TARGET_TYPE (type) = SYMBOL_TYPE (sym);
else /* TYPE_CODE_UNDEF */
stub_noname_complaint ();
return make_qualified_type (type, instance_flags, NULL);
}
- sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0);
+ sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0).symbol;
if (sym)
{
/* Same as above for opaque types, we can replace the stub
{
type = parse_and_eval_type (p, length);
}
-
CATCH (except, RETURN_MASK_ERROR)
{
type = builtin_type (gdbarch)->builtin_void;
{
/* FIXME: Should we return true for references as well as
pointers? */
- CHECK_TYPEDEF (t);
+ t = check_typedef (t);
return
(t != NULL
&& TYPE_CODE (t) == TYPE_CODE_PTR
int
is_integral_type (struct type *t)
{
- CHECK_TYPEDEF (t);
+ t = check_typedef (t);
return
((t != NULL)
&& ((TYPE_CODE (t) == TYPE_CODE_INT)
/* Return true if TYPE is scalar. */
-static int
+int
is_scalar_type (struct type *type)
{
- CHECK_TYPEDEF (type);
+ type = check_typedef (type);
switch (TYPE_CODE (type))
{
int
is_scalar_type_recursive (struct type *t)
{
- CHECK_TYPEDEF (t);
+ t = check_typedef (t);
if (is_scalar_type (t))
return 1;
int i;
int d;
- CHECK_TYPEDEF (base);
- CHECK_TYPEDEF (dclass);
+ base = check_typedef (base);
+ dclass = check_typedef (dclass);
if (class_types_same_p (base, dclass))
return 0;
{
int i, count = 0;
- CHECK_TYPEDEF (base);
- CHECK_TYPEDEF (dclass);
+ base = check_typedef (base);
+ dclass = check_typedef (dclass);
for (i = 0; i < TYPE_N_BASECLASSES (dclass) && count < 2; ++i)
{
struct value **args, int nargs)
{
int i;
- struct badness_vector *bv;
+ struct badness_vector *bv = XNEW (struct badness_vector);
int min_len = nparms < nargs ? nparms : nargs;
- bv = xmalloc (sizeof (struct badness_vector));
bv->length = nargs + 1; /* add 1 for the length-match rank. */
bv->rank = XNEWVEC (struct rank, nargs + 1);
check_types_equal (struct type *type1, struct type *type2,
VEC (type_equality_entry_d) **worklist)
{
- CHECK_TYPEDEF (type1);
- CHECK_TYPEDEF (type2);
+ type1 = check_typedef (type1);
+ type2 = check_typedef (type2);
if (type1 == type2)
return 1;
int
types_deeply_equal (struct type *type1, struct type *type2)
{
+ struct gdb_exception except = exception_none;
int result = 0;
struct bcache *cache;
VEC (type_equality_entry_d) *worklist = NULL;
entry.type2 = type2;
VEC_safe_push (type_equality_entry_d, worklist, &entry);
+ /* check_types_worklist calls several nested helper functions, some
+ of which can raise a GDB exception, so we just check and rethrow
+ here. If there is a GDB exception, a comparison is not capable
+ (or trusted), so exit. */
TRY
{
result = check_types_worklist (&worklist, cache);
}
- /* check_types_worklist calls several nested helper functions,
- some of which can raise a GDB Exception, so we just check
- and rethrow here. If there is a GDB exception, a comparison
- is not capable (or trusted), so exit. */
- bcache_xfree (cache);
- VEC_free (type_equality_entry_d, worklist);
- /* Rethrow if there was a problem. */
- CATCH (except, RETURN_MASK_ALL)
+ CATCH (ex, RETURN_MASK_ALL)
{
- throw_exception (except);
+ except = ex;
}
END_CATCH
+ bcache_xfree (cache);
+ VEC_free (type_equality_entry_d, worklist);
+
+ /* Rethrow if there was a problem. */
+ if (except.reason < 0)
+ throw_exception (except);
+
return result;
}
+
+/* Allocated status of type TYPE. Return zero if type TYPE is allocated.
+ Otherwise return one. */
+
+int
+type_not_allocated (const struct type *type)
+{
+ struct dynamic_prop *prop = TYPE_ALLOCATED_PROP (type);
+
+ return (prop && TYPE_DYN_PROP_KIND (prop) == PROP_CONST
+ && !TYPE_DYN_PROP_ADDR (prop));
+}
+
+/* Associated status of type TYPE. Return zero if type TYPE is associated.
+ Otherwise return one. */
+
+int
+type_not_associated (const struct type *type)
+{
+ struct dynamic_prop *prop = TYPE_ASSOCIATED_PROP (type);
+
+ return (prop && TYPE_DYN_PROP_KIND (prop) == PROP_CONST
+ && !TYPE_DYN_PROP_ADDR (prop));
+}
\f
/* Compare one type (PARM) for compatibility with another (ARG).
* PARM is intended to be the parameter type of a function; and
{
struct type *descriptive_type = TYPE_DESCRIPTIVE_TYPE (type);
- recursive_dump_type (descriptive_type, spaces + 2);
+ if (descriptive_type == NULL)
+ printfi_filtered (spaces + 2, "no descriptive type\n");
+ else
+ {
+ printfi_filtered (spaces + 2, "descriptive type\n");
+ recursive_dump_type (descriptive_type, spaces + 4);
+ }
}
static struct obstack dont_print_type_obstack;
static hashval_t
type_pair_hash (const void *item)
{
- const struct type_pair *pair = item;
+ const struct type_pair *pair = (const struct type_pair *) item;
return htab_hash_pointer (pair->old);
}
static int
type_pair_eq (const void *item_lhs, const void *item_rhs)
{
- const struct type_pair *lhs = item_lhs, *rhs = item_rhs;
+ const struct type_pair *lhs = (const struct type_pair *) item_lhs;
+ const struct type_pair *rhs = (const struct type_pair *) item_rhs;
return lhs->old == rhs->old;
}
dummy_obstack_deallocate);
}
+/* Recursively copy (deep copy) a dynamic attribute list of a type. */
+
+static struct dynamic_prop_list *
+copy_dynamic_prop_list (struct obstack *objfile_obstack,
+ struct dynamic_prop_list *list)
+{
+ struct dynamic_prop_list *copy = list;
+ struct dynamic_prop_list **node_ptr = ©
+
+ while (*node_ptr != NULL)
+ {
+ struct dynamic_prop_list *node_copy;
+
+ node_copy = ((struct dynamic_prop_list *)
+ obstack_copy (objfile_obstack, *node_ptr,
+ sizeof (struct dynamic_prop_list)));
+ node_copy->prop = (*node_ptr)->prop;
+ *node_ptr = node_copy;
+
+ node_ptr = &node_copy->next;
+ }
+
+ return copy;
+}
+
/* Recursively copy (deep copy) TYPE, if it is associated with
- OBJFILE. Return a new type allocated using malloc, a saved type if
- we have already visited TYPE (using COPIED_TYPES), or TYPE if it is
- not associated with OBJFILE. */
+ OBJFILE. Return a new type owned by the gdbarch associated with the type, a
+ saved type if we have already visited TYPE (using COPIED_TYPES), or TYPE if
+ it is not associated with OBJFILE. */
struct type *
copy_type_recursive (struct objfile *objfile,
/* We must add the new type to the hash table immediately, in case
we encounter this type again during a recursive call below. */
- stored
- = obstack_alloc (&objfile->objfile_obstack, sizeof (struct type_pair));
+ stored = XOBNEW (&objfile->objfile_obstack, struct type_pair);
stored->old = type;
stored->newobj = new_type;
*slot = stored;
/* For range types, copy the bounds information. */
if (TYPE_CODE (type) == TYPE_CODE_RANGE)
{
- TYPE_RANGE_DATA (new_type) = xmalloc (sizeof (struct range_bounds));
+ TYPE_RANGE_DATA (new_type) = XNEW (struct range_bounds);
*TYPE_RANGE_DATA (new_type) = *TYPE_RANGE_DATA (type);
}
- /* Copy the data location information. */
- if (TYPE_DATA_LOCATION (type) != NULL)
- {
- TYPE_DATA_LOCATION (new_type)
- = TYPE_ALLOC (new_type, sizeof (struct dynamic_prop));
- memcpy (TYPE_DATA_LOCATION (new_type), TYPE_DATA_LOCATION (type),
- sizeof (struct dynamic_prop));
- }
+ if (TYPE_DYN_PROP_LIST (type) != NULL)
+ TYPE_DYN_PROP_LIST (new_type)
+ = copy_dynamic_prop_list (&objfile->objfile_obstack,
+ TYPE_DYN_PROP_LIST (type));
+
/* Copy pointers to other types. */
if (TYPE_TARGET_TYPE (type))
TYPE_LENGTH (new_type) = TYPE_LENGTH (type);
memcpy (TYPE_MAIN_TYPE (new_type), TYPE_MAIN_TYPE (type),
sizeof (struct main_type));
- if (TYPE_DATA_LOCATION (type) != NULL)
- {
- TYPE_DATA_LOCATION (new_type)
- = TYPE_ALLOC (new_type, sizeof (struct dynamic_prop));
- memcpy (TYPE_DATA_LOCATION (new_type), TYPE_DATA_LOCATION (type),
- sizeof (struct dynamic_prop));
- }
+ if (TYPE_DYN_PROP_LIST (type) != NULL)
+ TYPE_DYN_PROP_LIST (new_type)
+ = copy_dynamic_prop_list (&TYPE_OBJFILE (type) -> objfile_obstack,
+ TYPE_DYN_PROP_LIST (type));
return new_type;
}
TYPE_LENGTH (type) = length;
if (name)
- TYPE_NAME (type) = xstrdup (name);
+ TYPE_NAME (type) = gdbarch_obstack_strdup (gdbarch, name);
return type;
}
type = arch_type (gdbarch, TYPE_CODE_FLAGS, length, name);
TYPE_UNSIGNED (type) = 1;
TYPE_NFIELDS (type) = nfields;
- TYPE_FIELDS (type) = TYPE_ZALLOC (type, nfields * sizeof (struct field));
+ TYPE_FIELDS (type)
+ = (struct field *) TYPE_ZALLOC (type, nfields * sizeof (struct field));
return type;
}
struct field *f;
TYPE_NFIELDS (t) = TYPE_NFIELDS (t) + 1;
- TYPE_FIELDS (t) = xrealloc (TYPE_FIELDS (t),
- sizeof (struct field) * TYPE_NFIELDS (t));
+ TYPE_FIELDS (t) = XRESIZEVEC (struct field, TYPE_FIELDS (t),
+ TYPE_NFIELDS (t));
f = &(TYPE_FIELDS (t)[TYPE_NFIELDS (t) - 1]);
memset (f, 0, sizeof f[0]);
FIELD_TYPE (f[0]) = field;
const struct builtin_type *
builtin_type (struct gdbarch *gdbarch)
{
- return gdbarch_data (gdbarch, gdbtypes_data);
+ return (const struct builtin_type *) gdbarch_data (gdbarch, gdbtypes_data);
}
static void *
{
struct gdbarch *gdbarch;
struct objfile_type *objfile_type
- = objfile_data (objfile, objfile_type_data);
+ = (struct objfile_type *) objfile_data (objfile, objfile_type_data);
if (objfile_type)
return objfile_type;
projects / deliverable / binutils-gdb.git / blobdiff