1 files changed, 365 insertions, 146 deletions

diff --git a/gdb/target-descriptions.c b/gdb/target-descriptions.c
index c1eec14..48fc7df 100644
--- a/gdb/target-descriptions.c
+++ b/gdb/target-descriptions.c
@@ -79,13 +79,67 @@ typedef struct tdesc_reg
   char *type;
 
   /* The target-described type corresponding to TYPE, if found.  */
-  struct type *gdb_type;
+  struct tdesc_type *tdesc_type;
 } *tdesc_reg_p;
 DEF_VEC_P(tdesc_reg_p);
 
 /* A named type from a target description.  */
-typedef struct type *type_p;
-DEF_VEC_P(type_p);
+
+typedef struct tdesc_type_field
+{
+  char *name;
+  struct tdesc_type *type;
+} tdesc_type_field;
+DEF_VEC_O(tdesc_type_field);
+
+typedef struct tdesc_type
+{
+  /* The name of this type.  */
+  char *name;
+
+  /* Identify the kind of this type.  */
+  enum
+  {
+    /* Predefined types.  */
+    TDESC_TYPE_INT8,
+    TDESC_TYPE_INT16,
+    TDESC_TYPE_INT32,
+    TDESC_TYPE_INT64,
+    TDESC_TYPE_INT128,
+    TDESC_TYPE_UINT8,
+    TDESC_TYPE_UINT16,
+    TDESC_TYPE_UINT32,
+    TDESC_TYPE_UINT64,
+    TDESC_TYPE_UINT128,
+    TDESC_TYPE_CODE_PTR,
+    TDESC_TYPE_DATA_PTR,
+    TDESC_TYPE_IEEE_SINGLE,
+    TDESC_TYPE_IEEE_DOUBLE,
+    TDESC_TYPE_ARM_FPA_EXT,
+
+    /* Types defined by a target feature.  */
+    TDESC_TYPE_VECTOR,
+    TDESC_TYPE_UNION
+  } kind;
+
+  /* Kind-specific data.  */
+  union
+  {
+    /* Vector type.  */
+    struct
+    {
+      struct tdesc_type *type;
+      int count;
+    } v;
+
+    /* Union type.  */
+    struct
+    {
+      VEC(tdesc_type_field) *fields;
+    } u;
+  } u;
+} *tdesc_type_p;
+DEF_VEC_P(tdesc_type_p);
 
 /* A feature from a target description.  Each feature is a collection
    of other elements, e.g. registers and types.  */
@@ -100,7 +154,7 @@ typedef struct tdesc_feature
   VEC(tdesc_reg_p) *registers;
 
   /* The types associated with this feature.  */
-  VEC(type_p) *types;
+  VEC(tdesc_type_p) *types;
 } *tdesc_feature_p;
 DEF_VEC_P(tdesc_feature_p);
 
@@ -122,15 +176,22 @@ struct target_desc
    target description may be shared by multiple architectures, but
    this data is private to one gdbarch.  */
 
+typedef struct tdesc_arch_reg
+{
+  struct tdesc_reg *reg;
+  struct type *type;
+} tdesc_arch_reg;
+DEF_VEC_O(tdesc_arch_reg);
+
 struct tdesc_arch_data
 {
-  /* A list of registers, indexed by GDB's internal register number.
+  /* A list of register/type pairs, indexed by GDB's internal register number.
      During initialization of the gdbarch this list is used to store
      registers which the architecture assigns a fixed register number.
      Registers which are NULL in this array, or off the end, are
      treated as zero-sized and nameless (i.e. placeholders in the
      numbering).  */
-  VEC(tdesc_reg_p) *registers;
+  VEC(tdesc_arch_reg) *arch_regs;
 
   /* Functions which report the register name, type, and reggroups for
      pseudo-registers.  */
@@ -218,7 +279,7 @@ target_find_description (void)
 
 	  data = gdbarch_data (target_gdbarch, tdesc_data);
 	  if (tdesc_has_registers (current_target_desc)
-	      && data->registers == NULL)
+	      && data->arch_regs == NULL)
 	    warning (_("Target-supplied registers are not supported "
 		       "by the current architecture"));
 	}
@@ -339,51 +400,145 @@ tdesc_feature_name (const struct tdesc_feature *feature)
   return feature->name;
 }
 
