1 /* Target description support for GDB.
2 
3    Copyright (C) 2006-2013 Free Software Foundation, Inc.
4 
5    Contributed by CodeSourcery.
6 
7    This file is part of GDB.
8 
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 3 of the License, or
12    (at your option) any later version.
13 
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18 
19    You should have received a copy of the GNU General Public License
20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
21 
22 #include "defs.h"
23 #include "arch-utils.h"
24 #include "gdbcmd.h"
25 #include "gdbtypes.h"
26 #include "reggroups.h"
27 #include "target.h"
28 #include "target-descriptions.h"
29 #include "vec.h"
30 #include "xml-support.h"
31 #include "xml-tdesc.h"
32 #include "osabi.h"
33 
34 #include "gdb_assert.h"
35 #include "gdb_obstack.h"
36 #include "hashtab.h"
37 #include "inferior.h"
38 
39 /* Types.  */
40 
41 typedef struct property
42 {
43   char *key;
44   char *value;
45 } property_s;
46 DEF_VEC_O(property_s);
47 
48 /* An individual register from a target description.  */
49 
50 typedef struct tdesc_reg
51 {
52   /* The name of this register.  In standard features, it may be
53      recognized by the architecture support code, or it may be purely
54      for the user.  */
55   char *name;
56 
57   /* The register number used by this target to refer to this
58      register.  This is used for remote p/P packets and to determine
59      the ordering of registers in the remote g/G packets.  */
60   long target_regnum;
61 
62   /* If this flag is set, GDB should save and restore this register
63      around calls to an inferior function.  */
64   int save_restore;
65 
66   /* The name of the register group containing this register, or NULL
67      if the group should be automatically determined from the
68      register's type.  If this is "general", "float", or "vector", the
69      corresponding "info" command should display this register's
70      value.  It can be an arbitrary string, but should be limited to
71      alphanumeric characters and internal hyphens.  Currently other
72      strings are ignored (treated as NULL).  */
73   char *group;
74 
75   /* The size of the register, in bits.  */
76   int bitsize;
77 
78   /* The type of the register.  This string corresponds to either
79      a named type from the target description or a predefined
80      type from GDB.  */
81   char *type;
82 
83   /* The target-described type corresponding to TYPE, if found.  */
84   struct tdesc_type *tdesc_type;
85 } *tdesc_reg_p;
86 DEF_VEC_P(tdesc_reg_p);
87 
88 /* A named type from a target description.  */
89 
90 typedef struct tdesc_type_field
91 {
92   char *name;
93   struct tdesc_type *type;
94   int start, end;
95 } tdesc_type_field;
96 DEF_VEC_O(tdesc_type_field);
97 
98 typedef struct tdesc_type_flag
99 {
100   char *name;
101   int start;
102 } tdesc_type_flag;
103 DEF_VEC_O(tdesc_type_flag);
104 
105 typedef struct tdesc_type
106 {
107   /* The name of this type.  */
108   char *name;
109 
110   /* Identify the kind of this type.  */
111   enum
112   {
113     /* Predefined types.  */
114     TDESC_TYPE_INT8,
115     TDESC_TYPE_INT16,
116     TDESC_TYPE_INT32,
117     TDESC_TYPE_INT64,
118     TDESC_TYPE_INT128,
119     TDESC_TYPE_UINT8,
120     TDESC_TYPE_UINT16,
121     TDESC_TYPE_UINT32,
122     TDESC_TYPE_UINT64,
123     TDESC_TYPE_UINT128,
124     TDESC_TYPE_CODE_PTR,
125     TDESC_TYPE_DATA_PTR,
126     TDESC_TYPE_IEEE_SINGLE,
127     TDESC_TYPE_IEEE_DOUBLE,
128     TDESC_TYPE_ARM_FPA_EXT,
129     TDESC_TYPE_I387_EXT,
130 
131     /* Types defined by a target feature.  */
132     TDESC_TYPE_VECTOR,
133     TDESC_TYPE_STRUCT,
134     TDESC_TYPE_UNION,
135     TDESC_TYPE_FLAGS
136   } kind;
137 
138   /* Kind-specific data.  */
139   union
140   {
141     /* Vector type.  */
142     struct
143     {
144       struct tdesc_type *type;
145       int count;
146     } v;
147 
148     /* Struct or union type.  */
149     struct
150     {
151       VEC(tdesc_type_field) *fields;
152       LONGEST size;
153     } u;
154 
155     /* Flags type.  */
156     struct
157     {
158       VEC(tdesc_type_flag) *flags;
159       LONGEST size;
160     } f;
161   } u;
162 } *tdesc_type_p;
163 DEF_VEC_P(tdesc_type_p);
164 
165 /* A feature from a target description.  Each feature is a collection
166    of other elements, e.g. registers and types.  */
167 
168 typedef struct tdesc_feature
169 {
170   /* The name of this feature.  It may be recognized by the architecture
171      support code.  */
172   char *name;
173 
174   /* The registers associated with this feature.  */
175   VEC(tdesc_reg_p) *registers;
176 
177   /* The types associated with this feature.  */
178   VEC(tdesc_type_p) *types;
179 } *tdesc_feature_p;
180 DEF_VEC_P(tdesc_feature_p);
181 
182 /* A compatible architecture from a target description.  */
183 typedef const struct bfd_arch_info *arch_p;
184 DEF_VEC_P(arch_p);
185 
186 /* A target description.  */
187 
188 struct target_desc
189 {
190   /* The architecture reported by the target, if any.  */
191   const struct bfd_arch_info *arch;
192 
193   /* The osabi reported by the target, if any; GDB_OSABI_UNKNOWN
194      otherwise.  */
195   enum gdb_osabi osabi;
196 
197   /* The list of compatible architectures reported by the target.  */
198   VEC(arch_p) *compatible;
199 
200   /* Any architecture-specific properties specified by the target.  */
201   VEC(property_s) *properties;
202 
203   /* The features associated with this target.  */
204   VEC(tdesc_feature_p) *features;
205 };
206 
207 /* Per-architecture data associated with a target description.  The
208    target description may be shared by multiple architectures, but
209    this data is private to one gdbarch.  */
210 
211 typedef struct tdesc_arch_reg
212 {
213   struct tdesc_reg *reg;
214   struct type *type;
215 } tdesc_arch_reg;
216 DEF_VEC_O(tdesc_arch_reg);
217 
218 struct tdesc_arch_data
219 {
220   /* A list of register/type pairs, indexed by GDB's internal register number.
221      During initialization of the gdbarch this list is used to store
222      registers which the architecture assigns a fixed register number.
223      Registers which are NULL in this array, or off the end, are
224      treated as zero-sized and nameless (i.e. placeholders in the
225      numbering).  */
226   VEC(tdesc_arch_reg) *arch_regs;
227 
228   /* Functions which report the register name, type, and reggroups for
229      pseudo-registers.  */
230   gdbarch_register_name_ftype *pseudo_register_name;
231   gdbarch_register_type_ftype *pseudo_register_type;
232   gdbarch_register_reggroup_p_ftype *pseudo_register_reggroup_p;
233 };
234 
235 /* Info about an inferior's target description.  There's one of these
236    for each inferior.  */
237 
238 struct target_desc_info
239 {
240   /* A flag indicating that a description has already been fetched
241      from the target, so it should not be queried again.  */
242 
243   int fetched;
244 
245   /* The description fetched from the target, or NULL if the target
246      did not supply any description.  Only valid when
247      target_desc_fetched is set.  Only the description initialization
248      code should access this; normally, the description should be
249      accessed through the gdbarch object.  */
250 
251   const struct target_desc *tdesc;
252 
253   /* The filename to read a target description from, as set by "set
254      tdesc filename ..."  */
255 
256   char *filename;
257 };
258 
259 /* Get the inferior INF's target description info, allocating one on
260    the stop if necessary.  */
261 
262 static struct target_desc_info *
get_tdesc_info(struct inferior * inf)263 get_tdesc_info (struct inferior *inf)
264 {
265   if (inf->tdesc_info == NULL)
266     inf->tdesc_info = XCNEW (struct target_desc_info);
267   return inf->tdesc_info;
268 }
269 
270 /* A handle for architecture-specific data associated with the
271    target description (see struct tdesc_arch_data).  */
272 
273 static struct gdbarch_data *tdesc_data;
274 
275 /* See target-descriptions.h.  */
276 
277 int
target_desc_info_from_user_p(struct target_desc_info * info)278 target_desc_info_from_user_p (struct target_desc_info *info)
279 {
280   return info != NULL && info->filename != NULL;
281 }
282 
283 /* See target-descriptions.h.  */
284 
285 void
copy_inferior_target_desc_info(struct inferior * destinf,struct inferior * srcinf)286 copy_inferior_target_desc_info (struct inferior *destinf, struct inferior *srcinf)
287 {
288   struct target_desc_info *src = get_tdesc_info (srcinf);
289   struct target_desc_info *dest = get_tdesc_info (destinf);
290 
291   dest->fetched = src->fetched;
292   dest->tdesc = src->tdesc;
293   dest->filename = src->filename != NULL ? xstrdup (src->filename) : NULL;
294 }
295 
296 /* See target-descriptions.h.  */
297 
298 void
target_desc_info_free(struct target_desc_info * tdesc_info)299 target_desc_info_free (struct target_desc_info *tdesc_info)
300 {
301   if (tdesc_info != NULL)
302     {
303       xfree (tdesc_info->filename);
304       xfree (tdesc_info);
305     }
306 }
307 
308 /* Convenience helper macros.  */
309 
310 #define target_desc_fetched \
311   get_tdesc_info (current_inferior ())->fetched
312 #define current_target_desc \
313   get_tdesc_info (current_inferior ())->tdesc
314 #define target_description_filename \
315   get_tdesc_info (current_inferior ())->filename
316 
317 /* The string manipulated by the "set tdesc filename ..." command.  */
318 
319 static char *tdesc_filename_cmd_string;
320 
321 /* Fetch the current target's description, and switch the current
322    architecture to one which incorporates that description.  */
323 
324 void
target_find_description(void)325 target_find_description (void)
326 {
327   /* If we've already fetched a description from the target, don't do
328      it again.  This allows a target to fetch the description early,
329      during its to_open or to_create_inferior, if it needs extra
330      information about the target to initialize.  */
331   if (target_desc_fetched)
332     return;
333 
334   /* The current architecture should not have any target description
335      specified.  It should have been cleared, e.g. when we
336      disconnected from the previous target.  */
337   gdb_assert (gdbarch_target_desc (target_gdbarch ()) == NULL);
338 
339   /* First try to fetch an XML description from the user-specified
340      file.  */
341   current_target_desc = NULL;
342   if (target_description_filename != NULL
343       && *target_description_filename != '\0')
344     current_target_desc
345       = file_read_description_xml (target_description_filename);
346 
347   /* Next try to read the description from the current target using
348      target objects.  */
349   if (current_target_desc == NULL)
350     current_target_desc = target_read_description_xml (&current_target);
351 
352   /* If that failed try a target-specific hook.  */
353   if (current_target_desc == NULL)
354     current_target_desc = target_read_description (&current_target);
355 
356   /* If a non-NULL description was returned, then update the current
357      architecture.  */
358   if (current_target_desc)
359     {
360       struct gdbarch_info info;
361 
362       gdbarch_info_init (&info);
363       info.target_desc = current_target_desc;
364       if (!gdbarch_update_p (info))
365 	warning (_("Architecture rejected target-supplied description"));
366       else
367 	{
368 	  struct tdesc_arch_data *data;
369 
370 	  data = gdbarch_data (target_gdbarch (), tdesc_data);
371 	  if (tdesc_has_registers (current_target_desc)
372 	      && data->arch_regs == NULL)
373 	    warning (_("Target-supplied registers are not supported "
374 		       "by the current architecture"));
375 	}
376     }
377 
378   /* Now that we know this description is usable, record that we
379      fetched it.  */
380   target_desc_fetched = 1;
381 }
382 
383 /* Discard any description fetched from the current target, and switch
384    the current architecture to one with no target description.  */
385 
386 void
target_clear_description(void)387 target_clear_description (void)
388 {
389   struct gdbarch_info info;
390 
391   if (!target_desc_fetched)
392     return;
393 
394   target_desc_fetched = 0;
395   current_target_desc = NULL;
396 
397   gdbarch_info_init (&info);
398   if (!gdbarch_update_p (info))
399     internal_error (__FILE__, __LINE__,
400 		    _("Could not remove target-supplied description"));
401 }
402 
403 /* Return the global current target description.  This should only be
404    used by gdbarch initialization code; most access should be through
405    an existing gdbarch.  */
406 
407 const struct target_desc *
target_current_description(void)408 target_current_description (void)
409 {
410   if (target_desc_fetched)
411     return current_target_desc;
412 
413   return NULL;
414 }
415 
416 /* Return non-zero if this target description is compatible
417    with the given BFD architecture.  */
418 
419 int
tdesc_compatible_p(const struct target_desc * target_desc,const struct bfd_arch_info * arch)420 tdesc_compatible_p (const struct target_desc *target_desc,
421 		    const struct bfd_arch_info *arch)
422 {
423   const struct bfd_arch_info *compat;
424   int ix;
425 
426   for (ix = 0; VEC_iterate (arch_p, target_desc->compatible, ix, compat);
427        ix++)
428     {
429       if (compat == arch
430 	  || arch->compatible (arch, compat)
431 	  || compat->compatible (compat, arch))
432 	return 1;
433     }
434 
435   return 0;
436 }
437 
438 
439 /* Direct accessors for target descriptions.  */
440 
441 /* Return the string value of a property named KEY, or NULL if the
442    property was not specified.  */
443 
444 const char *
tdesc_property(const struct target_desc * target_desc,const char * key)445 tdesc_property (const struct target_desc *target_desc, const char *key)
446 {
447   struct property *prop;
448   int ix;
449 
450   for (ix = 0; VEC_iterate (property_s, target_desc->properties, ix, prop);
451        ix++)
452     if (strcmp (prop->key, key) == 0)
453       return prop->value;
454 
455   return NULL;
456 }
457 
458 /* Return the BFD architecture associated with this target
459    description, or NULL if no architecture was specified.  */
460 
461 const struct bfd_arch_info *
tdesc_architecture(const struct target_desc * target_desc)462 tdesc_architecture (const struct target_desc *target_desc)
463 {
464   return target_desc->arch;
465 }
466 
467 /* Return the OSABI associated with this target description, or
468    GDB_OSABI_UNKNOWN if no osabi was specified.  */
469 
470 enum gdb_osabi
tdesc_osabi(const struct target_desc * target_desc)471 tdesc_osabi (const struct target_desc *target_desc)
472 {
473   return target_desc->osabi;
474 }
475 
476 
477 
478 /* Return 1 if this target description includes any registers.  */
479 
480 int
tdesc_has_registers(const struct target_desc * target_desc)481 tdesc_has_registers (const struct target_desc *target_desc)
482 {
483   int ix;
484   struct tdesc_feature *feature;
485 
486   if (target_desc == NULL)
487     return 0;
488 
489   for (ix = 0;
490        VEC_iterate (tdesc_feature_p, target_desc->features, ix, feature);
491        ix++)
492     if (! VEC_empty (tdesc_reg_p, feature->registers))
493       return 1;
494 
495   return 0;
496 }
497 
498 /* Return the feature with the given name, if present, or NULL if
499    the named feature is not found.  */
500 
501 const struct tdesc_feature *
tdesc_find_feature(const struct target_desc * target_desc,const char * name)502 tdesc_find_feature (const struct target_desc *target_desc,
503 		    const char *name)
504 {
505   int ix;
506   struct tdesc_feature *feature;
507 
508   for (ix = 0;
509        VEC_iterate (tdesc_feature_p, target_desc->features, ix, feature);
510        ix++)
511     if (strcmp (feature->name, name) == 0)
512       return feature;
513 
514   return NULL;
515 }
516 
517 /* Return the name of FEATURE.  */
518 
519 const char *
tdesc_feature_name(const struct tdesc_feature * feature)520 tdesc_feature_name (const struct tdesc_feature *feature)
521 {
522   return feature->name;
523 }
524 
525 /* Predefined types.  */
526 static struct tdesc_type tdesc_predefined_types[] =
527 {
528   { "int8", TDESC_TYPE_INT8 },
529   { "int16", TDESC_TYPE_INT16 },
530   { "int32", TDESC_TYPE_INT32 },
531   { "int64", TDESC_TYPE_INT64 },
532   { "int128", TDESC_TYPE_INT128 },
533   { "uint8", TDESC_TYPE_UINT8 },
534   { "uint16", TDESC_TYPE_UINT16 },
535   { "uint32", TDESC_TYPE_UINT32 },
536   { "uint64", TDESC_TYPE_UINT64 },
537   { "uint128", TDESC_TYPE_UINT128 },
538   { "code_ptr", TDESC_TYPE_CODE_PTR },
539   { "data_ptr", TDESC_TYPE_DATA_PTR },
540   { "ieee_single", TDESC_TYPE_IEEE_SINGLE },
541   { "ieee_double", TDESC_TYPE_IEEE_DOUBLE },
542   { "arm_fpa_ext", TDESC_TYPE_ARM_FPA_EXT },
543   { "i387_ext", TDESC_TYPE_I387_EXT }
544 };
545 
546 /* Return the type associated with ID in the context of FEATURE, or
547    NULL if none.  */
548 
549 struct tdesc_type *
tdesc_named_type(const struct tdesc_feature * feature,const char * id)550 tdesc_named_type (const struct tdesc_feature *feature, const char *id)
551 {
552   int ix;
553   struct tdesc_type *type;
554 
555   /* First try target-defined types.  */
556   for (ix = 0; VEC_iterate (tdesc_type_p, feature->types, ix, type); ix++)
557     if (strcmp (type->name, id) == 0)
558       return type;
559 
560   /* Next try the predefined types.  */
561   for (ix = 0; ix < ARRAY_SIZE (tdesc_predefined_types); ix++)
562     if (strcmp (tdesc_predefined_types[ix].name, id) == 0)
563       return &tdesc_predefined_types[ix];
564 
565   return NULL;
566 }
567 
568 /* Lookup type associated with ID.  */
569 
570 struct type *
tdesc_find_type(struct gdbarch * gdbarch,const char * id)571 tdesc_find_type (struct gdbarch *gdbarch, const char *id)
572 {
573   struct tdesc_arch_reg *reg;
574   struct tdesc_arch_data *data;
575   int i, num_regs;
576 
577   data = gdbarch_data (gdbarch, tdesc_data);
578   num_regs = VEC_length (tdesc_arch_reg, data->arch_regs);
579   for (i = 0; i < num_regs; i++)
580     {
581       reg = VEC_index (tdesc_arch_reg, data->arch_regs, i);
582       if (reg->reg
583 	  && reg->reg->tdesc_type
584 	  && reg->type
585 	  && strcmp (id, reg->reg->tdesc_type->name) == 0)
586 	return reg->type;
587     }
588 
589   return NULL;
590 }
591 
592 /* Construct, if necessary, and return the GDB type implementing target
593    type TDESC_TYPE for architecture GDBARCH.  */
594 
595 static struct type *
tdesc_gdb_type(struct gdbarch * gdbarch,struct tdesc_type * tdesc_type)596 tdesc_gdb_type (struct gdbarch *gdbarch, struct tdesc_type *tdesc_type)
597 {
598   struct type *type;
599 
600   switch (tdesc_type->kind)
601     {
602     /* Predefined types.  */
603     case TDESC_TYPE_INT8:
604       return builtin_type (gdbarch)->builtin_int8;
605 
606     case TDESC_TYPE_INT16:
607       return builtin_type (gdbarch)->builtin_int16;
608 
609     case TDESC_TYPE_INT32:
610       return builtin_type (gdbarch)->builtin_int32;
611 
612     case TDESC_TYPE_INT64:
613       return builtin_type (gdbarch)->builtin_int64;
614 
615     case TDESC_TYPE_INT128:
616       return builtin_type (gdbarch)->builtin_int128;
617 
618     case TDESC_TYPE_UINT8:
619       return builtin_type (gdbarch)->builtin_uint8;
620 
621     case TDESC_TYPE_UINT16:
622       return builtin_type (gdbarch)->builtin_uint16;
623 
624     case TDESC_TYPE_UINT32:
625       return builtin_type (gdbarch)->builtin_uint32;
626 
627     case TDESC_TYPE_UINT64:
628       return builtin_type (gdbarch)->builtin_uint64;
629 
630     case TDESC_TYPE_UINT128:
631       return builtin_type (gdbarch)->builtin_uint128;
632 
633     case TDESC_TYPE_CODE_PTR:
634       return builtin_type (gdbarch)->builtin_func_ptr;
635 
636     case TDESC_TYPE_DATA_PTR:
637       return builtin_type (gdbarch)->builtin_data_ptr;
638 
639     default:
640       break;
641     }
642 
643   type = tdesc_find_type (gdbarch, tdesc_type->name);
644   if (type)
645     return type;
646 
647   switch (tdesc_type->kind)
648     {
649     case TDESC_TYPE_IEEE_SINGLE:
650       return arch_float_type (gdbarch, -1, "builtin_type_ieee_single",
651 			      floatformats_ieee_single);
652 
653     case TDESC_TYPE_IEEE_DOUBLE:
654       return arch_float_type (gdbarch, -1, "builtin_type_ieee_double",
655 			      floatformats_ieee_double);
656 
657     case TDESC_TYPE_ARM_FPA_EXT:
658       return arch_float_type (gdbarch, -1, "builtin_type_arm_ext",
659 			      floatformats_arm_ext);
660 
661     case TDESC_TYPE_I387_EXT:
662       return arch_float_type (gdbarch, -1, "builtin_type_i387_ext",
663 			      floatformats_i387_ext);
664 
665     /* Types defined by a target feature.  */
666     case TDESC_TYPE_VECTOR:
667       {
668 	struct type *type, *field_type;
669 
670 	field_type = tdesc_gdb_type (gdbarch, tdesc_type->u.v.type);
671 	type = init_vector_type (field_type, tdesc_type->u.v.count);
672 	TYPE_NAME (type) = xstrdup (tdesc_type->name);
673 
674 	return type;
675       }
676 
677     case TDESC_TYPE_STRUCT:
678       {
679 	struct type *type, *field_type;
680 	struct tdesc_type_field *f;
681 	int ix;
682 
683 	type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
684 	TYPE_NAME (type) = xstrdup (tdesc_type->name);
685 	TYPE_TAG_NAME (type) = TYPE_NAME (type);
686 
687 	for (ix = 0;
688 	     VEC_iterate (tdesc_type_field, tdesc_type->u.u.fields, ix, f);
689 	     ix++)
690 	  {
691 	    if (f->type == NULL)
692 	      {
693 		/* Bitfield.  */
694 		struct field *fld;
695 		struct type *field_type;
696 		int bitsize, total_size;
697 
698 		/* This invariant should be preserved while creating
699 		   types.  */
700 		gdb_assert (tdesc_type->u.u.size != 0);
701 		if (tdesc_type->u.u.size > 4)
702 		  field_type = builtin_type (gdbarch)->builtin_uint64;
703 		else
704 		  field_type = builtin_type (gdbarch)->builtin_uint32;
705 
706 		fld = append_composite_type_field_raw (type, xstrdup (f->name),
707 						       field_type);
708 
709 		/* For little-endian, BITPOS counts from the LSB of
710 		   the structure and marks the LSB of the field.  For
711 		   big-endian, BITPOS counts from the MSB of the
712 		   structure and marks the MSB of the field.  Either
713 		   way, it is the number of bits to the "left" of the
714 		   field.  To calculate this in big-endian, we need
715 		   the total size of the structure.  */
716 		bitsize = f->end - f->start + 1;
717 		total_size = tdesc_type->u.u.size * TARGET_CHAR_BIT;
718 		if (gdbarch_bits_big_endian (gdbarch))
719 		  SET_FIELD_BITPOS (fld[0], total_size - f->start - bitsize);
720 		else
721 		  SET_FIELD_BITPOS (fld[0], f->start);
722 		FIELD_BITSIZE (fld[0]) = bitsize;
723 	      }
724 	    else
725 	      {
726 		field_type = tdesc_gdb_type (gdbarch, f->type);
727 		append_composite_type_field (type, xstrdup (f->name),
728 					     field_type);
729 	      }
730 	  }
731 
732 	if (tdesc_type->u.u.size != 0)
733 	  TYPE_LENGTH (type) = tdesc_type->u.u.size;
734 	return type;
735       }
736 
737     case TDESC_TYPE_UNION:
738       {
739 	struct type *type, *field_type;
740 	struct tdesc_type_field *f;
741 	int ix;
742 
743 	type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
744 	TYPE_NAME (type) = xstrdup (tdesc_type->name);
745 
746 	for (ix = 0;
747 	     VEC_iterate (tdesc_type_field, tdesc_type->u.u.fields, ix, f);
748 	     ix++)
749 	  {
750 	    field_type = tdesc_gdb_type (gdbarch, f->type);
751 	    append_composite_type_field (type, xstrdup (f->name), field_type);
752 
753 	    /* If any of the children of a union are vectors, flag the
754 	       union as a vector also.  This allows e.g. a union of two
755 	       vector types to show up automatically in "info vector".  */
756 	    if (TYPE_VECTOR (field_type))
757 	      TYPE_VECTOR (type) = 1;
758 	  }
759 	return type;
760       }
761 
762     case TDESC_TYPE_FLAGS:
763       {
764 	struct tdesc_type_flag *f;
765 	int ix;
766 
767 	type = arch_flags_type (gdbarch, tdesc_type->name,
768 				tdesc_type->u.f.size);
769 	for (ix = 0;
770 	     VEC_iterate (tdesc_type_flag, tdesc_type->u.f.flags, ix, f);
771 	     ix++)
772 	  /* Note that contrary to the function name, this call will
773 	     just set the properties of an already-allocated
774 	     field.  */
775 	  append_flags_type_flag (type, f->start,
776 				  *f->name ? f->name : NULL);
777 
778 	return type;
779       }
780     }
781 
782   internal_error (__FILE__, __LINE__,
783 		  "Type \"%s\" has an unknown kind %d",
784 		  tdesc_type->name, tdesc_type->kind);
785 }
786 
787 
788 /* Support for registers from target descriptions.  */
789 
790 /* Construct the per-gdbarch data.  */
791 
792 static void *
tdesc_data_init(struct obstack * obstack)793 tdesc_data_init (struct obstack *obstack)
794 {
795   struct tdesc_arch_data *data;
796 
797   data = OBSTACK_ZALLOC (obstack, struct tdesc_arch_data);
798   return data;
799 }
800 
801 /* Similar, but for the temporary copy used during architecture
802    initialization.  */
803 
804 struct tdesc_arch_data *
tdesc_data_alloc(void)805 tdesc_data_alloc (void)
806 {
807   return XZALLOC (struct tdesc_arch_data);
808 }
809 
810 /* Free something allocated by tdesc_data_alloc, if it is not going
811    to be used (for instance if it was unsuitable for the
812    architecture).  */
813 
814 void
tdesc_data_cleanup(void * data_untyped)815 tdesc_data_cleanup (void *data_untyped)
816 {
817   struct tdesc_arch_data *data = data_untyped;
818 
819   VEC_free (tdesc_arch_reg, data->arch_regs);
820   xfree (data);
821 }
822 
823 /* Search FEATURE for a register named NAME.  */
824 
825 static struct tdesc_reg *
tdesc_find_register_early(const struct tdesc_feature * feature,const char * name)826 tdesc_find_register_early (const struct tdesc_feature *feature,
827 			   const char *name)
828 {
829   int ixr;
830   struct tdesc_reg *reg;
831 
832   for (ixr = 0;
833        VEC_iterate (tdesc_reg_p, feature->registers, ixr, reg);
834        ixr++)
835     if (strcasecmp (reg->name, name) == 0)
836       return reg;
837 
838   return NULL;
839 }
840 
841 /* Search FEATURE for a register named NAME.  Assign REGNO to it.  */
842 
843 int
tdesc_numbered_register(const struct tdesc_feature * feature,struct tdesc_arch_data * data,int regno,const char * name)844 tdesc_numbered_register (const struct tdesc_feature *feature,
845 			 struct tdesc_arch_data *data,
846 			 int regno, const char *name)
847 {
848   struct tdesc_arch_reg arch_reg = { 0 };
849   struct tdesc_reg *reg = tdesc_find_register_early (feature, name);
850 
851   if (reg == NULL)
852     return 0;
853 
854   /* Make sure the vector includes a REGNO'th element.  */
855   while (regno >= VEC_length (tdesc_arch_reg, data->arch_regs))
856     VEC_safe_push (tdesc_arch_reg, data->arch_regs, &arch_reg);
857 
858   arch_reg.reg = reg;
859   VEC_replace (tdesc_arch_reg, data->arch_regs, regno, &arch_reg);
860   return 1;
861 }
862 
863 /* Search FEATURE for a register named NAME, but do not assign a fixed
864    register number to it.  */
865 
866 int
tdesc_unnumbered_register(const struct tdesc_feature * feature,const char * name)867 tdesc_unnumbered_register (const struct tdesc_feature *feature,
868 			   const char *name)
869 {
870   struct tdesc_reg *reg = tdesc_find_register_early (feature, name);
871 
872   if (reg == NULL)
873     return 0;
874 
875   return 1;
876 }
877 
878 /* Search FEATURE for a register whose name is in NAMES and assign
879    REGNO to it.  */
880 
881 int
tdesc_numbered_register_choices(const struct tdesc_feature * feature,struct tdesc_arch_data * data,int regno,const char * const names[])882 tdesc_numbered_register_choices (const struct tdesc_feature *feature,
883 				 struct tdesc_arch_data *data,
884 				 int regno, const char *const names[])
885 {
886   int i;
887 
888   for (i = 0; names[i] != NULL; i++)
889     if (tdesc_numbered_register (feature, data, regno, names[i]))
890       return 1;
891 
892   return 0;
893 }
894 
895 /* Search FEATURE for a register named NAME, and return its size in
896    bits.  The register must exist.  */
897 
898 int
tdesc_register_size(const struct tdesc_feature * feature,const char * name)899 tdesc_register_size (const struct tdesc_feature *feature,
900 		     const char *name)
901 {
902   struct tdesc_reg *reg = tdesc_find_register_early (feature, name);
903 
904   gdb_assert (reg != NULL);
905   return reg->bitsize;
906 }
907 
908 /* Look up a register by its GDB internal register number.  */
909 
910 static struct tdesc_arch_reg *
tdesc_find_arch_register(struct gdbarch * gdbarch,int regno)911 tdesc_find_arch_register (struct gdbarch *gdbarch, int regno)
912 {
913   struct tdesc_arch_data *data;
914 
915   data = gdbarch_data (gdbarch, tdesc_data);
916   if (regno < VEC_length (tdesc_arch_reg, data->arch_regs))
917     return VEC_index (tdesc_arch_reg, data->arch_regs, regno);
918   else
919     return NULL;
920 }
921 
922 static struct tdesc_reg *
tdesc_find_register(struct gdbarch * gdbarch,int regno)923 tdesc_find_register (struct gdbarch *gdbarch, int regno)
924 {
925   struct tdesc_arch_reg *reg = tdesc_find_arch_register (gdbarch, regno);
926 
927   return reg? reg->reg : NULL;
928 }
929 
930 /* Return the name of register REGNO, from the target description or
931    from an architecture-provided pseudo_register_name method.  */
932 
933 const char *
tdesc_register_name(struct gdbarch * gdbarch,int regno)934 tdesc_register_name (struct gdbarch *gdbarch, int regno)
935 {
936   struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
937   int num_regs = gdbarch_num_regs (gdbarch);
938   int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
939 
940   if (reg != NULL)
941     return reg->name;
942 
943   if (regno >= num_regs && regno < num_regs + num_pseudo_regs)
944     {
945       struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
946 
947       gdb_assert (data->pseudo_register_name != NULL);
948       return data->pseudo_register_name (gdbarch, regno);
949     }
950 
951   return "";
952 }
953 
954 struct type *
tdesc_register_type(struct gdbarch * gdbarch,int regno)955 tdesc_register_type (struct gdbarch *gdbarch, int regno)
956 {
957   struct tdesc_arch_reg *arch_reg = tdesc_find_arch_register (gdbarch, regno);
958   struct tdesc_reg *reg = arch_reg? arch_reg->reg : NULL;
959   int num_regs = gdbarch_num_regs (gdbarch);
960   int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
961 
962   if (reg == NULL && regno >= num_regs && regno < num_regs + num_pseudo_regs)
963     {
964       struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
965 
966       gdb_assert (data->pseudo_register_type != NULL);
967       return data->pseudo_register_type (gdbarch, regno);
968     }
969 
970   if (reg == NULL)
971     /* Return "int0_t", since "void" has a misleading size of one.  */
972     return builtin_type (gdbarch)->builtin_int0;
973 
974   if (arch_reg->type == NULL)
975     {
976       /* First check for a predefined or target defined type.  */
977       if (reg->tdesc_type)
978         arch_reg->type = tdesc_gdb_type (gdbarch, reg->tdesc_type);
979 
980       /* Next try size-sensitive type shortcuts.  */
981       else if (strcmp (reg->type, "float") == 0)
982 	{
983 	  if (reg->bitsize == gdbarch_float_bit (gdbarch))
984 	    arch_reg->type = builtin_type (gdbarch)->builtin_float;
985 	  else if (reg->bitsize == gdbarch_double_bit (gdbarch))
986 	    arch_reg->type = builtin_type (gdbarch)->builtin_double;
987 	  else if (reg->bitsize == gdbarch_long_double_bit (gdbarch))
988 	    arch_reg->type = builtin_type (gdbarch)->builtin_long_double;
989 	  else
990 	    {
991 	      warning (_("Register \"%s\" has an unsupported size (%d bits)"),
992 		       reg->name, reg->bitsize);
993 	      arch_reg->type = builtin_type (gdbarch)->builtin_double;
994 	    }
995 	}
996       else if (strcmp (reg->type, "int") == 0)
997 	{
998 	  if (reg->bitsize == gdbarch_long_bit (gdbarch))
999 	    arch_reg->type = builtin_type (gdbarch)->builtin_long;
1000 	  else if (reg->bitsize == TARGET_CHAR_BIT)
1001 	    arch_reg->type = builtin_type (gdbarch)->builtin_char;
1002 	  else if (reg->bitsize == gdbarch_short_bit (gdbarch))
1003 	    arch_reg->type = builtin_type (gdbarch)->builtin_short;
1004 	  else if (reg->bitsize == gdbarch_int_bit (gdbarch))
1005 	    arch_reg->type = builtin_type (gdbarch)->builtin_int;
1006 	  else if (reg->bitsize == gdbarch_long_long_bit (gdbarch))
1007 	    arch_reg->type = builtin_type (gdbarch)->builtin_long_long;
1008 	  else if (reg->bitsize == gdbarch_ptr_bit (gdbarch))
1009 	  /* A bit desperate by this point...  */
1010 	    arch_reg->type = builtin_type (gdbarch)->builtin_data_ptr;
1011 	  else
1012 	    {
1013 	      warning (_("Register \"%s\" has an unsupported size (%d bits)"),
1014 		       reg->name, reg->bitsize);
1015 	      arch_reg->type = builtin_type (gdbarch)->builtin_long;
1016 	    }
1017 	}
1018 
1019       if (arch_reg->type == NULL)
1020 	internal_error (__FILE__, __LINE__,
1021 			"Register \"%s\" has an unknown type \"%s\"",
1022 			reg->name, reg->type);
1023     }
1024 
1025   return arch_reg->type;
1026 }
1027 
1028 static int
tdesc_remote_register_number(struct gdbarch * gdbarch,int regno)1029 tdesc_remote_register_number (struct gdbarch *gdbarch, int regno)
1030 {
1031   struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
1032 
1033   if (reg != NULL)
1034     return reg->target_regnum;
1035   else
1036     return -1;
1037 }
1038 
1039 /* Check whether REGNUM is a member of REGGROUP.  Registers from the
1040    target description may be classified as general, float, or vector.
1041    Unlike a gdbarch register_reggroup_p method, this function will
1042    return -1 if it does not know; the caller should handle registers
1043    with no specified group.
1044 
1045    Arbitrary strings (other than "general", "float", and "vector")
1046    from the description are not used; they cause the register to be
1047    displayed in "info all-registers" but excluded from "info
1048    registers" et al.  The names of containing features are also not
1049    used.  This might be extended to display registers in some more
1050    useful groupings.
1051 
1052    The save-restore flag is also implemented here.  */
1053 
1054 int
tdesc_register_in_reggroup_p(struct gdbarch * gdbarch,int regno,struct reggroup * reggroup)1055 tdesc_register_in_reggroup_p (struct gdbarch *gdbarch, int regno,
1056 			      struct reggroup *reggroup)
1057 {
1058   struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
1059 
1060   if (reg != NULL && reg->group != NULL)
1061     {
1062       int general_p = 0, float_p = 0, vector_p = 0;
1063 
1064       if (strcmp (reg->group, "general") == 0)
1065 	general_p = 1;
1066       else if (strcmp (reg->group, "float") == 0)
1067 	float_p = 1;
1068       else if (strcmp (reg->group, "vector") == 0)
1069 	vector_p = 1;
1070 
1071       if (reggroup == float_reggroup)
1072 	return float_p;
1073 
1074       if (reggroup == vector_reggroup)
1075 	return vector_p;
1076 
1077       if (reggroup == general_reggroup)
1078 	return general_p;
1079     }
1080 
1081   if (reg != NULL
1082       && (reggroup == save_reggroup || reggroup == restore_reggroup))
1083     return reg->save_restore;
1084 
1085   return -1;
1086 }
1087 
1088 /* Check whether REGNUM is a member of REGGROUP.  Registers with no
1089    group specified go to the default reggroup function and are handled
1090    by type.  */
1091 
1092 static int
tdesc_register_reggroup_p(struct gdbarch * gdbarch,int regno,struct reggroup * reggroup)1093 tdesc_register_reggroup_p (struct gdbarch *gdbarch, int regno,
1094 			   struct reggroup *reggroup)
1095 {
1096   int num_regs = gdbarch_num_regs (gdbarch);
1097   int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
1098   int ret;
1099 
1100   if (regno >= num_regs && regno < num_regs + num_pseudo_regs)
1101     {
1102       struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
1103 
1104       if (data->pseudo_register_reggroup_p != NULL)
1105 	return data->pseudo_register_reggroup_p (gdbarch, regno, reggroup);
1106       /* Otherwise fall through to the default reggroup_p.  */
1107     }
1108 
1109   ret = tdesc_register_in_reggroup_p (gdbarch, regno, reggroup);
1110   if (ret != -1)
1111     return ret;
1112 
1113   return default_register_reggroup_p (gdbarch, regno, reggroup);
1114 }
1115 
1116 /* Record architecture-specific functions to call for pseudo-register
1117    support.  */
1118 
1119 void
set_tdesc_pseudo_register_name(struct gdbarch * gdbarch,gdbarch_register_name_ftype * pseudo_name)1120 set_tdesc_pseudo_register_name (struct gdbarch *gdbarch,
1121 				gdbarch_register_name_ftype *pseudo_name)
1122 {
1123   struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
1124 
1125   data->pseudo_register_name = pseudo_name;
1126 }
1127 
1128 void
set_tdesc_pseudo_register_type(struct gdbarch * gdbarch,gdbarch_register_type_ftype * pseudo_type)1129 set_tdesc_pseudo_register_type (struct gdbarch *gdbarch,
1130 				gdbarch_register_type_ftype *pseudo_type)
1131 {
1132   struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
1133 
1134   data->pseudo_register_type = pseudo_type;
1135 }
1136 
1137 void
set_tdesc_pseudo_register_reggroup_p(struct gdbarch * gdbarch,gdbarch_register_reggroup_p_ftype * pseudo_reggroup_p)1138 set_tdesc_pseudo_register_reggroup_p
1139   (struct gdbarch *gdbarch,
1140    gdbarch_register_reggroup_p_ftype *pseudo_reggroup_p)
1141 {
1142   struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
1143 
1144   data->pseudo_register_reggroup_p = pseudo_reggroup_p;
1145 }
1146 
1147 /* Update GDBARCH to use the target description for registers.  */
1148 
1149 void
tdesc_use_registers(struct gdbarch * gdbarch,const struct target_desc * target_desc,struct tdesc_arch_data * early_data)1150 tdesc_use_registers (struct gdbarch *gdbarch,
1151 		     const struct target_desc *target_desc,
1152 		     struct tdesc_arch_data *early_data)
1153 {
1154   int num_regs = gdbarch_num_regs (gdbarch);
1155   int ixf, ixr;
1156   struct tdesc_feature *feature;
1157   struct tdesc_reg *reg;
1158   struct tdesc_arch_data *data;
1159   struct tdesc_arch_reg *arch_reg, new_arch_reg = { 0 };
1160   htab_t reg_hash;
1161 
1162   /* We can't use the description for registers if it doesn't describe
1163      any.  This function should only be called after validating
1164      registers, so the caller should know that registers are
1165      included.  */
1166   gdb_assert (tdesc_has_registers (target_desc));
1167 
1168   data = gdbarch_data (gdbarch, tdesc_data);
1169   data->arch_regs = early_data->arch_regs;
1170   xfree (early_data);
1171 
1172   /* Build up a set of all registers, so that we can assign register
1173      numbers where needed.  The hash table expands as necessary, so
1174      the initial size is arbitrary.  */
1175   reg_hash = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
1176   for (ixf = 0;
1177        VEC_iterate (tdesc_feature_p, target_desc->features, ixf, feature);
1178        ixf++)
1179     for (ixr = 0;
1180 	 VEC_iterate (tdesc_reg_p, feature->registers, ixr, reg);
1181 	 ixr++)
1182       {
1183 	void **slot = htab_find_slot (reg_hash, reg, INSERT);
1184 
1185 	*slot = reg;
1186       }
1187 
1188   /* Remove any registers which were assigned numbers by the
1189      architecture.  */
1190   for (ixr = 0;
1191        VEC_iterate (tdesc_arch_reg, data->arch_regs, ixr, arch_reg);
1192        ixr++)
1193     if (arch_reg->reg)
1194       htab_remove_elt (reg_hash, arch_reg->reg);
1195 
1196   /* Assign numbers to the remaining registers and add them to the
1197      list of registers.  The new numbers are always above gdbarch_num_regs.
1198      Iterate over the features, not the hash table, so that the order
1199      matches that in the target description.  */
1200 
1201   gdb_assert (VEC_length (tdesc_arch_reg, data->arch_regs) <= num_regs);
1202   while (VEC_length (tdesc_arch_reg, data->arch_regs) < num_regs)
1203     VEC_safe_push (tdesc_arch_reg, data->arch_regs, &new_arch_reg);
1204   for (ixf = 0;
1205        VEC_iterate (tdesc_feature_p, target_desc->features, ixf, feature);
1206        ixf++)
1207     for (ixr = 0;
1208 	 VEC_iterate (tdesc_reg_p, feature->registers, ixr, reg);
1209 	 ixr++)
1210       if (htab_find (reg_hash, reg) != NULL)
1211 	{
1212 	  new_arch_reg.reg = reg;
1213 	  VEC_safe_push (tdesc_arch_reg, data->arch_regs, &new_arch_reg);
1214 	  num_regs++;
1215 	}
1216 
1217   htab_delete (reg_hash);
1218 
1219   /* Update the architecture.  */
1220   set_gdbarch_num_regs (gdbarch, num_regs);
1221   set_gdbarch_register_name (gdbarch, tdesc_register_name);
1222   set_gdbarch_register_type (gdbarch, tdesc_register_type);
1223   set_gdbarch_remote_register_number (gdbarch,
1224 				      tdesc_remote_register_number);
1225   set_gdbarch_register_reggroup_p (gdbarch, tdesc_register_reggroup_p);
1226 }
1227 
1228 
1229 /* Methods for constructing a target description.  */
1230 
1231 static void
tdesc_free_reg(struct tdesc_reg * reg)1232 tdesc_free_reg (struct tdesc_reg *reg)
1233 {
1234   xfree (reg->name);
1235   xfree (reg->type);
1236   xfree (reg->group);
1237   xfree (reg);
1238 }
1239 
1240 void
tdesc_create_reg(struct tdesc_feature * feature,const char * name,int regnum,int save_restore,const char * group,int bitsize,const char * type)1241 tdesc_create_reg (struct tdesc_feature *feature, const char *name,
1242 		  int regnum, int save_restore, const char *group,
1243 		  int bitsize, const char *type)
1244 {
1245   struct tdesc_reg *reg = XZALLOC (struct tdesc_reg);
1246 
1247   reg->name = xstrdup (name);
1248   reg->target_regnum = regnum;
1249   reg->save_restore = save_restore;
1250   reg->group = group ? xstrdup (group) : NULL;
1251   reg->bitsize = bitsize;
1252   reg->type = type ? xstrdup (type) : xstrdup ("<unknown>");
1253 
1254   /* If the register's type is target-defined, look it up now.  We may not
1255      have easy access to the containing feature when we want it later.  */
1256   reg->tdesc_type = tdesc_named_type (feature, reg->type);
1257 
1258   VEC_safe_push (tdesc_reg_p, feature->registers, reg);
1259 }
1260 
1261 static void
tdesc_free_type(struct tdesc_type * type)1262 tdesc_free_type (struct tdesc_type *type)
1263 {
1264   switch (type->kind)
1265     {
1266     case TDESC_TYPE_STRUCT:
1267     case TDESC_TYPE_UNION:
1268       {
1269 	struct tdesc_type_field *f;
1270 	int ix;
1271 
1272 	for (ix = 0;
1273 	     VEC_iterate (tdesc_type_field, type->u.u.fields, ix, f);
1274 	     ix++)
1275 	  xfree (f->name);
1276 
1277 	VEC_free (tdesc_type_field, type->u.u.fields);
1278       }
1279       break;
1280 
1281     case TDESC_TYPE_FLAGS:
1282       {
1283 	struct tdesc_type_flag *f;
1284 	int ix;
1285 
1286 	for (ix = 0;
1287 	     VEC_iterate (tdesc_type_flag, type->u.f.flags, ix, f);
1288 	     ix++)
1289 	  xfree (f->name);
1290 
1291 	VEC_free (tdesc_type_flag, type->u.f.flags);
1292       }
1293       break;
1294 
1295     default:
1296       break;
1297     }
1298 
1299   xfree (type->name);
1300   xfree (type);
1301 }
1302 
1303 struct tdesc_type *
tdesc_create_vector(struct tdesc_feature * feature,const char * name,struct tdesc_type * field_type,int count)1304 tdesc_create_vector (struct tdesc_feature *feature, const char *name,
1305 		     struct tdesc_type *field_type, int count)
1306 {
1307   struct tdesc_type *type = XZALLOC (struct tdesc_type);
1308 
1309   type->name = xstrdup (name);
1310   type->kind = TDESC_TYPE_VECTOR;
1311   type->u.v.type = field_type;
1312   type->u.v.count = count;
1313 
1314   VEC_safe_push (tdesc_type_p, feature->types, type);
1315   return type;
1316 }
1317 
1318 struct tdesc_type *
tdesc_create_struct(struct tdesc_feature * feature,const char * name)1319 tdesc_create_struct (struct tdesc_feature *feature, const char *name)
1320 {
1321   struct tdesc_type *type = XZALLOC (struct tdesc_type);
1322 
1323   type->name = xstrdup (name);
1324   type->kind = TDESC_TYPE_STRUCT;
1325 
1326   VEC_safe_push (tdesc_type_p, feature->types, type);
1327   return type;
1328 }
1329 
1330 /* Set the total length of TYPE.  Structs which contain bitfields may
1331    omit the reserved bits, so the end of the last field may not
1332    suffice.  */
1333 
1334 void
tdesc_set_struct_size(struct tdesc_type * type,LONGEST size)1335 tdesc_set_struct_size (struct tdesc_type *type, LONGEST size)
1336 {
1337   gdb_assert (type->kind == TDESC_TYPE_STRUCT);
1338   type->u.u.size = size;
1339 }
1340 
1341 struct tdesc_type *
tdesc_create_union(struct tdesc_feature * feature,const char * name)1342 tdesc_create_union (struct tdesc_feature *feature, const char *name)
1343 {
1344   struct tdesc_type *type = XZALLOC (struct tdesc_type);
1345 
1346   type->name = xstrdup (name);
1347   type->kind = TDESC_TYPE_UNION;
1348 
1349   VEC_safe_push (tdesc_type_p, feature->types, type);
1350   return type;
1351 }
1352 
1353 struct tdesc_type *
tdesc_create_flags(struct tdesc_feature * feature,const char * name,LONGEST size)1354 tdesc_create_flags (struct tdesc_feature *feature, const char *name,
1355 		    LONGEST size)
1356 {
1357   struct tdesc_type *type = XZALLOC (struct tdesc_type);
1358 
1359   type->name = xstrdup (name);
1360   type->kind = TDESC_TYPE_FLAGS;
1361   type->u.f.size = size;
1362 
1363   VEC_safe_push (tdesc_type_p, feature->types, type);
1364   return type;
1365 }
1366 
1367 /* Add a new field.  Return a temporary pointer to the field, which
1368    is only valid until the next call to tdesc_add_field (the vector
1369    might be reallocated).  */
1370 
1371 void
tdesc_add_field(struct tdesc_type * type,const char * field_name,struct tdesc_type * field_type)1372 tdesc_add_field (struct tdesc_type *type, const char *field_name,
1373 		 struct tdesc_type *field_type)
1374 {
1375   struct tdesc_type_field f = { 0 };
1376 
1377   gdb_assert (type->kind == TDESC_TYPE_UNION
1378 	      || type->kind == TDESC_TYPE_STRUCT);
1379 
1380   f.name = xstrdup (field_name);
1381   f.type = field_type;
1382 
1383   VEC_safe_push (tdesc_type_field, type->u.u.fields, &f);
1384 }
1385 
1386 /* Add a new bitfield.  */
1387 
1388 void
tdesc_add_bitfield(struct tdesc_type * type,const char * field_name,int start,int end)1389 tdesc_add_bitfield (struct tdesc_type *type, const char *field_name,
1390 		    int start, int end)
1391 {
1392   struct tdesc_type_field f = { 0 };
1393 
1394   gdb_assert (type->kind == TDESC_TYPE_STRUCT);
1395 
1396   f.name = xstrdup (field_name);
1397   f.start = start;
1398   f.end = end;
1399 
1400   VEC_safe_push (tdesc_type_field, type->u.u.fields, &f);
1401 }
1402 
1403 void
tdesc_add_flag(struct tdesc_type * type,int start,const char * flag_name)1404 tdesc_add_flag (struct tdesc_type *type, int start,
1405 		const char *flag_name)
1406 {
1407   struct tdesc_type_flag f = { 0 };
1408 
1409   gdb_assert (type->kind == TDESC_TYPE_FLAGS);
1410 
1411   f.name = xstrdup (flag_name);
1412   f.start = start;
1413 
1414   VEC_safe_push (tdesc_type_flag, type->u.f.flags, &f);
1415 }
1416 
1417 static void
tdesc_free_feature(struct tdesc_feature * feature)1418 tdesc_free_feature (struct tdesc_feature *feature)
1419 {
1420   struct tdesc_reg *reg;
1421   struct tdesc_type *type;
1422   int ix;
1423 
1424   for (ix = 0; VEC_iterate (tdesc_reg_p, feature->registers, ix, reg); ix++)
1425     tdesc_free_reg (reg);
1426   VEC_free (tdesc_reg_p, feature->registers);
1427 
1428   for (ix = 0; VEC_iterate (tdesc_type_p, feature->types, ix, type); ix++)
1429     tdesc_free_type (type);
1430   VEC_free (tdesc_type_p, feature->types);
1431 
1432   xfree (feature->name);
1433   xfree (feature);
1434 }
1435 
1436 struct tdesc_feature *
tdesc_create_feature(struct target_desc * tdesc,const char * name)1437 tdesc_create_feature (struct target_desc *tdesc, const char *name)
1438 {
1439   struct tdesc_feature *new_feature = XZALLOC (struct tdesc_feature);
1440 
1441   new_feature->name = xstrdup (name);
1442 
1443   VEC_safe_push (tdesc_feature_p, tdesc->features, new_feature);
1444   return new_feature;
1445 }
1446 
1447 struct target_desc *
allocate_target_description(void)1448 allocate_target_description (void)
1449 {
1450   return XZALLOC (struct target_desc);
1451 }
1452 
1453 static void
free_target_description(void * arg)1454 free_target_description (void *arg)
1455 {
1456   struct target_desc *target_desc = arg;
1457   struct tdesc_feature *feature;
1458   struct property *prop;
1459   int ix;
1460 
1461   for (ix = 0;
1462        VEC_iterate (tdesc_feature_p, target_desc->features, ix, feature);
1463        ix++)
1464     tdesc_free_feature (feature);
1465   VEC_free (tdesc_feature_p, target_desc->features);
1466 
1467   for (ix = 0;
1468        VEC_iterate (property_s, target_desc->properties, ix, prop);
1469        ix++)
1470     {
1471       xfree (prop->key);
1472       xfree (prop->value);
1473     }
1474   VEC_free (property_s, target_desc->properties);
1475 
1476   VEC_free (arch_p, target_desc->compatible);
1477 
1478   xfree (target_desc);
1479 }
1480 
1481 struct cleanup *
make_cleanup_free_target_description(struct target_desc * target_desc)1482 make_cleanup_free_target_description (struct target_desc *target_desc)
1483 {
1484   return make_cleanup (free_target_description, target_desc);
1485 }
1486 
1487 void
tdesc_add_compatible(struct target_desc * target_desc,const struct bfd_arch_info * compatible)1488 tdesc_add_compatible (struct target_desc *target_desc,
1489 		      const struct bfd_arch_info *compatible)
1490 {
1491   const struct bfd_arch_info *compat;
1492   int ix;
1493 
1494   /* If this instance of GDB is compiled without BFD support for the
1495      compatible architecture, simply ignore it -- we would not be able
1496      to handle it anyway.  */
1497   if (compatible == NULL)
1498     return;
1499 
1500   for (ix = 0; VEC_iterate (arch_p, target_desc->compatible, ix, compat);
1501        ix++)
1502     if (compat == compatible)
1503       internal_error (__FILE__, __LINE__,
1504 		      _("Attempted to add duplicate "
1505 			"compatible architecture \"%s\""),
1506 		      compatible->printable_name);
1507 
1508   VEC_safe_push (arch_p, target_desc->compatible, compatible);
1509 }
1510 
1511 void
set_tdesc_property(struct target_desc * target_desc,const char * key,const char * value)1512 set_tdesc_property (struct target_desc *target_desc,
1513 		    const char *key, const char *value)
1514 {
1515   struct property *prop, new_prop;
1516   int ix;
1517 
1518   gdb_assert (key != NULL && value != NULL);
1519 
1520   for (ix = 0; VEC_iterate (property_s, target_desc->properties, ix, prop);
1521        ix++)
1522     if (strcmp (prop->key, key) == 0)
1523       internal_error (__FILE__, __LINE__,
1524 		      _("Attempted to add duplicate property \"%s\""), key);
1525 
1526   new_prop.key = xstrdup (key);
1527   new_prop.value = xstrdup (value);
1528   VEC_safe_push (property_s, target_desc->properties, &new_prop);
1529 }
1530 
1531 void
set_tdesc_architecture(struct target_desc * target_desc,const struct bfd_arch_info * arch)1532 set_tdesc_architecture (struct target_desc *target_desc,
1533 			const struct bfd_arch_info *arch)
1534 {
1535   target_desc->arch = arch;
1536 }
1537 
1538 void
set_tdesc_osabi(struct target_desc * target_desc,enum gdb_osabi osabi)1539 set_tdesc_osabi (struct target_desc *target_desc, enum gdb_osabi osabi)
1540 {
1541   target_desc->osabi = osabi;
1542 }
1543 
1544 
1545 static struct cmd_list_element *tdesc_set_cmdlist, *tdesc_show_cmdlist;
1546 static struct cmd_list_element *tdesc_unset_cmdlist;
1547 
1548 /* Helper functions for the CLI commands.  */
1549 
1550 static void
set_tdesc_cmd(char * args,int from_tty)1551 set_tdesc_cmd (char *args, int from_tty)
1552 {
1553   help_list (tdesc_set_cmdlist, "set tdesc ", -1, gdb_stdout);
1554 }
1555 
1556 static void
show_tdesc_cmd(char * args,int from_tty)1557 show_tdesc_cmd (char *args, int from_tty)
1558 {
1559   cmd_show_list (tdesc_show_cmdlist, from_tty, "");
1560 }
1561 
1562 static void
unset_tdesc_cmd(char * args,int from_tty)1563 unset_tdesc_cmd (char *args, int from_tty)
1564 {
1565   help_list (tdesc_unset_cmdlist, "unset tdesc ", -1, gdb_stdout);
1566 }
1567 
1568 static void
set_tdesc_filename_cmd(char * args,int from_tty,struct cmd_list_element * c)1569 set_tdesc_filename_cmd (char *args, int from_tty,
1570 			struct cmd_list_element *c)
1571 {
1572   xfree (target_description_filename);
1573   target_description_filename = xstrdup (tdesc_filename_cmd_string);
1574 
1575   target_clear_description ();
1576   target_find_description ();
1577 }
1578 
1579 static void
show_tdesc_filename_cmd(struct ui_file * file,int from_tty,struct cmd_list_element * c,const char * value)1580 show_tdesc_filename_cmd (struct ui_file *file, int from_tty,
1581 			 struct cmd_list_element *c,
1582 			 const char *value)
1583 {
1584   value = target_description_filename;
1585 
1586   if (value != NULL && *value != '\0')
1587     printf_filtered (_("The target description will be read from \"%s\".\n"),
1588 		     value);
1589   else
1590     printf_filtered (_("The target description will be "
1591 		       "read from the target.\n"));
1592 }
1593 
1594 static void
unset_tdesc_filename_cmd(char * args,int from_tty)1595 unset_tdesc_filename_cmd (char *args, int from_tty)
1596 {
1597   xfree (target_description_filename);
1598   target_description_filename = NULL;
1599   target_clear_description ();
1600   target_find_description ();
1601 }
1602 
1603 static void
maint_print_c_tdesc_cmd(char * args,int from_tty)1604 maint_print_c_tdesc_cmd (char *args, int from_tty)
1605 {
1606   const struct target_desc *tdesc;
1607   const struct bfd_arch_info *compatible;
1608   const char *filename, *inp;
1609   char *function, *outp;
1610   struct property *prop;
1611   struct tdesc_feature *feature;
1612   struct tdesc_reg *reg;
1613   struct tdesc_type *type;
1614   struct tdesc_type_field *f;
1615   struct tdesc_type_flag *flag;
1616   int ix, ix2, ix3;
1617   int printed_field_type = 0;
1618 
1619   /* Use the global target-supplied description, not the current
1620      architecture's.  This lets a GDB for one architecture generate C
1621      for another architecture's description, even though the gdbarch
1622      initialization code will reject the new description.  */
1623   tdesc = current_target_desc;
1624   if (tdesc == NULL)
1625     error (_("There is no target description to print."));
1626 
1627   if (target_description_filename == NULL)
1628     error (_("The current target description did not come from an XML file."));
1629 
1630   filename = lbasename (target_description_filename);
1631   function = alloca (strlen (filename) + 1);
1632   for (inp = filename, outp = function; *inp != '\0'; inp++)
1633     if (*inp == '.')
1634       break;
1635     else if (*inp == '-')
1636       *outp++ = '_';
1637     else
1638       *outp++ = *inp;
1639   *outp = '\0';
1640 
1641   /* Standard boilerplate.  */
1642   printf_unfiltered ("/* THIS FILE IS GENERATED.  "
1643 		     "-*- buffer-read-only: t -*- vi"
1644 		     ":set ro:\n");
1645   printf_unfiltered ("  Original: %s */\n\n", filename);
1646   printf_unfiltered ("#include \"defs.h\"\n");
1647   printf_unfiltered ("#include \"osabi.h\"\n");
1648   printf_unfiltered ("#include \"target-descriptions.h\"\n");
1649   printf_unfiltered ("\n");
1650 
1651   printf_unfiltered ("struct target_desc *tdesc_%s;\n", function);
1652   printf_unfiltered ("static void\n");
1653   printf_unfiltered ("initialize_tdesc_%s (void)\n", function);
1654   printf_unfiltered ("{\n");
1655   printf_unfiltered
1656     ("  struct target_desc *result = allocate_target_description ();\n");
1657   printf_unfiltered ("  struct tdesc_feature *feature;\n");
1658 
1659   /* Now we do some "filtering" in order to know which variables to
1660      declare.  This is needed because otherwise we would declare unused
1661      variables `field_type' and `type'.  */
1662   for (ix = 0;
1663        VEC_iterate (tdesc_feature_p, tdesc->features, ix, feature);
1664        ix++)
1665     {
1666       int printed_desc_type = 0;
1667 
1668       for (ix2 = 0;
1669 	   VEC_iterate (tdesc_type_p, feature->types, ix2, type);
1670 	   ix2++)
1671 	{
1672 	  if (!printed_field_type)
1673 	    {
1674 	      printf_unfiltered ("  struct tdesc_type *field_type;\n");
1675 	      printed_field_type = 1;
1676 	    }
1677 
1678 	  if (type->kind == TDESC_TYPE_UNION
1679 	      && VEC_length (tdesc_type_field, type->u.u.fields) > 0)
1680 	    {
1681 	      printf_unfiltered ("  struct tdesc_type *type;\n");
1682 	      printed_desc_type = 1;
1683 	      break;
1684 	    }
1685 	}
1686 
1687       if (printed_desc_type)
1688 	break;
1689     }
1690 
1691   printf_unfiltered ("\n");
1692 
1693   if (tdesc_architecture (tdesc) != NULL)
1694     {
1695       printf_unfiltered
1696 	("  set_tdesc_architecture (result, bfd_scan_arch (\"%s\"));\n",
1697 	 tdesc_architecture (tdesc)->printable_name);
1698       printf_unfiltered ("\n");
1699     }
1700 
1701   if (tdesc_osabi (tdesc) > GDB_OSABI_UNKNOWN
1702       && tdesc_osabi (tdesc) < GDB_OSABI_INVALID)
1703     {
1704       printf_unfiltered
1705 	("  set_tdesc_osabi (result, osabi_from_tdesc_string (\"%s\"));\n",
1706 	 gdbarch_osabi_name (tdesc_osabi (tdesc)));
1707       printf_unfiltered ("\n");
1708     }
1709 
1710   for (ix = 0; VEC_iterate (arch_p, tdesc->compatible, ix, compatible);
1711        ix++)
1712     {
1713       printf_unfiltered
1714 	("  tdesc_add_compatible (result, bfd_scan_arch (\"%s\"));\n",
1715 	 compatible->printable_name);
1716     }
1717   if (ix)
1718     printf_unfiltered ("\n");
1719 
1720   for (ix = 0; VEC_iterate (property_s, tdesc->properties, ix, prop);
1721        ix++)
1722     {
1723       printf_unfiltered ("  set_tdesc_property (result, \"%s\", \"%s\");\n",
1724 	      prop->key, prop->value);
1725     }
1726 
1727   for (ix = 0;
1728        VEC_iterate (tdesc_feature_p, tdesc->features, ix, feature);
1729        ix++)
1730     {
1731       printf_unfiltered ("  \
1732 feature = tdesc_create_feature (result, \"%s\");\n",
1733 			 feature->name);
1734 
1735       for (ix2 = 0;
1736 	   VEC_iterate (tdesc_type_p, feature->types, ix2, type);
1737 	   ix2++)
1738 	{
1739 	  switch (type->kind)
1740 	    {
1741 	    case TDESC_TYPE_VECTOR:
1742 	      printf_unfiltered
1743 		("  field_type = tdesc_named_type (feature, \"%s\");\n",
1744 		 type->u.v.type->name);
1745 	      printf_unfiltered
1746 		("  tdesc_create_vector (feature, \"%s\", field_type, %d);\n",
1747 		 type->name, type->u.v.count);
1748 	      break;
1749 	    case TDESC_TYPE_UNION:
1750 	      printf_unfiltered
1751 		("  type = tdesc_create_union (feature, \"%s\");\n",
1752 		 type->name);
1753 	      for (ix3 = 0;
1754 		   VEC_iterate (tdesc_type_field, type->u.u.fields, ix3, f);
1755 		   ix3++)
1756 		{
1757 		  printf_unfiltered
1758 		    ("  field_type = tdesc_named_type (feature, \"%s\");\n",
1759 		     f->type->name);
1760 		  printf_unfiltered
1761 		    ("  tdesc_add_field (type, \"%s\", field_type);\n",
1762 		     f->name);
1763 		}
1764 	      break;
1765 	    case TDESC_TYPE_FLAGS:
1766 	      printf_unfiltered
1767 		("  field_type = tdesc_create_flags (feature, \"%s\", %d);\n",
1768 		 type->name, (int) type->u.f.size);
1769 	      for (ix3 = 0;
1770 		   VEC_iterate (tdesc_type_flag, type->u.f.flags, ix3,
1771 				flag);
1772 		   ix3++)
1773 		printf_unfiltered
1774 		  ("  tdesc_add_flag (field_type, %d, \"%s\");\n",
1775 		   flag->start, flag->name);
1776 	      break;
1777 	    default:
1778 	      error (_("C output is not supported type \"%s\"."), type->name);
1779 	    }
1780 	  printf_unfiltered ("\n");
1781 	}
1782 
1783       for (ix2 = 0;
1784 	   VEC_iterate (tdesc_reg_p, feature->registers, ix2, reg);
1785 	   ix2++)
1786 	{
1787 	  printf_unfiltered ("  tdesc_create_reg (feature, \"%s\", %ld, %d, ",
1788 			     reg->name, reg->target_regnum, reg->save_restore);
1789 	  if (reg->group)
1790 	    printf_unfiltered ("\"%s\", ", reg->group);
1791 	  else
1792 	    printf_unfiltered ("NULL, ");
1793 	  printf_unfiltered ("%d, \"%s\");\n", reg->bitsize, reg->type);
1794 	}
1795 
1796       printf_unfiltered ("\n");
1797     }
1798 
1799   printf_unfiltered ("  tdesc_%s = result;\n", function);
1800   printf_unfiltered ("}\n");
1801 }
1802 
1803 /* Provide a prototype to silence -Wmissing-prototypes.  */
1804 extern initialize_file_ftype _initialize_target_descriptions;
1805 
1806 void
_initialize_target_descriptions(void)1807 _initialize_target_descriptions (void)
1808 {
1809   tdesc_data = gdbarch_data_register_pre_init (tdesc_data_init);
1810 
1811   add_prefix_cmd ("tdesc", class_maintenance, set_tdesc_cmd, _("\
1812 Set target description specific variables."),
1813 		  &tdesc_set_cmdlist, "set tdesc ",
1814 		  0 /* allow-unknown */, &setlist);
1815   add_prefix_cmd ("tdesc", class_maintenance, show_tdesc_cmd, _("\
1816 Show target description specific variables."),
1817 		  &tdesc_show_cmdlist, "show tdesc ",
1818 		  0 /* allow-unknown */, &showlist);
1819   add_prefix_cmd ("tdesc", class_maintenance, unset_tdesc_cmd, _("\
1820 Unset target description specific variables."),
1821 		  &tdesc_unset_cmdlist, "unset tdesc ",
1822 		  0 /* allow-unknown */, &unsetlist);
1823 
1824   add_setshow_filename_cmd ("filename", class_obscure,
1825 			    &tdesc_filename_cmd_string,
1826 			    _("\
1827 Set the file to read for an XML target description"), _("\
1828 Show the file to read for an XML target description"), _("\
1829 When set, GDB will read the target description from a local\n\
1830 file instead of querying the remote target."),
1831 			    set_tdesc_filename_cmd,
1832 			    show_tdesc_filename_cmd,
1833 			    &tdesc_set_cmdlist, &tdesc_show_cmdlist);
1834 
1835   add_cmd ("filename", class_obscure, unset_tdesc_filename_cmd, _("\
1836 Unset the file to read for an XML target description.  When unset,\n\
1837 GDB will read the description from the target."),
1838 	   &tdesc_unset_cmdlist);
1839 
1840   add_cmd ("c-tdesc", class_maintenance, maint_print_c_tdesc_cmd, _("\
1841 Print the current target description as a C source file."),
1842 	   &maintenanceprintlist);
1843 }
1844