gdb/common/tdesc.h

   1 /* Copyright (C) 2006-2018 Free Software Foundation, Inc.
   2
   3    This file is part of GDB.
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 3 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  17
  18 #ifndef ARCH_TDESC_H
  19 #define ARCH_TDESC_H 1
  20
  21 struct tdesc_feature;
  22 struct tdesc_type;
  23 struct tdesc_type_builtin;
  24 struct tdesc_type_vector;
  25 struct tdesc_type_with_fields;
  26 struct tdesc_reg;
  27 struct target_desc;
  28
  29 /* The interface to visit different elements of target description.  */
  30
  31 class tdesc_element_visitor
  32 {
  33 public:
  34   virtual void visit_pre (const target_desc *e)
  35   {}
  36
  37   virtual void visit_post (const target_desc *e)
  38   {}
  39
  40   virtual void visit_pre (const tdesc_feature *e)
  41   {}
  42
  43   virtual void visit_post (const tdesc_feature *e)
  44   {}
  45
  46   virtual void visit (const tdesc_type_builtin *e)
  47   {}
  48
  49   virtual void visit (const tdesc_type_vector *e)
  50   {}
  51
  52   virtual void visit (const tdesc_type_with_fields *e)
  53   {}
  54
  55   virtual void visit (const tdesc_reg *e)
  56   {}
  57 };
  58
  59 class tdesc_element
  60 {
  61 public:
  62   virtual void accept (tdesc_element_visitor &v) const = 0;
  63 };
  64
  65 /* An individual register from a target description.  */
  66
  67 struct tdesc_reg : tdesc_element
  68 {
  69   tdesc_reg (struct tdesc_feature *feature, const std::string &name_,
  70              int regnum, int save_restore_, const char *group_,
  71              int bitsize_, const char *type_);
  72
  73   virtual ~tdesc_reg () = default;
  74
  75   DISABLE_COPY_AND_ASSIGN (tdesc_reg);
  76
  77   /* The name of this register.  In standard features, it may be
  78      recognized by the architecture support code, or it may be purely
  79      for the user.  */
  80   std::string name;
  81
  82   /* The register number used by this target to refer to this
  83      register.  This is used for remote p/P packets and to determine
  84      the ordering of registers in the remote g/G packets.  */
  85   long target_regnum;
  86
  87   /* If this flag is set, GDB should save and restore this register
  88      around calls to an inferior function.  */
  89   int save_restore;
  90
  91   /* The name of the register group containing this register, or empty
  92      if the group should be automatically determined from the
  93      register's type.  If this is "general", "float", or "vector", the
  94      corresponding "info" command should display this register's
  95      value.  It can be an arbitrary string, but should be limited to
  96      alphanumeric characters and internal hyphens.  Currently other
  97      strings are ignored (treated as empty).  */
  98   std::string group;
  99
 100   /* The size of the register, in bits.  */
 101   int bitsize;
 102
 103   /* The type of the register.  This string corresponds to either
 104      a named type from the target description or a predefined
 105      type from GDB.  */
 106   std::string type;
 107
 108   /* The target-described type corresponding to TYPE, if found.  */
 109   struct tdesc_type *tdesc_type;
 110
 111   void accept (tdesc_element_visitor &v) const override
 112   {
 113     v.visit (this);
 114   }
 115
 116   bool operator== (const tdesc_reg &other) const
 117   {
 118     return (name == other.name
 119        && target_regnum == other.target_regnum
 120        && save_restore == other.save_restore
 121        && bitsize == other.bitsize
 122        && group == other.group
 123        && type == other.type);
 124   }
 125
 126   bool operator!= (const tdesc_reg &other) const
 127   {
 128     return !(*this == other);
 129   }
 130 };
 131
 132 typedef std::unique_ptr<tdesc_reg> tdesc_reg_up;
 133
 134 enum tdesc_type_kind
 135 {
 136   /* Predefined types.  */
 137   TDESC_TYPE_BOOL,
 138   TDESC_TYPE_INT8,
 139   TDESC_TYPE_INT16,
 140   TDESC_TYPE_INT32,
 141   TDESC_TYPE_INT64,
 142   TDESC_TYPE_INT128,
 143   TDESC_TYPE_UINT8,
 144   TDESC_TYPE_UINT16,
 145   TDESC_TYPE_UINT32,
 146   TDESC_TYPE_UINT64,
 147   TDESC_TYPE_UINT128,
 148   TDESC_TYPE_CODE_PTR,
 149   TDESC_TYPE_DATA_PTR,
 150   TDESC_TYPE_IEEE_SINGLE,
 151   TDESC_TYPE_IEEE_DOUBLE,
 152   TDESC_TYPE_ARM_FPA_EXT,
 153   TDESC_TYPE_I387_EXT,
 154
 155   /* Types defined by a target feature.  */
 156   TDESC_TYPE_VECTOR,
 157   TDESC_TYPE_STRUCT,
 158   TDESC_TYPE_UNION,
 159   TDESC_TYPE_FLAGS,
 160   TDESC_TYPE_ENUM
 161 };
 162
 163 struct tdesc_type : tdesc_element
 164 {
 165   tdesc_type (const std::string &name_, enum tdesc_type_kind kind_)
 166     : name (name_), kind (kind_)
 167   {}
 168
 169   virtual ~tdesc_type () = default;
 170
 171   DISABLE_COPY_AND_ASSIGN (tdesc_type);
 172
 173   /* The name of this type.  */
 174   std::string name;
 175
 176   /* Identify the kind of this type.  */
 177   enum tdesc_type_kind kind;
 178
 179   bool operator== (const tdesc_type &other) const
 180   {
 181     return name == other.name && kind == other.kind;
 182   }
 183
 184   bool operator!= (const tdesc_type &other) const
 185   {
 186     return !(*this == other);
 187   }
 188 };
 189
 190 typedef std::unique_ptr<tdesc_type> tdesc_type_up;
 191
 192 struct tdesc_type_builtin : tdesc_type
 193 {
 194   tdesc_type_builtin (const std::string &name, enum tdesc_type_kind kind)
 195   : tdesc_type (name, kind)
 196   {}
 197
 198   void accept (tdesc_element_visitor &v) const override
 199   {
 200     v.visit (this);
 201   }
 202 };
 203
 204 /* tdesc_type for vector types.  */
 205
 206 struct tdesc_type_vector : tdesc_type
 207 {
 208   tdesc_type_vector (const std::string &name, tdesc_type *element_type_,
 209                      int count_)
 210   : tdesc_type (name, TDESC_TYPE_VECTOR),
 211     element_type (element_type_), count (count_)
 212   {}
 213
 214   void accept (tdesc_element_visitor &v) const override
 215   {
 216     v.visit (this);
 217   }
 218
 219   struct tdesc_type *element_type;
 220   int count;
 221 };
 222
 223 /* A named type from a target description.  */
 224
 225 struct tdesc_type_field
 226 {
 227   tdesc_type_field (const std::string &name_, tdesc_type *type_,
 228                     int start_, int end_)
 229   : name (name_), type (type_), start (start_), end (end_)
 230   {}
 231
 232   std::string name;
 233   struct tdesc_type *type;
 234   /* For non-enum-values, either both are -1 (non-bitfield), or both are
 235      not -1 (bitfield).  For enum values, start is the value (which could be
 236      -1), end is -1.  */
 237   int start, end;
 238 };
 239
 240 /* tdesc_type for struct, union, flags, and enum types.  */
 241
 242 struct tdesc_type_with_fields : tdesc_type
 243 {
 244   tdesc_type_with_fields (const std::string &name, tdesc_type_kind kind,
 245                           int size_ = 0)
 246   : tdesc_type (name, kind), size (size_)
 247   {}
 248
 249   void accept (tdesc_element_visitor &v) const override
 250   {
 251     v.visit (this);
 252   }
 253
 254   std::vector<tdesc_type_field> fields;
 255   int size;
 256 };
 257
 258 /* A feature from a target description.  Each feature is a collection
 259    of other elements, e.g. registers and types.  */
 260
 261 struct tdesc_feature : tdesc_element
 262 {
 263   tdesc_feature (const std::string &name_)
 264     : name (name_)
 265   {}
 266
 267   virtual ~tdesc_feature () = default;
 268
 269   DISABLE_COPY_AND_ASSIGN (tdesc_feature);
 270
 271   /* The name of this feature.  It may be recognized by the architecture
 272      support code.  */
 273   std::string name;
 274
 275   /* The registers associated with this feature.  */
 276   std::vector<tdesc_reg_up> registers;
 277
 278   /* The types associated with this feature.  */
 279   std::vector<tdesc_type_up> types;
 280
 281   void accept (tdesc_element_visitor &v) const override;
 282
 283   bool operator== (const tdesc_feature &other) const;
 284
 285   bool operator!= (const tdesc_feature &other) const
 286   {
 287     return !(*this == other);
 288   }
 289 };
 290
 291 typedef std::unique_ptr<tdesc_feature> tdesc_feature_up;
 292
 293 /* Allocate a new target_desc.  */
 294 target_desc *allocate_target_description (void);
 295
 296 /* Set TARGET_DESC's architecture by NAME.  */
 297 void set_tdesc_architecture (target_desc *target_desc,
 298                              const char *name);
 299
 300 /* Return the architecture associated with this target description as a string,
 301    or NULL if no architecture was specified.  */
 302 const char *tdesc_architecture_name (const struct target_desc *target_desc);
 303
 304 /* Set TARGET_DESC's osabi by NAME.  */
 305 void set_tdesc_osabi (target_desc *target_desc, const char *name);
 306
 307 /* Return the osabi associated with this target description as a string,
 308    or NULL if no osabi was specified.  */
 309 const char *tdesc_osabi_name (const struct target_desc *target_desc);
 310
 311 /* Return the type associated with ID in the context of FEATURE, or
 312    NULL if none.  */
 313 struct tdesc_type *tdesc_named_type (const struct tdesc_feature *feature,
 314                                      const char *id);
 315
 316 /* Return the created feature named NAME in target description TDESC.  */
 317 struct tdesc_feature *tdesc_create_feature (struct target_desc *tdesc,
 318                                             const char *name,
 319                                             const char *xml = nullptr);
 320
 321
 322 /* Return the created vector tdesc_type named NAME in FEATURE.  */
 323 struct tdesc_type *tdesc_create_vector (struct tdesc_feature *feature,
 324                                         const char *name,
 325                                         struct tdesc_type *field_type,
 326                                         int count);
 327
 328 /* Return the created struct tdesc_type named NAME in FEATURE.  */
 329 tdesc_type_with_fields *tdesc_create_struct (struct tdesc_feature *feature,
 330                                              const char *name);
 331
 332 /* Return the created union tdesc_type named NAME in FEATURE.  */
 333 tdesc_type_with_fields *tdesc_create_union (struct tdesc_feature *feature,
 334                                             const char *name);
 335
 336 /* Return the created flags tdesc_type named NAME in FEATURE.  */
 337 tdesc_type_with_fields *tdesc_create_flags (struct tdesc_feature *feature,
 338                                             const char *name,
 339                                             int size);
 340
 341 /* Return the created enum tdesc_type named NAME in FEATURE.  */
 342 tdesc_type_with_fields *tdesc_create_enum (struct tdesc_feature *feature,
 343                                            const char *name,
 344                                            int size);
 345
 346 /* Add a new field to TYPE.  FIELD_NAME is its name, and FIELD_TYPE is
 347    its type.  */
 348 void tdesc_add_field (tdesc_type_with_fields *type, const char *field_name,
 349                       struct tdesc_type *field_type);
 350
 351 /* Add a new bitfield to TYPE, with range START to END.  FIELD_NAME is its name,
 352    and FIELD_TYPE is its type.  */
 353 void tdesc_add_typed_bitfield (tdesc_type_with_fields *type,
 354                                const char *field_name,
 355                                int start, int end,
 356                                struct tdesc_type *field_type);
 357
 358 /* Set the total length of TYPE.  Structs which contain bitfields may
 359    omit the reserved bits, so the end of the last field may not
 360    suffice.  */
 361 void tdesc_set_struct_size (tdesc_type_with_fields *type, int size);
 362
 363 /* Add a new untyped bitfield to TYPE.
 364    Untyped bitfields become either uint32 or uint64 depending on the size
 365    of the underlying type.  */
 366 void tdesc_add_bitfield (tdesc_type_with_fields *type, const char *field_name,
 367                          int start, int end);
 368
 369 /* A flag is just a typed(bool) single-bit bitfield.
 370    This function is kept to minimize changes in generated files.  */
 371 void tdesc_add_flag (tdesc_type_with_fields *type, int start,
 372                      const char *flag_name);
 373
 374 /* Add field with VALUE and NAME to the enum TYPE.  */
 375 void tdesc_add_enum_value (tdesc_type_with_fields *type, int value,
 376                            const char *name);
 377
 378 /* Create a register in feature FEATURE.  */
 379 void tdesc_create_reg (struct tdesc_feature *feature, const char *name,
 380                        int regnum, int save_restore, const char *group,
 381                        int bitsize, const char *type);
 382
 383 #endif /* ARCH_TDESC_H */