gdbsupport/tdesc.h

   1 /* Copyright (C) 2006-2020 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 /* Declaration of a structure that holds information about one
 135    "compatibility" entry within a target description.  */
 136
 137 struct tdesc_compatible_info;
 138
 139 /* A pointer to a single piece of compatibility information.  */
 140
 141 typedef std::unique_ptr<tdesc_compatible_info> tdesc_compatible_info_up;
 142
 143 /* Return a vector of compatibility information pointers from the target
 144    description TARGET_DESC.  */
 145
 146 const std::vector<tdesc_compatible_info_up> &tdesc_compatible_info_list
 147         (const target_desc *target_desc);
 148
 149 /* Return the architecture name from a compatibility information
 150    COMPATIBLE.  */
 151
 152 const char *tdesc_compatible_info_arch_name
 153         (const tdesc_compatible_info_up &compatible);
 154
 155 enum tdesc_type_kind
 156 {
 157   /* Predefined types.  */
 158   TDESC_TYPE_BOOL,
 159   TDESC_TYPE_INT8,
 160   TDESC_TYPE_INT16,
 161   TDESC_TYPE_INT32,
 162   TDESC_TYPE_INT64,
 163   TDESC_TYPE_INT128,
 164   TDESC_TYPE_UINT8,
 165   TDESC_TYPE_UINT16,
 166   TDESC_TYPE_UINT32,
 167   TDESC_TYPE_UINT64,
 168   TDESC_TYPE_UINT128,
 169   TDESC_TYPE_CODE_PTR,
 170   TDESC_TYPE_DATA_PTR,
 171   TDESC_TYPE_CODE_CAPABILITY,
 172   TDESC_TYPE_DATA_CAPABILITY,
 173   TDESC_TYPE_INTCAP,
 174   TDESC_TYPE_UINTCAP,
 175   TDESC_TYPE_IEEE_HALF,
 176   TDESC_TYPE_IEEE_SINGLE,
 177   TDESC_TYPE_IEEE_DOUBLE,
 178   TDESC_TYPE_ARM_FPA_EXT,
 179   TDESC_TYPE_I387_EXT,
 180   TDESC_TYPE_BFLOAT16,
 181
 182   /* Types defined by a target feature.  */
 183   TDESC_TYPE_VECTOR,
 184   TDESC_TYPE_STRUCT,
 185   TDESC_TYPE_UNION,
 186   TDESC_TYPE_FLAGS,
 187   TDESC_TYPE_ENUM
 188 };
 189
 190 struct tdesc_type : tdesc_element
 191 {
 192   tdesc_type (const std::string &name_, enum tdesc_type_kind kind_)
 193     : name (name_), kind (kind_)
 194   {}
 195
 196   virtual ~tdesc_type () = default;
 197
 198   DISABLE_COPY_AND_ASSIGN (tdesc_type);
 199
 200   /* The name of this type.  */
 201   std::string name;
 202
 203   /* Identify the kind of this type.  */
 204   enum tdesc_type_kind kind;
 205
 206   bool operator== (const tdesc_type &other) const
 207   {
 208     return name == other.name && kind == other.kind;
 209   }
 210
 211   bool operator!= (const tdesc_type &other) const
 212   {
 213     return !(*this == other);
 214   }
 215 };
 216
 217 typedef std::unique_ptr<tdesc_type> tdesc_type_up;
 218
 219 struct tdesc_type_builtin : tdesc_type
 220 {
 221   tdesc_type_builtin (const std::string &name, enum tdesc_type_kind kind)
 222   : tdesc_type (name, kind)
 223   {}
 224
 225   void accept (tdesc_element_visitor &v) const override
 226   {
 227     v.visit (this);
 228   }
 229 };
 230
 231 /* tdesc_type for vector types.  */
 232
 233 struct tdesc_type_vector : tdesc_type
 234 {
 235   tdesc_type_vector (const std::string &name, tdesc_type *element_type_,
 236                      int count_)
 237   : tdesc_type (name, TDESC_TYPE_VECTOR),
 238     element_type (element_type_), count (count_)
 239   {}
 240
 241   void accept (tdesc_element_visitor &v) const override
 242   {
 243     v.visit (this);
 244   }
 245
 246   struct tdesc_type *element_type;
 247   int count;
 248 };
 249
 250 /* A named type from a target description.  */
 251
 252 struct tdesc_type_field
 253 {
 254   tdesc_type_field (const std::string &name_, tdesc_type *type_,
 255                     int start_, int end_)
 256   : name (name_), type (type_), start (start_), end (end_)
 257   {}
 258
 259   std::string name;
 260   struct tdesc_type *type;
 261   /* For non-enum-values, either both are -1 (non-bitfield), or both are
 262      not -1 (bitfield).  For enum values, start is the value (which could be
 263      -1), end is -1.  */
 264   int start, end;
 265 };
 266
 267 /* tdesc_type for struct, union, flags, and enum types.  */
 268
 269 struct tdesc_type_with_fields : tdesc_type
 270 {
 271   tdesc_type_with_fields (const std::string &name, tdesc_type_kind kind,
 272                           int size_ = 0)
 273   : tdesc_type (name, kind), size (size_)
 274   {}
 275
 276   void accept (tdesc_element_visitor &v) const override
 277   {
 278     v.visit (this);
 279   }
 280
 281   std::vector<tdesc_type_field> fields;
 282   int size;
 283 };
 284
 285 /* A feature from a target description.  Each feature is a collection
 286    of other elements, e.g. registers and types.  */
 287
 288 struct tdesc_feature : tdesc_element
 289 {
 290   tdesc_feature (const std::string &name_)
 291     : name (name_)
 292   {}
 293
 294   virtual ~tdesc_feature () = default;
 295
 296   DISABLE_COPY_AND_ASSIGN (tdesc_feature);
 297
 298   /* The name of this feature.  It may be recognized by the architecture
 299      support code.  */
 300   std::string name;
 301
 302   /* The registers associated with this feature.  */
 303   std::vector<tdesc_reg_up> registers;
 304
 305   /* The types associated with this feature.  */
 306   std::vector<tdesc_type_up> types;
 307
 308   void accept (tdesc_element_visitor &v) const override;
 309
 310   bool operator== (const tdesc_feature &other) const;
 311
 312   bool operator!= (const tdesc_feature &other) const
 313   {
 314     return !(*this == other);
 315   }
 316 };
 317
 318 typedef std::unique_ptr<tdesc_feature> tdesc_feature_up;
 319
 320 /* A deleter adapter for a target_desc.  There are different
 321    implementations of this deleter class in gdb and gdbserver because even
 322    though the target_desc name is shared between the two projects, the
 323    actual implementations of target_desc are completely different.  */
 324
 325 struct target_desc_deleter
 326 {
 327   void operator() (struct target_desc *desc) const;
 328 };
 329
 330 /* A unique pointer specialization that holds a target_desc.  */
 331
 332 typedef std::unique_ptr<target_desc, target_desc_deleter> target_desc_up;
 333
 334 /* Allocate a new target_desc.  */
 335 target_desc_up allocate_target_description (void);
 336
 337 /* Set TARGET_DESC's architecture by NAME.  */
 338 void set_tdesc_architecture (target_desc *target_desc,
 339                              const char *name);
 340
 341 /* Return the architecture associated with this target description as a string,
 342    or NULL if no architecture was specified.  */
 343 const char *tdesc_architecture_name (const struct target_desc *target_desc);
 344
 345 /* Set TARGET_DESC's osabi by NAME.  */
 346 void set_tdesc_osabi (target_desc *target_desc, const char *name);
 347
 348 /* Return the osabi associated with this target description as a string,
 349    or NULL if no osabi was specified.  */
 350 const char *tdesc_osabi_name (const struct target_desc *target_desc);
 351
 352 /* Return the type associated with ID in the context of FEATURE, or
 353    NULL if none.  */
 354 struct tdesc_type *tdesc_named_type (const struct tdesc_feature *feature,
 355                                      const char *id);
 356
 357 /* Return the created feature named NAME in target description TDESC.  */
 358 struct tdesc_feature *tdesc_create_feature (struct target_desc *tdesc,
 359                                             const char *name);
 360
 361 /* Return the created vector tdesc_type named NAME in FEATURE.  */
 362 struct tdesc_type *tdesc_create_vector (struct tdesc_feature *feature,
 363                                         const char *name,
 364                                         struct tdesc_type *field_type,
 365                                         int count);
 366
 367 /* Return the created struct tdesc_type named NAME in FEATURE.  */
 368 tdesc_type_with_fields *tdesc_create_struct (struct tdesc_feature *feature,
 369                                              const char *name);
 370
 371 /* Return the created union tdesc_type named NAME in FEATURE.  */
 372 tdesc_type_with_fields *tdesc_create_union (struct tdesc_feature *feature,
 373                                             const char *name);
 374
 375 /* Return the created flags tdesc_type named NAME in FEATURE.  */
 376 tdesc_type_with_fields *tdesc_create_flags (struct tdesc_feature *feature,
 377                                             const char *name,
 378                                             int size);
 379
 380 /* Return the created enum tdesc_type named NAME in FEATURE.  */
 381 tdesc_type_with_fields *tdesc_create_enum (struct tdesc_feature *feature,
 382                                            const char *name,
 383                                            int size);
 384
 385 /* Add a new field to TYPE.  FIELD_NAME is its name, and FIELD_TYPE is
 386    its type.  */
 387 void tdesc_add_field (tdesc_type_with_fields *type, const char *field_name,
 388                       struct tdesc_type *field_type);
 389
 390 /* Add a new bitfield to TYPE, with range START to END.  FIELD_NAME is its name,
 391    and FIELD_TYPE is its type.  */
 392 void tdesc_add_typed_bitfield (tdesc_type_with_fields *type,
 393                                const char *field_name,
 394                                int start, int end,
 395                                struct tdesc_type *field_type);
 396
 397 /* Set the total length of TYPE.  Structs which contain bitfields may
 398    omit the reserved bits, so the end of the last field may not
 399    suffice.  */
 400 void tdesc_set_struct_size (tdesc_type_with_fields *type, int size);
 401
 402 /* Add a new untyped bitfield to TYPE.
 403    Untyped bitfields become either uint32 or uint64 depending on the size
 404    of the underlying type.  */
 405 void tdesc_add_bitfield (tdesc_type_with_fields *type, const char *field_name,
 406                          int start, int end);
 407
 408 /* A flag is just a typed(bool) single-bit bitfield.
 409    This function is kept to minimize changes in generated files.  */
 410 void tdesc_add_flag (tdesc_type_with_fields *type, int start,
 411                      const char *flag_name);
 412
 413 /* Add field with VALUE and NAME to the enum TYPE.  */
 414 void tdesc_add_enum_value (tdesc_type_with_fields *type, int value,
 415                            const char *name);
 416
 417 /* Create a register in feature FEATURE.  */
 418 void tdesc_create_reg (struct tdesc_feature *feature, const char *name,
 419                        int regnum, int save_restore, const char *group,
 420                        int bitsize, const char *type);
 421
 422 /* Return the tdesc in string XML format.  */
 423
 424 const char *tdesc_get_features_xml (const target_desc *tdesc);
 425
 426 /* Print target description as xml.  */
 427
 428 class print_xml_feature : public tdesc_element_visitor
 429 {
 430 public:
 431   print_xml_feature (std::string *buffer_)
 432     : m_buffer (buffer_),
 433       m_depth (0)
 434   {}
 435
 436   void visit_pre (const target_desc *e) override;
 437   void visit_post (const target_desc *e) override;
 438   void visit_pre (const tdesc_feature *e) override;
 439   void visit_post (const tdesc_feature *e) override;
 440   void visit (const tdesc_type_builtin *type) override;
 441   void visit (const tdesc_type_vector *type) override;
 442   void visit (const tdesc_type_with_fields *type) override;
 443   void visit (const tdesc_reg *reg) override;
 444
 445 private:
 446
 447   /* Called with a positive value of ADJUST when we move inside an element,
 448      for example inside <target>, and with a negative value when we leave
 449      the element.  In this class this function does nothing, but a
 450      sub-class can override this to track the current level of nesting.  */
 451   void indent (int adjust)
 452   {
 453     m_depth += (adjust * 2);
 454   }
 455
 456   /* Functions to add lines to the output buffer M_BUFFER.  Each of these
 457      functions appends a newline, so don't include one in the strings being
 458      passed.  */
 459   void add_line (const std::string &str);
 460   void add_line (const char *fmt, ...) ATTRIBUTE_PRINTF (2, 3);
 461
 462   /* The buffer we are writing too.  */
 463   std::string *m_buffer;
 464
 465   /* The current indentation depth.  */
 466   int m_depth;
 467 };
 468
 469 #endif /* COMMON_TDESC_H */