return (result_type);
}
-
/* Construct and return a type of the form:
struct NAME { ELT_TYPE ELT_NAME[N]; }
We use these types for SIMD registers. For example, the type of
char *elt_name,
int n)
{
- struct type *t;
- struct field *f;
-
- /* Build the field structure. */
- f = xmalloc (sizeof (*f));
- memset (f, 0, sizeof (*f));
- f->loc.bitpos = 0;
- f->type = create_array_type (0, elt_type,
- create_range_type (0, builtin_type_int,
- 0, n-1));
- f->name = elt_name;
-
- /* Build a struct type with that field. */
- t = init_type (TYPE_CODE_STRUCT, n * TYPE_LENGTH (elt_type), 0, 0, 0);
- t->nfields = 1;
- t->fields = f;
- TYPE_TAG_NAME (t) = name;
-
- return t;
+ struct type *simd_type;
+ struct type *array_type;
+
+ simd_type = init_composite_type (name, TYPE_CODE_STRUCT);
+ array_type = create_array_type (0, elt_type,
+ create_range_type (0, builtin_type_int,
+ 0, n-1));
+ append_composite_type_field (simd_type, elt_name, array_type);
+ return simd_type;
}
static struct type *
#endif
struct type *t;
- struct field *f;
-
- f = (struct field *) xcalloc (5, sizeof (*f));
-
- FIELD_TYPE (f[0]) = builtin_type_int128;
- FIELD_NAME (f[0]) = "uint128";
-
- FIELD_TYPE (f[1]) = builtin_type_v4sf;
- FIELD_NAME (f[1]) = "v4sf";
- FIELD_TYPE (f[2]) = builtin_type_v4si;
- FIELD_NAME (f[2]) = "v4si";
-
- FIELD_TYPE (f[3]) = builtin_type_v8hi;
- FIELD_NAME (f[3]) = "v8hi";
-
- FIELD_TYPE (f[4]) = builtin_type_v16qi;
- FIELD_NAME (f[4]) = "v16qi";
-
- /* Build a union type with those fields. */
- t = init_type (TYPE_CODE_UNION, 16, 0, 0, 0);
- TYPE_NFIELDS (t) = 5;
- TYPE_FIELDS (t) = f;
- TYPE_TAG_NAME (t) = "__gdb_builtin_type_vec128";
+ t = init_composite_type ("__gdb_builtin_type_vec128", TYPE_CODE_UNION);
+ append_composite_type_field (t, "uint128", builtin_type_int128);
+ append_composite_type_field (t, "v4sf", builtin_type_v4sf);
+ append_composite_type_field (t, "v4si", builtin_type_v4si);
+ append_composite_type_field (t, "v8hi", builtin_type_v8hi);
+ append_composite_type_field (t, "v16qi", builtin_type_v16qi);
return t;
}
return (type);
}
+/* Helper function. Create an empty composite type. */
+
+struct type *
+init_composite_type (char *name, enum type_code code)
+{
+ struct type *t;
+ gdb_assert (code == TYPE_CODE_STRUCT
+ || code == TYPE_CODE_UNION);
+ t = init_type (code, 0, 0, NULL, NULL);
+ TYPE_TAG_NAME (t) = name;
+ return t;
+}
+
+/* Helper function. Append a field to a composite type. */
+
+void
+append_composite_type_field (struct type *t, char *name, struct type *field)
+{
+ struct field *f;
+ TYPE_NFIELDS (t) = TYPE_NFIELDS (t) + 1;
+ TYPE_FIELDS (t) = xrealloc (TYPE_FIELDS (t),
+ sizeof (struct field) * TYPE_NFIELDS (t));
+ f = &(TYPE_FIELDS (t)[TYPE_NFIELDS (t) - 1]);
+ memset (f, 0, sizeof f[0]);
+ FIELD_TYPE (f[0]) = field;
+ FIELD_NAME (f[0]) = name;
+ if (TYPE_CODE (t) == TYPE_CODE_UNION)
+ {
+ if (TYPE_LENGTH (t) < TYPE_LENGTH (field))
+ TYPE_LENGTH (t) = TYPE_LENGTH (field);
+ }
+ else if (TYPE_CODE (t) == TYPE_CODE_STRUCT)
+ {
+ TYPE_LENGTH (t) = TYPE_LENGTH (t) + TYPE_LENGTH (field);
+ if (TYPE_NFIELDS (t) > 1)
+ {
+ FIELD_BITPOS (f[0]) = (FIELD_BITPOS (f[-1])
+ + TYPE_LENGTH (field) * TARGET_CHAR_BIT);
+ }
+ }
+}
+
/* Look up a fundamental type for the specified objfile.
May need to construct such a type if this is the first use.
{
puts_filtered (" TYPE_FLAG_VARARGS");
}
+ /* This is used for things like AltiVec registers on ppc. Gcc emits
+ an attribute for the array type, which tells whether or not we
+ have a vector, instead of a regular array. */
+ if (TYPE_VECTOR (type))
+ {
+ puts_filtered (" TYPE_FLAG_VECTOR");
+ }
puts_filtered ("\n");
printfi_filtered (spaces, "nfields %d ", TYPE_NFIELDS (type));
gdb_print_host_address (TYPE_FIELDS (type), gdb_stdout);
init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
0,
"float", (struct objfile *) NULL);
+/* vinschen@redhat.com 2002-02-08:
+ The below lines are disabled since they are doing the wrong
+ thing for non-multiarch targets. They are setting the correct
+ type of floats for the target but while on multiarch targets
+ this is done everytime the architecture changes, it's done on
+ non-multiarch targets only on startup, leaving the wrong values
+ in even if the architecture changes (eg. from big-endian to
+ little-endian). */
+#if 0
TYPE_FLOATFORMAT (builtin_type_float) = TARGET_FLOAT_FORMAT;
+#endif
builtin_type_double =
init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
0,
"double", (struct objfile *) NULL);
+#if 0
TYPE_FLOATFORMAT (builtin_type_double) = TARGET_DOUBLE_FORMAT;
+#endif
builtin_type_long_double =
init_type (TYPE_CODE_FLT, TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
0,
"long double", (struct objfile *) NULL);
+#if 0
TYPE_FLOATFORMAT (builtin_type_long_double) = TARGET_LONG_DOUBLE_FORMAT;
+#endif
builtin_type_complex =
init_type (TYPE_CODE_COMPLEX, 2 * TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
0,
projects / binutils-gdb.git / blobdiff