gdb/common/tdesc.h

   1 /* Copyright (C) 2006-2019 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 COMMON_TDESC_H
  19 #define COMMON_TDESC_H
  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
 320 /* Return the created vector tdesc_type named NAME in FEATURE.  */
 321 struct tdesc_type *tdesc_create_vector (struct tdesc_feature *feature,
 322                                         const char *name,
 323                                         struct tdesc_type *field_type,
 324                                         int count);
 325
 326 /* Return the created struct tdesc_type named NAME in FEATURE.  */
 327 tdesc_type_with_fields *tdesc_create_struct (struct tdesc_feature *feature,
 328                                              const char *name);
 329
 330 /* Return the created union tdesc_type named NAME in FEATURE.  */
 331 tdesc_type_with_fields *tdesc_create_union (struct tdesc_feature *feature,
 332                                             const char *name);
 333
 334 /* Return the created flags tdesc_type named NAME in FEATURE.  */
 335 tdesc_type_with_fields *tdesc_create_flags (struct tdesc_feature *feature,
 336                                             const char *name,
 337                                             int size);
 338
 339 /* Return the created enum tdesc_type named NAME in FEATURE.  */
 340 tdesc_type_with_fields *tdesc_create_enum (struct tdesc_feature *feature,
 341                                            const char *name,
 342                                            int size);
 343
 344 /* Add a new field to TYPE.  FIELD_NAME is its name, and FIELD_TYPE is
 345    its type.  */
 346 void tdesc_add_field (tdesc_type_with_fields *type, const char *field_name,
 347                       struct tdesc_type *field_type);
 348
 349 /* Add a new bitfield to TYPE, with range START to END.  FIELD_NAME is its name,
 350    and FIELD_TYPE is its type.  */
 351 void tdesc_add_typed_bitfield (tdesc_type_with_fields *type,
 352                                const char *field_name,
 353                                int start, int end,
 354                                struct tdesc_type *field_type);
 355
 356 /* Set the total length of TYPE.  Structs which contain bitfields may
 357    omit the reserved bits, so the end of the last field may not
 358    suffice.  */
 359 void tdesc_set_struct_size (tdesc_type_with_fields *type, int size);
 360
 361 /* Add a new untyped bitfield to TYPE.
 362    Untyped bitfields become either uint32 or uint64 depending on the size
 363    of the underlying type.  */
 364 void tdesc_add_bitfield (tdesc_type_with_fields *type, const char *field_name,
 365                          int start, int end);
 366
 367 /* A flag is just a typed(bool) single-bit bitfield.
 368    This function is kept to minimize changes in generated files.  */
 369 void tdesc_add_flag (tdesc_type_with_fields *type, int start,
 370                      const char *flag_name);
 371
 372 /* Add field with VALUE and NAME to the enum TYPE.  */
 373 void tdesc_add_enum_value (tdesc_type_with_fields *type, int value,
 374                            const char *name);
 375
 376 /* Create a register in feature FEATURE.  */
 377 void tdesc_create_reg (struct tdesc_feature *feature, const char *name,
 378                        int regnum, int save_restore, const char *group,
 379                        int bitsize, const char *type);
 380
 381 /* Return the tdesc in string XML format.  */
 382
 383 const char *tdesc_get_features_xml (const target_desc *tdesc);
 384
 385 /* Print target description as xml.  */
 386
 387 class print_xml_feature : public tdesc_element_visitor
 388 {
 389 public:
 390   print_xml_feature (std::string *buffer_)
 391     : m_buffer (buffer_)
 392   {}
 393
 394   void visit_pre (const target_desc *e) override;
 395   void visit_post (const target_desc *e) override;
 396   void visit_pre (const tdesc_feature *e) override;
 397   void visit_post (const tdesc_feature *e) override;
 398   void visit (const tdesc_type_builtin *type) override;
 399   void visit (const tdesc_type_vector *type) override;
 400   void visit (const tdesc_type_with_fields *type) override;
 401   void visit (const tdesc_reg *reg) override;
 402
 403 private:
 404   std::string *m_buffer;
 405 };
 406
 407 #endif /* COMMON_TDESC_H */