-/* Predefined types.  Note that none of these types depend on the
-   current architecture; some of the builtin_type_foo variables are
-   swapped based on the architecture.  */
-static struct
+/* Predefined types.  */
+static struct tdesc_type tdesc_predefined_types[] =
 {
-  const char *name;
-  struct type **type;
-} tdesc_predefined_types[] =
-  {
-    { "int8", &builtin_type_int8 },
-    { "int16", &builtin_type_int16 },
-    { "int32", &builtin_type_int32 },
-    { "int64", &builtin_type_int64 },
-    { "int128", &builtin_type_int128 },
-    { "uint8", &builtin_type_uint8 },
-    { "uint16", &builtin_type_uint16 },
-    { "uint32", &builtin_type_uint32 },
-    { "uint64", &builtin_type_uint64 },
-    { "uint128", &builtin_type_uint128 },
-    { "ieee_single", &builtin_type_ieee_single },
-    { "ieee_double", &builtin_type_ieee_double },
-    { "arm_fpa_ext", &builtin_type_arm_ext }
-  };
+  { "int8", TDESC_TYPE_INT8 },
+  { "int16", TDESC_TYPE_INT16 },
+  { "int32", TDESC_TYPE_INT32 },
+  { "int64", TDESC_TYPE_INT64 },
+  { "int128", TDESC_TYPE_INT128 },
+  { "uint8", TDESC_TYPE_UINT8 },
+  { "uint16", TDESC_TYPE_UINT16 },
+  { "uint32", TDESC_TYPE_UINT32 },
+  { "uint64", TDESC_TYPE_UINT64 },
+  { "uint128", TDESC_TYPE_UINT128 },
+  { "code_ptr", TDESC_TYPE_CODE_PTR },
+  { "data_ptr", TDESC_TYPE_DATA_PTR },
+  { "ieee_single", TDESC_TYPE_IEEE_SINGLE },
+  { "ieee_double", TDESC_TYPE_IEEE_DOUBLE },
+  { "arm_fpa_ext", TDESC_TYPE_ARM_FPA_EXT }
+};
 
 /* Return the type associated with ID in the context of FEATURE, or
    NULL if none.  */
 
-struct type *
+struct tdesc_type *
 tdesc_named_type (const struct tdesc_feature *feature, const char *id)
 {
   int ix;
-  struct type *gdb_type;
+  struct tdesc_type *type;
 
   /* First try target-defined types.  */
-  for (ix = 0; VEC_iterate (type_p, feature->types, ix, gdb_type); ix++)
-    if (strcmp (TYPE_NAME (gdb_type), id) == 0)
-      return gdb_type;
+  for (ix = 0; VEC_iterate (tdesc_type_p, feature->types, ix, type); ix++)
+    if (strcmp (type->name, id) == 0)
+      return type;
 
   /* Next try the predefined types.  */
   for (ix = 0; ix < ARRAY_SIZE (tdesc_predefined_types); ix++)
     if (strcmp (tdesc_predefined_types[ix].name, id) == 0)
-      return *tdesc_predefined_types[ix].type;
+      return &tdesc_predefined_types[ix];
 
   return NULL;
 }
