1 /* Target description support for GDB. 2 3 Copyright (C) 2018-2023 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 "gdbsupport/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_half", TDESC_TYPE_IEEE_HALF }, 54 { "ieee_single", TDESC_TYPE_IEEE_SINGLE }, 55 { "ieee_double", TDESC_TYPE_IEEE_DOUBLE }, 56 { "arm_fpa_ext", TDESC_TYPE_ARM_FPA_EXT }, 57 { "i387_ext", TDESC_TYPE_I387_EXT }, 58 { "bfloat16", TDESC_TYPE_BFLOAT16 } 59 }; 60 61 void tdesc_feature::accept (tdesc_element_visitor &v) const 62 { 63 v.visit_pre (this); 64 65 for (const tdesc_type_up &type : types) 66 type->accept (v); 67 68 for (const tdesc_reg_up ® : registers) 69 reg->accept (v); 70 71 v.visit_post (this); 72 } 73 74 bool tdesc_feature::operator== (const tdesc_feature &other) const 75 { 76 if (name != other.name) 77 return false; 78 79 if (registers.size () != other.registers.size ()) 80 return false; 81 82 for (int ix = 0; ix < registers.size (); ix++) 83 { 84 const tdesc_reg_up ®1 = registers[ix]; 85 const tdesc_reg_up ®2 = other.registers[ix]; 86 87 if (reg1 != reg2 && *reg1 != *reg2) 88 return false; 89 } 90 91 if (types.size () != other.types.size ()) 92 return false; 93 94 for (int ix = 0; ix < types.size (); ix++) 95 { 96 const tdesc_type_up &type1 = types[ix]; 97 const tdesc_type_up &type2 = other.types[ix]; 98 99 if (type1 != type2 && *type1 != *type2) 100 return false; 101 } 102 103 return true; 104 } 105 106 /* Lookup a predefined type. */ 107 108 static struct tdesc_type * 109 tdesc_predefined_type (enum tdesc_type_kind kind) 110 { 111 for (int ix = 0; ix < ARRAY_SIZE (tdesc_predefined_types); ix++) 112 if (tdesc_predefined_types[ix].kind == kind) 113 return &tdesc_predefined_types[ix]; 114 115 gdb_assert_not_reached ("bad predefined tdesc type"); 116 } 117 118 /* See gdbsupport/tdesc.h. */ 119 120 struct tdesc_type * 121 tdesc_named_type (const struct tdesc_feature *feature, const char *id) 122 { 123 /* First try target-defined types. */ 124 for (const tdesc_type_up &type : feature->types) 125 if (type->name == id) 126 return type.get (); 127 128 /* Next try the predefined types. */ 129 for (int ix = 0; ix < ARRAY_SIZE (tdesc_predefined_types); ix++) 130 if (tdesc_predefined_types[ix].name == id) 131 return &tdesc_predefined_types[ix]; 132 133 return NULL; 134 } 135 136 /* See gdbsupport/tdesc.h. */ 137 138 void 139 tdesc_create_reg (struct tdesc_feature *feature, const char *name, 140 int regnum, int save_restore, const char *group, 141 int bitsize, const char *type) 142 { 143 tdesc_reg *reg = new tdesc_reg (feature, name, regnum, save_restore, 144 group, bitsize, type); 145 146 feature->registers.emplace_back (reg); 147 } 148 149 /* See gdbsupport/tdesc.h. */ 150 151 struct tdesc_type * 152 tdesc_create_vector (struct tdesc_feature *feature, const char *name, 153 struct tdesc_type *field_type, int count) 154 { 155 tdesc_type_vector *type = new tdesc_type_vector (name, field_type, count); 156 feature->types.emplace_back (type); 157 158 return type; 159 } 160 161 /* See gdbsupport/tdesc.h. */ 162 163 tdesc_type_with_fields * 164 tdesc_create_struct (struct tdesc_feature *feature, const char *name) 165 { 166 tdesc_type_with_fields *type 167 = new tdesc_type_with_fields (name, TDESC_TYPE_STRUCT); 168 feature->types.emplace_back (type); 169 170 return type; 171 } 172 173 /* See gdbsupport/tdesc.h. */ 174 175 void 176 tdesc_set_struct_size (tdesc_type_with_fields *type, int size) 177 { 178 gdb_assert (type->kind == TDESC_TYPE_STRUCT); 179 gdb_assert (size > 0); 180 type->size = size; 181 } 182 183 /* See gdbsupport/tdesc.h. */ 184 185 tdesc_type_with_fields * 186 tdesc_create_union (struct tdesc_feature *feature, const char *name) 187 { 188 tdesc_type_with_fields *type 189 = new tdesc_type_with_fields (name, TDESC_TYPE_UNION); 190 feature->types.emplace_back (type); 191 192 return type; 193 } 194 195 /* See gdbsupport/tdesc.h. */ 196 197 tdesc_type_with_fields * 198 tdesc_create_flags (struct tdesc_feature *feature, const char *name, 199 int size) 200 { 201 gdb_assert (size > 0); 202 203 tdesc_type_with_fields *type 204 = new tdesc_type_with_fields (name, TDESC_TYPE_FLAGS, size); 205 feature->types.emplace_back (type); 206 207 return type; 208 } 209 210 /* See gdbsupport/tdesc.h. */ 211 212 tdesc_type_with_fields * 213 tdesc_create_enum (struct tdesc_feature *feature, const char *name, 214 int size) 215 { 216 gdb_assert (size > 0); 217 218 tdesc_type_with_fields *type 219 = new tdesc_type_with_fields (name, TDESC_TYPE_ENUM, size); 220 feature->types.emplace_back (type); 221 222 return type; 223 } 224 225 /* See gdbsupport/tdesc.h. */ 226 227 void 228 tdesc_add_field (tdesc_type_with_fields *type, const char *field_name, 229 struct tdesc_type *field_type) 230 { 231 gdb_assert (type->kind == TDESC_TYPE_UNION 232 || type->kind == TDESC_TYPE_STRUCT); 233 234 /* Initialize start and end so we know this is not a bit-field 235 when we print-c-tdesc. */ 236 type->fields.emplace_back (field_name, field_type, -1, -1); 237 } 238 239 /* See gdbsupport/tdesc.h. */ 240 241 void 242 tdesc_add_typed_bitfield (tdesc_type_with_fields *type, const char *field_name, 243 int start, int end, struct tdesc_type *field_type) 244 { 245 gdb_assert (type->kind == TDESC_TYPE_STRUCT 246 || type->kind == TDESC_TYPE_FLAGS); 247 gdb_assert (start >= 0 && end >= start); 248 249 type->fields.emplace_back (field_name, field_type, start, end); 250 } 251 252 /* See gdbsupport/tdesc.h. */ 253 254 void 255 tdesc_add_bitfield (tdesc_type_with_fields *type, const char *field_name, 256 int start, int end) 257 { 258 struct tdesc_type *field_type; 259 260 gdb_assert (start >= 0 && end >= start); 261 262 if (type->size > 4) 263 field_type = tdesc_predefined_type (TDESC_TYPE_UINT64); 264 else 265 field_type = tdesc_predefined_type (TDESC_TYPE_UINT32); 266 267 tdesc_add_typed_bitfield (type, field_name, start, end, field_type); 268 } 269 270 /* See gdbsupport/tdesc.h. */ 271 272 void 273 tdesc_add_flag (tdesc_type_with_fields *type, int start, 274 const char *flag_name) 275 { 276 gdb_assert (type->kind == TDESC_TYPE_FLAGS 277 || type->kind == TDESC_TYPE_STRUCT); 278 279 type->fields.emplace_back (flag_name, 280 tdesc_predefined_type (TDESC_TYPE_BOOL), 281 start, start); 282 } 283 284 /* See gdbsupport/tdesc.h. */ 285 286 void 287 tdesc_add_enum_value (tdesc_type_with_fields *type, int value, 288 const char *name) 289 { 290 gdb_assert (type->kind == TDESC_TYPE_ENUM); 291 type->fields.emplace_back (name, 292 tdesc_predefined_type (TDESC_TYPE_INT32), 293 value, -1); 294 } 295 296 void print_xml_feature::visit_pre (const tdesc_feature *e) 297 { 298 add_line ("<feature name=\"%s\">", e->name.c_str ()); 299 indent (1); 300 } 301 302 void print_xml_feature::visit_post (const tdesc_feature *e) 303 { 304 indent (-1); 305 add_line ("</feature>"); 306 } 307 308 void print_xml_feature::visit (const tdesc_type_builtin *t) 309 { 310 error (_("xml output is not supported for type \"%s\"."), t->name.c_str ()); 311 } 312 313 void print_xml_feature::visit (const tdesc_type_vector *t) 314 { 315 add_line ("<vector id=\"%s\" type=\"%s\" count=\"%d\"/>", 316 t->name.c_str (), t->element_type->name.c_str (), t->count); 317 } 318 319 void print_xml_feature::visit (const tdesc_type_with_fields *t) 320 { 321 const static char *types[] = { "struct", "union", "flags", "enum" }; 322 323 gdb_assert (t->kind >= TDESC_TYPE_STRUCT && t->kind <= TDESC_TYPE_ENUM); 324 325 std::string tmp; 326 327 string_appendf (tmp, 328 "<%s id=\"%s\"", types[t->kind - TDESC_TYPE_STRUCT], 329 t->name.c_str ()); 330 331 switch (t->kind) 332 { 333 case TDESC_TYPE_STRUCT: 334 case TDESC_TYPE_FLAGS: 335 if (t->size > 0) 336 string_appendf (tmp, " size=\"%d\"", t->size); 337 string_appendf (tmp, ">"); 338 add_line (tmp); 339 340 for (const tdesc_type_field &f : t->fields) 341 { 342 tmp.clear (); 343 string_appendf (tmp, " <field name=\"%s\"", f.name.c_str ()); 344 if (f.start != -1) 345 string_appendf (tmp, " start=\"%d\" end=\"%d\"", f.start, 346 f.end); 347 string_appendf (tmp, " type=\"%s\"/>", 348 f.type->name.c_str ()); 349 add_line (tmp); 350 } 351 break; 352 353 case TDESC_TYPE_ENUM: 354 if (t->size > 0) 355 string_appendf (tmp, " size=\"%d\"", t->size); 356 string_appendf (tmp, ">"); 357 add_line (tmp); 358 /* The 'start' of the field is reused as the enum value. The 'end' 359 of the field is always set to -1 for enum values. */ 360 for (const tdesc_type_field &f : t->fields) 361 add_line (" <evalue name=\"%s\" value=\"%d\"/>", 362 f.name.c_str (), f.start); 363 break; 364 365 case TDESC_TYPE_UNION: 366 string_appendf (tmp, ">"); 367 add_line (tmp); 368 for (const tdesc_type_field &f : t->fields) 369 add_line (" <field name=\"%s\" type=\"%s\"/>", 370 f.name.c_str (), f.type->name.c_str ()); 371 break; 372 373 default: 374 error (_("xml output is not supported for type \"%s\"."), 375 t->name.c_str ()); 376 } 377 378 add_line ("</%s>", types[t->kind - TDESC_TYPE_STRUCT]); 379 } 380 381 void print_xml_feature::visit (const tdesc_reg *r) 382 { 383 std::string tmp; 384 385 string_appendf (tmp, 386 "<reg name=\"%s\" bitsize=\"%d\" type=\"%s\" regnum=\"%ld\"", 387 r->name.c_str (), r->bitsize, r->type.c_str (), 388 r->target_regnum); 389 390 if (r->group.length () > 0) 391 string_appendf (tmp, " group=\"%s\"", r->group.c_str ()); 392 393 if (r->save_restore == 0) 394 string_appendf (tmp, " save-restore=\"no\""); 395 396 string_appendf (tmp, "/>"); 397 398 add_line (tmp); 399 } 400 401 void print_xml_feature::visit_pre (const target_desc *e) 402 { 403 #ifndef IN_PROCESS_AGENT 404 add_line ("<?xml version=\"1.0\"?>"); 405 add_line ("<!DOCTYPE target SYSTEM \"gdb-target.dtd\">"); 406 add_line ("<target>"); 407 indent (1); 408 if (tdesc_architecture_name (e)) 409 add_line ("<architecture>%s</architecture>", 410 tdesc_architecture_name (e)); 411 412 const char *osabi = tdesc_osabi_name (e); 413 if (osabi != nullptr) 414 add_line ("<osabi>%s</osabi>", osabi); 415 416 const std::vector<tdesc_compatible_info_up> &compatible_list 417 = tdesc_compatible_info_list (e); 418 for (const auto &c : compatible_list) 419 add_line ("<compatible>%s</compatible>", 420 tdesc_compatible_info_arch_name (c)); 421 #endif 422 } 423 424 void print_xml_feature::visit_post (const target_desc *e) 425 { 426 indent (-1); 427 add_line ("</target>"); 428 } 429 430 /* See gdbsupport/tdesc.h. */ 431 432 void 433 print_xml_feature::add_line (const std::string &str) 434 { 435 string_appendf (*m_buffer, "%*s", m_depth, ""); 436 string_appendf (*m_buffer, "%s", str.c_str ()); 437 string_appendf (*m_buffer, "\n"); 438 } 439 440 /* See gdbsupport/tdesc.h. */ 441 442 void 443 print_xml_feature::add_line (const char *fmt, ...) 444 { 445 std::string tmp; 446 447 va_list ap; 448 va_start (ap, fmt); 449 string_vappendf (tmp, fmt, ap); 450 va_end (ap); 451 add_line (tmp); 452 } 453