gdb/common/tdesc.c

   1 /* Target description support for GDB.
   2
   3    Copyright (C) 2018-2019 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "common-defs.h"
  21 #include "common/tdesc.h"
  22
  23 tdesc_reg::tdesc_reg (struct tdesc_feature *feature, const std::string &name_,
  24                       int regnum, int save_restore_, const char *group_,
  25                       int bitsize_, const char *type_)
  26   : name (name_), target_regnum (regnum),
  27     save_restore (save_restore_),
  28     group (group_ != NULL ? group_ : ""),
  29     bitsize (bitsize_),
  30     type (type_ != NULL ? type_ : "<unknown>")
  31 {
  32   /* If the register's type is target-defined, look it up now.  We may not
  33      have easy access to the containing feature when we want it later.  */
  34   tdesc_type = tdesc_named_type (feature, type.c_str ());
  35 }
  36
  37 /* Predefined types.  */
  38 static tdesc_type_builtin tdesc_predefined_types[] =
  39 {
  40   { "bool", TDESC_TYPE_BOOL },
  41   { "int8", TDESC_TYPE_INT8 },
  42   { "int16", TDESC_TYPE_INT16 },
  43   { "int32", TDESC_TYPE_INT32 },
  44   { "int64", TDESC_TYPE_INT64 },
  45   { "int128", TDESC_TYPE_INT128 },
  46   { "uint8", TDESC_TYPE_UINT8 },
  47   { "uint16", TDESC_TYPE_UINT16 },
  48   { "uint32", TDESC_TYPE_UINT32 },
  49   { "uint64", TDESC_TYPE_UINT64 },
  50   { "uint128", TDESC_TYPE_UINT128 },
  51   { "code_ptr", TDESC_TYPE_CODE_PTR },
  52   { "data_ptr", TDESC_TYPE_DATA_PTR },
  53   { "ieee_single", TDESC_TYPE_IEEE_SINGLE },
  54   { "ieee_double", TDESC_TYPE_IEEE_DOUBLE },
  55   { "arm_fpa_ext", TDESC_TYPE_ARM_FPA_EXT },
  56   { "i387_ext", TDESC_TYPE_I387_EXT }
  57 };
  58
  59 void tdesc_feature::accept (tdesc_element_visitor &v) const
  60 {
  61   v.visit_pre (this);
  62
  63   for (const tdesc_type_up &type : types)
  64     type->accept (v);
  65
  66   for (const tdesc_reg_up &reg : registers)
  67     reg->accept (v);
  68
  69   v.visit_post (this);
  70 }
  71
  72 bool tdesc_feature::operator== (const tdesc_feature &other) const
  73 {
  74   if (name != other.name)
  75     return false;
  76
  77   if (registers.size () != other.registers.size ())
  78     return false;
  79
  80   for (int ix = 0; ix < registers.size (); ix++)
  81     {
  82       const tdesc_reg_up &reg1 = registers[ix];
  83       const tdesc_reg_up &reg2 = other.registers[ix];
  84
  85       if (reg1 != reg2 && *reg1 != *reg2)
  86         return false;
  87       }
  88
  89   if (types.size () != other.types.size ())
  90     return false;
  91
  92   for (int ix = 0; ix < types.size (); ix++)
  93     {
  94       const tdesc_type_up &type1 = types[ix];
  95       const tdesc_type_up &type2 = other.types[ix];
  96
  97       if (type1 != type2 && *type1 != *type2)
  98         return false;
  99     }
 100
 101   return true;
 102 }
 103
 104 /* Lookup a predefined type.  */
 105
 106 static struct tdesc_type *
 107 tdesc_predefined_type (enum tdesc_type_kind kind)
 108 {
 109   for (int ix = 0; ix < ARRAY_SIZE (tdesc_predefined_types); ix++)
 110     if (tdesc_predefined_types[ix].kind == kind)
 111       return &tdesc_predefined_types[ix];
 112
 113   gdb_assert_not_reached ("bad predefined tdesc type");
 114 }
 115
 116 /* See common/tdesc.h.  */
 117
 118 struct tdesc_type *
 119 tdesc_named_type (const struct tdesc_feature *feature, const char *id)
 120 {
 121   /* First try target-defined types.  */
 122   for (const tdesc_type_up &type : feature->types)
 123     if (type->name == id)
 124       return type.get ();
 125
 126   /* Next try the predefined types.  */
 127   for (int ix = 0; ix < ARRAY_SIZE (tdesc_predefined_types); ix++)
 128     if (tdesc_predefined_types[ix].name == id)
 129       return &tdesc_predefined_types[ix];
 130
 131   return NULL;
 132 }
 133
 134 /* See common/tdesc.h.  */
 135
 136 void
 137 tdesc_create_reg (struct tdesc_feature *feature, const char *name,
 138                   int regnum, int save_restore, const char *group,
 139                   int bitsize, const char *type)
 140 {
 141   tdesc_reg *reg = new tdesc_reg (feature, name, regnum, save_restore,
 142                                   group, bitsize, type);
 143
 144   feature->registers.emplace_back (reg);
 145 }
 146
 147 /* See common/tdesc.h.  */
 148
 149 struct tdesc_type *
 150 tdesc_create_vector (struct tdesc_feature *feature, const char *name,
 151                      struct tdesc_type *field_type, int count)
 152 {
 153   tdesc_type_vector *type = new tdesc_type_vector (name, field_type, count);
 154   feature->types.emplace_back (type);
 155
 156   return type;
 157 }
 158
 159 /* See common/tdesc.h.  */
 160
 161 tdesc_type_with_fields *
 162 tdesc_create_struct (struct tdesc_feature *feature, const char *name)
 163 {
 164   tdesc_type_with_fields *type
 165     = new tdesc_type_with_fields (name, TDESC_TYPE_STRUCT);
 166   feature->types.emplace_back (type);
 167
 168   return type;
 169 }
 170
 171 /* See common/tdesc.h.  */
 172
 173 void
 174 tdesc_set_struct_size (tdesc_type_with_fields *type, int size)
 175 {
 176   gdb_assert (type->kind == TDESC_TYPE_STRUCT);
 177   gdb_assert (size > 0);
 178   type->size = size;
 179 }
 180
 181 /* See common/tdesc.h.  */
 182
 183 tdesc_type_with_fields *
 184 tdesc_create_union (struct tdesc_feature *feature, const char *name)
 185 {
 186   tdesc_type_with_fields *type
 187     = new tdesc_type_with_fields (name, TDESC_TYPE_UNION);
 188   feature->types.emplace_back (type);
 189
 190   return type;
 191 }
 192
 193 /* See common/tdesc.h.  */
 194
 195 tdesc_type_with_fields *
 196 tdesc_create_flags (struct tdesc_feature *feature, const char *name,
 197                     int size)
 198 {
 199   gdb_assert (size > 0);
 200
 201   tdesc_type_with_fields *type
 202     = new tdesc_type_with_fields (name, TDESC_TYPE_FLAGS, size);
 203   feature->types.emplace_back (type);
 204
 205   return type;
 206 }
 207
 208 /* See common/tdesc.h.  */
 209
 210 tdesc_type_with_fields *
 211 tdesc_create_enum (struct tdesc_feature *feature, const char *name,
 212                    int size)
 213 {
 214   gdb_assert (size > 0);
 215
 216   tdesc_type_with_fields *type
 217     = new tdesc_type_with_fields (name, TDESC_TYPE_ENUM, size);
 218   feature->types.emplace_back (type);
 219
 220   return type;
 221 }
 222
 223 /* See common/tdesc.h.  */
 224
 225 void
 226 tdesc_add_field (tdesc_type_with_fields *type, const char *field_name,
 227                  struct tdesc_type *field_type)
 228 {
 229   gdb_assert (type->kind == TDESC_TYPE_UNION
 230               || type->kind == TDESC_TYPE_STRUCT);
 231
 232   /* Initialize start and end so we know this is not a bit-field
 233      when we print-c-tdesc.  */
 234   type->fields.emplace_back (field_name, field_type, -1, -1);
 235 }
 236
 237 /* See common/tdesc.h.  */
 238
 239 void
 240 tdesc_add_typed_bitfield (tdesc_type_with_fields *type, const char *field_name,
 241                           int start, int end, struct tdesc_type *field_type)
 242 {
 243   gdb_assert (type->kind == TDESC_TYPE_STRUCT
 244               || type->kind == TDESC_TYPE_FLAGS);
 245   gdb_assert (start >= 0 && end >= start);
 246
 247   type->fields.emplace_back (field_name, field_type, start, end);
 248 }
 249
 250 /* See common/tdesc.h.  */
 251
 252 void
 253 tdesc_add_bitfield (tdesc_type_with_fields *type, const char *field_name,
 254                     int start, int end)
 255 {
 256   struct tdesc_type *field_type;
 257
 258   gdb_assert (start >= 0 && end >= start);
 259
 260   if (type->size > 4)
 261     field_type = tdesc_predefined_type (TDESC_TYPE_UINT64);
 262   else
 263     field_type = tdesc_predefined_type (TDESC_TYPE_UINT32);
 264
 265   tdesc_add_typed_bitfield (type, field_name, start, end, field_type);
 266 }
 267
 268 /* See common/tdesc.h.  */
 269
 270 void
 271 tdesc_add_flag (tdesc_type_with_fields *type, int start,
 272                 const char *flag_name)
 273 {
 274   gdb_assert (type->kind == TDESC_TYPE_FLAGS
 275               || type->kind == TDESC_TYPE_STRUCT);
 276
 277   type->fields.emplace_back (flag_name,
 278                              tdesc_predefined_type (TDESC_TYPE_BOOL),
 279                              start, start);
 280 }
 281
 282 /* See common/tdesc.h.  */
 283
 284 void
 285 tdesc_add_enum_value (tdesc_type_with_fields *type, int value,
 286                       const char *name)
 287 {
 288   gdb_assert (type->kind == TDESC_TYPE_ENUM);
 289   type->fields.emplace_back (name,
 290                              tdesc_predefined_type (TDESC_TYPE_INT32),
 291                              value, -1);
 292 }
 293
 294 void print_xml_feature::visit_pre (const tdesc_feature *e)
 295 {
 296   string_appendf (*m_buffer, "<feature name=\"%s\">\n", e->name.c_str ());
 297 }
 298
 299 void print_xml_feature::visit_post (const tdesc_feature *e)
 300 {
 301   string_appendf (*m_buffer, "</feature>\n");
 302 }
 303
 304 void print_xml_feature::visit (const tdesc_type_builtin *t)
 305 {
 306   error (_("xml output is not supported for type \"%s\"."), t->name.c_str ());
 307 }
 308
 309 void print_xml_feature::visit (const tdesc_type_vector *t)
 310 {
 311   string_appendf (*m_buffer, "<vector id=\"%s\" type=\"%s\" count=\"%d\"/>\n",
 312                   t->name.c_str (), t->element_type->name.c_str (), t->count);
 313 }
 314
 315 void print_xml_feature::visit (const tdesc_type_with_fields *t)
 316 {
 317   const static char *types[] = { "struct", "union", "flags", "enum" };
 318
 319   gdb_assert (t->kind >= TDESC_TYPE_STRUCT && t->kind <= TDESC_TYPE_ENUM);
 320
 321   string_appendf (*m_buffer,
 322                   "<%s id=\"%s\"", types[t->kind - TDESC_TYPE_STRUCT],
 323                   t->name.c_str ());
 324
 325   switch (t->kind)
 326     {
 327     case TDESC_TYPE_STRUCT:
 328     case TDESC_TYPE_FLAGS:
 329       if (t->size > 0)
 330         string_appendf (*m_buffer, " size=\"%d\"", t->size);
 331       string_appendf (*m_buffer, ">\n");
 332
 333       for (const tdesc_type_field &f : t->fields)
 334         {
 335           string_appendf (*m_buffer, "  <field name=\"%s\" ", f.name.c_str ());
 336           if (f.start == -1)
 337             string_appendf (*m_buffer, "type=\"%s\"/>\n",
 338                             f.type->name.c_str ());
 339           else
 340             string_appendf (*m_buffer, "start=\"%d\" end=\"%d\"/>\n", f.start,
 341                             f.end);
 342         }
 343       break;
 344
 345     case TDESC_TYPE_ENUM:
 346       string_appendf (*m_buffer, ">\n");
 347       for (const tdesc_type_field &f : t->fields)
 348         string_appendf (*m_buffer, "  <field name=\"%s\" start=\"%d\"/>\n",
 349                         f.name.c_str (), f.start);
 350       break;
 351
 352     case TDESC_TYPE_UNION:
 353       string_appendf (*m_buffer, ">\n");
 354       for (const tdesc_type_field &f : t->fields)
 355         string_appendf (*m_buffer, "  <field name=\"%s\" type=\"%s\"/>\n",
 356                         f.name.c_str (), f.type->name.c_str ());
 357       break;
 358
 359     default:
 360       error (_("xml output is not supported for type \"%s\"."),
 361              t->name.c_str ());
 362     }
 363
 364   string_appendf (*m_buffer, "</%s>\n", types[t->kind - TDESC_TYPE_STRUCT]);
 365 }
 366
 367 void print_xml_feature::visit (const tdesc_reg *r)
 368 {
 369   string_appendf (*m_buffer,
 370                   "<reg name=\"%s\" bitsize=\"%d\" type=\"%s\" regnum=\"%ld\"",
 371                   r->name.c_str (), r->bitsize, r->type.c_str (),
 372                   r->target_regnum);
 373
 374   if (r->group.length () > 0)
 375     string_appendf (*m_buffer, " group=\"%s\"", r->group.c_str ());
 376
 377   if (r->save_restore == 0)
 378     string_appendf (*m_buffer, " save-restore=\"no\"");
 379
 380   string_appendf (*m_buffer, "/>\n");
 381 }
 382
 383 void print_xml_feature::visit_pre (const target_desc *e)
 384 {
 385 #ifndef IN_PROCESS_AGENT
 386   string_appendf (*m_buffer, "<?xml version=\"1.0\"?>\n");
 387   string_appendf (*m_buffer, "<!DOCTYPE target SYSTEM \"gdb-target.dtd\">\n");
 388   string_appendf (*m_buffer, "<target>\n<architecture>%s</architecture>\n",
 389                   tdesc_architecture_name (e));
 390
 391   const char *osabi = tdesc_osabi_name (e);
 392   if (osabi != nullptr)
 393     string_appendf (*m_buffer, "<osabi>%s</osabi>", osabi);
 394 #endif
 395 }
 396
 397 void print_xml_feature::visit_post (const target_desc *e)
 398 {
 399   string_appendf (*m_buffer, "</target>\n");
 400 }