+
+/* Construct, if necessary, and return the GDB type implementing target
+   type TDESC_TYPE for architecture GDBARCH.  */
+
+static struct type *
+tdesc_gdb_type (struct gdbarch *gdbarch, struct tdesc_type *tdesc_type)
+{
+  switch (tdesc_type->kind)
+    {
+    /* Predefined types.  */
+    case TDESC_TYPE_INT8:
+      return builtin_type_int8;
+
+    case TDESC_TYPE_INT16:
+      return builtin_type_int16;
+
+    case TDESC_TYPE_INT32:
+      return builtin_type_int32;
+
+    case TDESC_TYPE_INT64:
+      return builtin_type_int64;
+
+    case TDESC_TYPE_INT128:
+      return builtin_type_int128;
+
+    case TDESC_TYPE_UINT8:
+      return builtin_type_uint8;
+
+    case TDESC_TYPE_UINT16:
+      return builtin_type_uint16;
+
+    case TDESC_TYPE_UINT32:
+      return builtin_type_uint32;
+
+    case TDESC_TYPE_UINT64:
+      return builtin_type_uint64;
+
+    case TDESC_TYPE_UINT128:
+      return builtin_type_uint128;
+
+    case TDESC_TYPE_CODE_PTR:
+      return builtin_type (gdbarch)->builtin_func_ptr;
+
+    case TDESC_TYPE_DATA_PTR:
+      return builtin_type (gdbarch)->builtin_data_ptr;
+
+    case TDESC_TYPE_IEEE_SINGLE:
+      return builtin_type_ieee_single;
+
+    case TDESC_TYPE_IEEE_DOUBLE:
+      return builtin_type_ieee_double;
+
+    case TDESC_TYPE_ARM_FPA_EXT:
+      return builtin_type_arm_ext;
+
+    /* Types defined by a target feature.  */
+    case TDESC_TYPE_VECTOR:
+      {
+	struct type *type, *field_type;
+
+	field_type = tdesc_gdb_type (gdbarch, tdesc_type->u.v.type);
+	type = init_vector_type (field_type, tdesc_type->u.v.count);
+	TYPE_NAME (type) = xstrdup (tdesc_type->name);
+
+	return type;
+      }
+
+    case TDESC_TYPE_UNION:
+      {
+	struct type *type, *field_type;
+	struct tdesc_type_field *f;
+	int ix;
+
+	type = init_composite_type (NULL, TYPE_CODE_UNION);
+	TYPE_NAME (type) = xstrdup (tdesc_type->name);
+
+	for (ix = 0;
+	     VEC_iterate (tdesc_type_field, tdesc_type->u.u.fields, ix, f);
+	     ix++)
+	  {
+	    field_type = tdesc_gdb_type (gdbarch, f->type);
+	    append_composite_type_field (type, xstrdup (f->name), field_type);
+
+	    /* If any of the children of this union are vectors, flag the
+	       union as a vector also.  This allows e.g. a union of two
+	       vector types to show up automatically in "info vector".  */
+	    if (TYPE_VECTOR (field_type))
+	      TYPE_VECTOR (type) = 1;
+	  }
+
+	return type;
+      }
+    }
+
+  internal_error (__FILE__, __LINE__,
+		  "Type \"%s\" has an unknown kind %d",
+		  tdesc_type->name, tdesc_type->kind);
+}
 
 
 /* Support for registers from target descriptions.  */
@@ -417,7 +572,7 @@ tdesc_data_cleanup (void *data_untyped)
 {
   struct tdesc_arch_data *data = data_untyped;
 
-  VEC_free (tdesc_reg_p, data->registers);
+  VEC_free (tdesc_arch_reg, data->arch_regs);
   xfree (data);
 }
 
@@ -446,15 +601,18 @@ tdesc_numbered_register (const struct tdesc_feature *feature,
 			 struct tdesc_arch_data *data,
 			 int regno, const char *name)
 {
+  struct tdesc_arch_reg arch_reg = { 0 };
   struct tdesc_reg *reg = tdesc_find_register_early (feature, name);
 
   if (reg == NULL)
     return 0;
 
   /* Make sure the vector includes a REGNO'th element.  */
-  while (regno >= VEC_length (tdesc_reg_p, data->registers))
-    VEC_safe_push (tdesc_reg_p, data->registers, NULL);
-  VEC_replace (tdesc_reg_p, data->registers, regno, reg);
+  while (regno >= VEC_length (tdesc_arch_reg, data->arch_regs))
+    VEC_safe_push (tdesc_arch_reg, data->arch_regs, &arch_reg);
+
+  arch_reg.reg = reg;
+  VEC_replace (tdesc_arch_reg, data->arch_regs, regno, &arch_reg);
   return 1;
 }
 
@@ -490,19 +648,26 @@ tdesc_register_size (const struct tdesc_feature *feature,
 
 /* Look up a register by its GDB internal register number.  */
 
-static struct tdesc_reg *
-tdesc_find_register (struct gdbarch *gdbarch, int regno)
+static struct tdesc_arch_reg *
+tdesc_find_arch_register (struct gdbarch *gdbarch, int regno)
 {
-  struct tdesc_reg *reg;
+  struct tdesc_arch_reg *reg;
   struct tdesc_arch_data *data;
 
   data = gdbarch_data (gdbarch, tdesc_data);
-  if (regno < VEC_length (tdesc_reg_p, data->registers))
-    return VEC_index (tdesc_reg_p, data->registers, regno);
+  if (regno < VEC_length (tdesc_arch_reg, data->arch_regs))
+    return VEC_index (tdesc_arch_reg, data->arch_regs, regno);
   else
     return NULL;
 }
 
+static struct tdesc_reg *
+tdesc_find_register (struct gdbarch *gdbarch, int regno)
+{
+  struct tdesc_arch_reg *reg = tdesc_find_arch_register (gdbarch, regno);
+  return reg? reg->reg : NULL;
+}
+
 /* Return the name of register REGNO, from the target description or
    from an architecture-provided pseudo_register_name method.  */
 
@@ -529,7 +694,8 @@ tdesc_register_name (struct gdbarch *gdbarch, int regno)
 static struct type *
 tdesc_register_type (struct gdbarch *gdbarch, int regno)
 {
-  struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
+  struct tdesc_arch_reg *arch_reg = tdesc_find_arch_register (gdbarch, regno);
+  struct tdesc_reg *reg = arch_reg? arch_reg->reg : NULL;
   int num_regs = gdbarch_num_regs (gdbarch);
   int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
 
@@ -544,48 +710,58 @@ tdesc_register_type (struct gdbarch *gdbarch, int regno)
     /* Return "int0_t", since "void" has a misleading size of one.  */
     return builtin_type_int0;
 
-  /* First check for a predefined or target defined type.  */
-  if (reg->gdb_type)
-    return reg->gdb_type;
-
-  /* Next try size-sensitive type shortcuts.  */
-  if (strcmp (reg->type, "float") == 0)
+  if (arch_reg->type == NULL)
     {
-      if (reg->bitsize == gdbarch_float_bit (gdbarch))
-	return builtin_type (gdbarch)->builtin_float;
-      else if (reg->bitsize == gdbarch_double_bit (gdbarch))
-	return builtin_type (gdbarch)->builtin_double;
-      else if (reg->bitsize == gdbarch_long_double_bit (gdbarch))
-	return builtin_type (gdbarch)->builtin_long_double;
-    }
-  else if (strcmp (reg->type, "int") == 0)
-    {
-      if (reg->bitsize == gdbarch_long_bit (gdbarch))
-	return builtin_type (gdbarch)->builtin_long;
-      else if (reg->bitsize == TARGET_CHAR_BIT)
-	return builtin_type (gdbarch)->builtin_char;
-      else if (reg->bitsize == gdbarch_short_bit (gdbarch))
-	return builtin_type (gdbarch)->builtin_short;
-      else if (reg->bitsize == gdbarch_int_bit (gdbarch))
-	return builtin_type (gdbarch)->builtin_int;
-      else if (reg->bitsize == gdbarch_long_long_bit (gdbarch))
-	return builtin_type (gdbarch)->builtin_long_long;
-      else if (reg->bitsize == gdbarch_ptr_bit (gdbarch))
-	/* A bit desperate by this point... */
-	return builtin_type (gdbarch)->builtin_data_ptr;
+      /* First check for a predefined or target defined type.  */
+      if (reg->tdesc_type)
+        arch_reg->type = tdesc_gdb_type (gdbarch, reg->tdesc_type);
+
+      /* Next try size-sensitive type shortcuts.  */
+      else if (strcmp (reg->type, "float") == 0)
+	{
+	  if (reg->bitsize == gdbarch_float_bit (gdbarch))
+	    arch_reg->type = builtin_type (gdbarch)->builtin_float;
+	  else if (reg->bitsize == gdbarch_double_bit (gdbarch))
+	    arch_reg->type = builtin_type (gdbarch)->builtin_double;
+	  else if (reg->bitsize == gdbarch_long_double_bit (gdbarch))
+	    arch_reg->type = builtin_type (gdbarch)->builtin_long_double;
+	  else
+	    {
+	      warning (_("Register \"%s\" has an unsupported size (%d bits)"),
+		       reg->name, reg->bitsize);
+	      arch_reg->type = builtin_type (gdbarch)->builtin_double;
+	    }
+	}
+      else if (strcmp (reg->type, "int") == 0)
+	{
+	  if (reg->bitsize == gdbarch_long_bit (gdbarch))
+	    arch_reg->type = builtin_type (gdbarch)->builtin_long;
+	  else if (reg->bitsize == TARGET_CHAR_BIT)
+	    arch_reg->type = builtin_type (gdbarch)->builtin_char;
+	  else if (reg->bitsize == gdbarch_short_bit (gdbarch))
+	    arch_reg->type = builtin_type (gdbarch)->builtin_short;
+	  else if (reg->bitsize == gdbarch_int_bit (gdbarch))
+	    arch_reg->type = builtin_type (gdbarch)->builtin_int;
+	  else if (reg->bitsize == gdbarch_long_long_bit (gdbarch))
+	    arch_reg->type = builtin_type (gdbarch)->builtin_long_long;
+	  else if (reg->bitsize == gdbarch_ptr_bit (gdbarch))
+	  /* A bit desperate by this point... */
+	    arch_reg->type = builtin_type (gdbarch)->builtin_data_ptr;
+	  else
+	    {
+	      warning (_("Register \"%s\" has an unsupported size (%d bits)"),
+		       reg->name, reg->bitsize);
+	      arch_reg->type = builtin_type (gdbarch)->builtin_long;
+	    }
+	}
+
+      if (arch_reg->type == NULL)
+	internal_error (__FILE__, __LINE__,
+			"Register \"%s\" has an unknown type \"%s\"",
+			reg->name, reg->type);
     }
-  else if (strcmp (reg->type, "code_ptr") == 0)
-    return builtin_type (gdbarch)->builtin_func_ptr;
-  else if (strcmp (reg->type, "data_ptr") == 0)
-    return builtin_type (gdbarch)->builtin_data_ptr;
-  else
-    internal_error (__FILE__, __LINE__,
-		    "Register \"%s\" has an unknown type \"%s\"",
-		    reg->name, reg->type);
 
-  warning (_("Register \"%s\" has an unsupported size (%d bits)"),
-	   reg->name, reg->bitsize);
-  return builtin_type (gdbarch)->builtin_long;
+  return arch_reg->type;
 }
 
 static int
@@ -717,6 +893,7 @@ tdesc_use_registers (struct gdbarch *gdbarch,
   struct tdesc_feature *feature;
   struct tdesc_reg *reg;
   struct tdesc_arch_data *data;
+  struct tdesc_arch_reg *arch_reg, new_arch_reg = { 0 };
   htab_t reg_hash;
 
   /* We can't use the description for registers if it doesn't describe
@@ -726,7 +903,7 @@ tdesc_use_registers (struct gdbarch *gdbarch,
   gdb_assert (tdesc_has_registers (target_desc));
 
   data = gdbarch_data (gdbarch, tdesc_data);
-  data->registers = early_data->registers;
+  data->arch_regs = early_data->arch_regs;
   xfree (early_data);
 
   /* Build up a set of all registers, so that we can assign register
@@ -747,18 +924,20 @@ tdesc_use_registers (struct gdbarch *gdbarch,
 
   /* Remove any registers which were assigned numbers by the
      architecture.  */
-  for (ixr = 0; VEC_iterate (tdesc_reg_p, data->registers, ixr, reg); ixr++)
-    if (reg)
-      htab_remove_elt (reg_hash, reg);
+  for (ixr = 0;
+       VEC_iterate (tdesc_arch_reg, data->arch_regs, ixr, arch_reg);
+       ixr++)
+    if (arch_reg->reg)
+      htab_remove_elt (reg_hash, arch_reg->reg);
 
   /* Assign numbers to the remaining registers and add them to the
      list of registers.  The new numbers are always above gdbarch_num_regs.
      Iterate over the features, not the hash table, so that the order
      matches that in the target description.  */
 
-  gdb_assert (VEC_length (tdesc_reg_p, data->registers) <= num_regs);
-  while (VEC_length (tdesc_reg_p, data->registers) < num_regs)
-    VEC_safe_push (tdesc_reg_p, data->registers, NULL);
+  gdb_assert (VEC_length (tdesc_arch_reg, data->arch_regs) <= num_regs);
+  while (VEC_length (tdesc_arch_reg, data->arch_regs) < num_regs)
+    VEC_safe_push (tdesc_arch_reg, data->arch_regs, &new_arch_reg);
   for (ixf = 0;
        VEC_iterate (tdesc_feature_p, target_desc->features, ixf, feature);
        ixf++)
@@ -767,7 +946,8 @@ tdesc_use_registers (struct gdbarch *gdbarch,
 	 ixr++)
       if (htab_find (reg_hash, reg) != NULL)
 	{
-	  VEC_safe_push (tdesc_reg_p, data->registers, reg);
+	  new_arch_reg.reg = reg;
+	  VEC_safe_push (tdesc_arch_reg, data->arch_regs, &new_arch_reg);
 	  num_regs++;
 	}
 
@@ -810,27 +990,94 @@ tdesc_create_reg (struct tdesc_feature *feature, const char *name,
 
   /* If the register's type is target-defined, look it up now.  We may not
      have easy access to the containing feature when we want it later.  */
-  reg->gdb_type = tdesc_named_type (feature, reg->type);
+  reg->tdesc_type = tdesc_named_type (feature, reg->type);
 
   VEC_safe_push (tdesc_reg_p, feature->registers, reg);
 }
 
 static void
+tdesc_free_type (struct tdesc_type *type)
+{
+
+  switch (type->kind)
+    {
+    case TDESC_TYPE_UNION:
+      {
+	struct tdesc_type_field *f;
+	int ix;
+
+	for (ix = 0;
+	     VEC_iterate (tdesc_type_field, type->u.u.fields, ix, f);
+	     ix++)
+	  xfree (f->name);
+
+	VEC_free (tdesc_type_field, type->u.u.fields);
+      }
+      break;
+
+    default:
+      break;
+    }
+
+  xfree (type->name);
+  xfree (type);
+}
+
+struct tdesc_type *
+tdesc_create_vector (struct tdesc_feature *feature, const char *name,
+		     struct tdesc_type *field_type, int count)
+{
+  struct tdesc_type *type = XZALLOC (struct tdesc_type);
+
+  type->name = xstrdup (name);
+  type->kind = TDESC_TYPE_VECTOR;
+  type->u.v.type = field_type;
+  type->u.v.count = count;
+
+  VEC_safe_push (tdesc_type_p, feature->types, type);
+  return type;
+}
+
+struct tdesc_type *
+tdesc_create_union (struct tdesc_feature *feature, const char *name)
+{
+  struct tdesc_type *type = XZALLOC (struct tdesc_type);
+
+  type->name = xstrdup (name);
+  type->kind = TDESC_TYPE_UNION;
+
+  VEC_safe_push (tdesc_type_p, feature->types, type);
+  return type;
+}
+
+void
+tdesc_add_field (struct tdesc_type *type, const char *field_name,
+		 struct tdesc_type *field_type)
+{
+  struct tdesc_type_field f = { 0 };
+
+  gdb_assert (type->kind == TDESC_TYPE_UNION);
+
+  f.name = xstrdup (field_name);
+  f.type = field_type;
+
+  VEC_safe_push (tdesc_type_field, type->u.u.fields, &f);
+}
+
+static void
 tdesc_free_feature (struct tdesc_feature *feature)
 {
   struct tdesc_reg *reg;
+  struct tdesc_type *type;
   int ix;
 
   for (ix = 0; VEC_iterate (tdesc_reg_p, feature->registers, ix, reg); ix++)
     tdesc_free_reg (reg);
   VEC_free (tdesc_reg_p, feature->registers);
 
-  /* There is no easy way to free xmalloc-allocated types, nor is
-     there a way to allocate types on an obstack not associated with
-     an objfile.  Therefore we never free types.  Since we only ever
-     parse an identical XML document once, this memory leak is mostly
-     contained.  */
-  VEC_free (type_p, feature->types);
+  for (ix = 0; VEC_iterate (tdesc_type_p, feature->types, ix, type); ix++)
+    tdesc_free_type (type);
+  VEC_free (tdesc_type_p, feature->types);
 
   xfree (feature->name);
   xfree (feature);
@@ -847,15 +1094,6 @@ tdesc_create_feature (struct target_desc *tdesc, const char *name)
   return new_feature;
 }
 
-void
-tdesc_record_type (struct tdesc_feature *feature, struct type *type)
-{
-  /* The type's ID should be used as its TYPE_NAME.  */
-  gdb_assert (TYPE_NAME (type) != NULL);
-
-  VEC_safe_push (type_p, feature->types, type);
-}
-
 struct target_desc *
 allocate_target_description (void)
 {
@@ -976,19 +1214,6 @@ unset_tdesc_filename_cmd (char *args, int from_tty)
   target_find_description ();
 }
 
-static const char *
-tdesc_type_id (struct type *type)
-{
-  int ix;
-
-  for (ix = 0; ix < ARRAY_SIZE (tdesc_predefined_types); ix++)
-    if (TYPE_MAIN_TYPE (*tdesc_predefined_types[ix].type)
-	== TYPE_MAIN_TYPE (type))
-      return tdesc_predefined_types[ix].name;
-
-  return TYPE_NAME (type);
-}
-
 static void
 maint_print_c_tdesc_cmd (char *args, int from_tty)
 {
@@ -998,7 +1223,8 @@ maint_print_c_tdesc_cmd (char *args, int from_tty)
   struct property *prop;
   struct tdesc_feature *feature;
   struct tdesc_reg *reg;
-  struct type *type;
+  struct tdesc_type *type;
+  struct tdesc_type_field *f;
   int ix, ix2, ix3;
 
   /* Use the global target-supplied description, not the current
@@ -1027,7 +1253,6 @@ maint_print_c_tdesc_cmd (char *args, int from_tty)
   printf_unfiltered ("/* THIS FILE IS GENERATED.  Original: %s */\n\n",
 		     filename);
   printf_unfiltered ("#include \"defs.h\"\n");
-  printf_unfiltered ("#include \"gdbtypes.h\"\n");
   printf_unfiltered ("#include \"target-descriptions.h\"\n");
   printf_unfiltered ("\n");
 
@@ -1038,7 +1263,7 @@ maint_print_c_tdesc_cmd (char *args, int from_tty)
   printf_unfiltered
     ("  struct target_desc *result = allocate_target_description ();\n");
   printf_unfiltered ("  struct tdesc_feature *feature;\n");
-  printf_unfiltered ("  struct type *field_type, *type;\n");
+  printf_unfiltered ("  struct tdesc_type *field_type, *type;\n");
   printf_unfiltered ("\n");
 
   if (tdesc_architecture (tdesc) != NULL)
@@ -1064,44 +1289,38 @@ maint_print_c_tdesc_cmd (char *args, int from_tty)
 			 feature->name);
 
       for (ix2 = 0;
-	   VEC_iterate (type_p, feature->types, ix2, type);
+	   VEC_iterate (tdesc_type_p, feature->types, ix2, type);
 	   ix2++)
 	{
-	  switch (TYPE_CODE (type))
+	  switch (type->kind)
 	    {
-	    case TYPE_CODE_ARRAY:
+	    case TDESC_TYPE_VECTOR:
 	      printf_unfiltered
 		("  field_type = tdesc_named_type (feature, \"%s\");\n",
-		 tdesc_type_id (TYPE_TARGET_TYPE (type)));
-	      printf_unfiltered
-		("  type = init_vector_type (field_type, %d);\n",
-		 TYPE_LENGTH (type) / TYPE_LENGTH (TYPE_TARGET_TYPE (type)));
+		 type->u.v.type->name);
 	      printf_unfiltered
-		("  TYPE_NAME (type) = xstrdup (\"%s\");\n", TYPE_NAME (type));
+		("  tdesc_create_vector (feature, \"%s\", field_type, %d);\n",
+		 type->name, type->u.v.count);
 	      break;
-	    case TYPE_CODE_UNION:
-	      printf_unfiltered
-		("  type = init_composite_type (NULL, TYPE_CODE_UNION);\n");
+	    case TDESC_TYPE_UNION:
 	      printf_unfiltered
-		("  TYPE_NAME (type) = xstrdup (\"%s\");\n", TYPE_NAME (type));
-	      for (ix3 = 0; ix3 < TYPE_NFIELDS (type); ix3++)
+		("  type = tdesc_create_union (feature, \"%s\");\n",
+		 type->name);
+	      for (ix3 = 0;
+		   VEC_iterate (tdesc_type_field, type->u.u.fields, ix3, f);
+		   ix3++)
 		{
 		  printf_unfiltered
 		    ("  field_type = tdesc_named_type (feature, \"%s\");\n",
-		     tdesc_type_id (TYPE_FIELD_TYPE (type, ix3)));
+		     f->type->name);
 		  printf_unfiltered
-		    ("  append_composite_type_field (type, "
-		     "xstrdup (\"%s\"), field_type);\n",
-		     TYPE_FIELD_NAME (type, ix3));
+		    ("  tdesc_add_field (type, \"%s\", field_type);\n",
+		     f->name);
 		}
-	      if (TYPE_VECTOR (type))
-		printf_unfiltered
-		  ("  TYPE_VECTOR (type) = 1;\n");
 	      break;
 	    default:
-	      error (_("C output is not supported type \"%s\"."), TYPE_NAME (type));
+	      error (_("C output is not supported type \"%s\"."), type->name);
 	    }
-	  printf_unfiltered ("  tdesc_record_type (feature, type);\n");
 	  printf_unfiltered ("\n");
 	}