1 /***************************************************************************
2 * Copyright (C) 2013-2015,2019-2020 Synopsys, Inc. *
3 * Frank Dols <frank.dols@synopsys.com> *
4 * Mischa Jonker <mischa.jonker@synopsys.com> *
5 * Anton Kolesov <anton.kolesov@synopsys.com> *
6 * Evgeniy Didin <didin@synopsys.com> *
8 * SPDX-License-Identifier: GPL-2.0-or-later *
9 ***************************************************************************/
17 /* --------------------------------------------------------------------------
19 * ARC targets expose command interface.
20 * It can be accessed via GDB through the (gdb) monitor command.
22 * ------------------------------------------------------------------------- */
25 static int arc_cmd_jim_get_uint32(Jim_GetOptInfo *goi, uint32_t *value)
28 JIM_CHECK_RETVAL(Jim_GetOpt_Wide(goi, &value_wide));
29 *value = (uint32_t)value_wide;
34 CFG_ADD_REG_TYPE_FLAG,
35 CFG_ADD_REG_TYPE_STRUCT,
37 /* Add flags register data type */
38 enum add_reg_type_flags {
39 CFG_ADD_REG_TYPE_FLAGS_NAME,
40 CFG_ADD_REG_TYPE_FLAGS_FLAG,
43 static Jim_Nvp nvp_add_reg_type_flags_opts[] = {
44 { .name = "-name", .value = CFG_ADD_REG_TYPE_FLAGS_NAME },
45 { .name = "-flag", .value = CFG_ADD_REG_TYPE_FLAGS_FLAG },
46 { .name = NULL, .value = -1 }
49 /* Helper function to check if all field required for register
51 static const char *validate_register(const struct arc_reg_desc * const reg, bool arch_num_set)
53 /* Check that required fields are set */
55 return "-name option is required";
56 if (!reg->gdb_xml_feature)
57 return "-feature option is required";
59 return "-num option is required";
60 if (reg->is_bcr && reg->is_core)
61 return "Register cannot be both -core and -bcr.";
65 /* Helper function to read the name of register type or register from
67 static int jim_arc_read_reg_name_field(Jim_GetOptInfo *goi,
68 const char **name, int *name_len)
73 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-name <name> ...");
76 e = Jim_GetOpt_String(goi, name, name_len);
80 /* Helper function to read bitfields/flags of register type. */
81 static int jim_arc_read_reg_type_field(Jim_GetOptInfo *goi, const char **field_name, int *field_name_len,
82 struct arc_reg_bitfield *bitfields, int cur_field, int type)
84 jim_wide start_pos, end_pos;
87 if ((type == CFG_ADD_REG_TYPE_STRUCT && goi->argc < 3) ||
88 (type == CFG_ADD_REG_TYPE_FLAG && goi->argc < 2)) {
89 Jim_SetResultFormatted(goi->interp, "Not enough argmunets after -flag/-bitfield");
93 e = Jim_GetOpt_String(goi, field_name, field_name_len);
97 /* read start position of bitfield/flag */
98 e = Jim_GetOpt_Wide(goi, &start_pos);
104 /* Check if any argnuments remain,
105 * set bitfields[cur_field].end if flag is multibit */
107 /* Check current argv[0], if it is equal to "-flag",
108 * than bitfields[cur_field].end remains start */
109 if ((strcmp(Jim_String(goi->argv[0]), "-flag") && type == CFG_ADD_REG_TYPE_FLAG)
110 || (type == CFG_ADD_REG_TYPE_STRUCT)) {
111 e = Jim_GetOpt_Wide(goi, &end_pos);
113 Jim_SetResultFormatted(goi->interp, "Error reading end position");
118 bitfields[cur_field].bitfield.start = start_pos;
119 bitfields[cur_field].bitfield.end = end_pos;
120 if ((end_pos != start_pos) || (type == CFG_ADD_REG_TYPE_STRUCT))
121 bitfields[cur_field].bitfield.type = REG_TYPE_INT;
125 static int jim_arc_add_reg_type_flags(Jim_Interp *interp, int argc,
126 Jim_Obj * const *argv)
129 JIM_CHECK_RETVAL(Jim_GetOpt_Setup(&goi, interp, argc-1, argv+1));
133 struct command_context *ctx;
134 struct target *target;
136 ctx = current_command_context(interp);
138 target = get_current_target(ctx);
140 Jim_SetResultFormatted(goi.interp, "No current target");
146 /* Check if the amount of argnuments is not zero */
148 Jim_SetResultFormatted(goi.interp, "The command has no argnuments");
152 /* Estimate number of registers as (argc - 2)/3 as each -flag option has 2
153 * arguments while -name is required. */
154 unsigned int fields_sz = (goi.argc - 2) / 3;
155 unsigned int cur_field = 0;
157 /* Tha maximum amount of bitfilds is 32 */
158 if (fields_sz > 32) {
159 Jim_SetResultFormatted(goi.interp, "The amount of bitfields exceed 32");
163 struct arc_reg_data_type *type = calloc(1, sizeof(*type));
164 struct reg_data_type_flags *flags = &type->data_type_flags;
165 struct reg_data_type_flags_field *fields = calloc(fields_sz, sizeof(*fields));
166 type->reg_type_flags_field = fields;
167 struct arc_reg_bitfield *bitfields = calloc(fields_sz, sizeof(*bitfields));
168 if (!(type && fields && bitfields)) {
169 Jim_SetResultFormatted(goi.interp, "Failed to allocate memory.");
173 /* Initialize type */
174 type->bitfields = bitfields;
175 type->data_type.id = type->data_type_id;
176 type->data_type.type = REG_TYPE_ARCH_DEFINED;
177 type->data_type.type_class = REG_TYPE_CLASS_FLAGS;
178 type->data_type.reg_type_flags = flags;
179 flags->size = 4; /* For now ARC has only 32-bit registers */
181 while (goi.argc > 0 && e == JIM_OK) {
183 e = Jim_GetOpt_Nvp(&goi, nvp_add_reg_type_flags_opts, &n);
185 Jim_GetOpt_NvpUnknown(&goi, nvp_add_reg_type_flags_opts, 0);
190 case CFG_ADD_REG_TYPE_FLAGS_NAME:
192 const char *name = NULL;
195 e = jim_arc_read_reg_name_field(&goi, &name, &name_len);
197 Jim_SetResultFormatted(goi.interp, "Unable to read reg name.");
201 if (name_len > REG_TYPE_MAX_NAME_LENGTH) {
202 Jim_SetResultFormatted(goi.interp, "Reg type name is too big.");
206 strncpy((void *)type->data_type.id, name, name_len);
207 if (!type->data_type.id) {
208 Jim_SetResultFormatted(goi.interp, "Unable to setup reg type name.");
215 case CFG_ADD_REG_TYPE_FLAGS_FLAG:
217 const char *field_name = NULL;
218 int field_name_len = 0;
220 e = jim_arc_read_reg_type_field(&goi, &field_name, &field_name_len, bitfields,
221 cur_field, CFG_ADD_REG_TYPE_FLAG);
223 Jim_SetResultFormatted(goi.interp, "Unable to add reg_type_flag field.");
227 if (field_name_len > REG_TYPE_MAX_NAME_LENGTH) {
228 Jim_SetResultFormatted(goi.interp, "Reg type field_name_len is too big.");
232 fields[cur_field].name = bitfields[cur_field].name;
233 strncpy(bitfields[cur_field].name, field_name, field_name_len);
234 if (!fields[cur_field].name) {
235 Jim_SetResultFormatted(goi.interp, "Unable to setup field name. ");
239 fields[cur_field].bitfield = &(bitfields[cur_field].bitfield);
241 fields[cur_field - 1].next = &(fields[cur_field]);
243 flags->fields = fields;
251 if (!type->data_type.id) {
252 Jim_SetResultFormatted(goi.interp, "-name is a required option");
256 arc_reg_data_type_add(target, type);
258 LOG_DEBUG("added flags type {name=%s}", type->data_type.id);
269 /* Add struct register data type */
270 enum add_reg_type_struct {
271 CFG_ADD_REG_TYPE_STRUCT_NAME,
272 CFG_ADD_REG_TYPE_STRUCT_BITFIELD,
275 static Jim_Nvp nvp_add_reg_type_struct_opts[] = {
276 { .name = "-name", .value = CFG_ADD_REG_TYPE_STRUCT_NAME },
277 { .name = "-bitfield", .value = CFG_ADD_REG_TYPE_STRUCT_BITFIELD },
278 { .name = NULL, .value = -1 }
281 static int jim_arc_set_aux_reg(Jim_Interp *interp, int argc, Jim_Obj * const *argv)
284 struct command_context *context;
285 struct target *target;
290 JIM_CHECK_RETVAL(Jim_GetOpt_Setup(&goi, interp, argc-1, argv+1));
293 Jim_SetResultFormatted(goi.interp,
294 "usage: %s <aux_reg_num> <aux_reg_value>", Jim_GetString(argv[0], NULL));
298 context = current_command_context(interp);
301 target = get_current_target(context);
303 Jim_SetResultFormatted(goi.interp, "No current target");
307 /* Register number */
308 JIM_CHECK_RETVAL(arc_cmd_jim_get_uint32(&goi, ®num));
311 JIM_CHECK_RETVAL(arc_cmd_jim_get_uint32(&goi, &value));
313 struct arc_common *arc = target_to_arc(target);
316 CHECK_RETVAL(arc_jtag_write_aux_reg_one(&arc->jtag_info, regnum, value));
321 static int jim_arc_get_aux_reg(Jim_Interp *interp, int argc, Jim_Obj * const *argv)
323 struct command_context *context;
324 struct target *target;
329 JIM_CHECK_RETVAL(Jim_GetOpt_Setup(&goi, interp, argc-1, argv+1));
332 Jim_SetResultFormatted(goi.interp,
333 "usage: %s <aux_reg_num>", Jim_GetString(argv[0], NULL));
337 context = current_command_context(interp);
340 target = get_current_target(context);
342 Jim_SetResultFormatted(goi.interp, "No current target");
346 /* Register number */
347 JIM_CHECK_RETVAL(arc_cmd_jim_get_uint32(&goi, ®num));
349 struct arc_common *arc = target_to_arc(target);
352 CHECK_RETVAL(arc_jtag_read_aux_reg_one(&arc->jtag_info, regnum, &value));
353 Jim_SetResultInt(interp, value);
358 static int jim_arc_get_core_reg(Jim_Interp *interp, int argc, Jim_Obj * const *argv)
360 struct command_context *context;
361 struct target *target;
366 JIM_CHECK_RETVAL(Jim_GetOpt_Setup(&goi, interp, argc-1, argv+1));
369 Jim_SetResultFormatted(goi.interp,
370 "usage: %s <core_reg_num>", Jim_GetString(argv[0], NULL));
374 context = current_command_context(interp);
377 target = get_current_target(context);
379 Jim_SetResultFormatted(goi.interp, "No current target");
383 /* Register number */
384 JIM_CHECK_RETVAL(arc_cmd_jim_get_uint32(&goi, ®num));
385 if (regnum > CORE_REG_MAX_NUMBER || regnum == CORE_R61_NUM || regnum == CORE_R62_NUM) {
386 Jim_SetResultFormatted(goi.interp, "Core register number %i " \
387 "is invalid. Must less then 64 and not 61 and 62.", regnum);
391 struct arc_common *arc = target_to_arc(target);
395 CHECK_RETVAL(arc_jtag_read_core_reg_one(&arc->jtag_info, regnum, &value));
396 Jim_SetResultInt(interp, value);
401 static int jim_arc_set_core_reg(Jim_Interp *interp, int argc, Jim_Obj * const *argv)
403 struct command_context *context;
404 struct target *target;
409 JIM_CHECK_RETVAL(Jim_GetOpt_Setup(&goi, interp, argc-1, argv+1));
412 Jim_SetResultFormatted(goi.interp,
413 "usage: %s <core_reg_num> <core_reg_value>", Jim_GetString(argv[0], NULL));
417 context = current_command_context(interp);
420 target = get_current_target(context);
422 Jim_SetResultFormatted(goi.interp, "No current target");
426 /* Register number */
427 JIM_CHECK_RETVAL(arc_cmd_jim_get_uint32(&goi, ®num));
428 if (regnum > CORE_REG_MAX_NUMBER || regnum == CORE_R61_NUM || regnum == CORE_R62_NUM) {
429 Jim_SetResultFormatted(goi.interp, "Core register number %i " \
430 "is invalid. Must less then 64 and not 61 and 62.", regnum);
435 JIM_CHECK_RETVAL(arc_cmd_jim_get_uint32(&goi, &value));
437 struct arc_common *arc = target_to_arc(target);
440 CHECK_RETVAL(arc_jtag_write_core_reg_one(&arc->jtag_info, regnum, value));
445 static const struct command_registration arc_jtag_command_group[] = {
447 .name = "get-aux-reg",
448 .jim_handler = jim_arc_get_aux_reg,
449 .mode = COMMAND_EXEC,
450 .help = "Get AUX register by number. This command does a " \
451 "raw JTAG request that bypasses OpenOCD register cache "\
452 "and thus is unsafe and can have unexpected consequences. "\
453 "Use at your own risk.",
454 .usage = "arc jtag get-aux-reg <regnum>"
457 .name = "set-aux-reg",
458 .jim_handler = jim_arc_set_aux_reg,
459 .mode = COMMAND_EXEC,
460 .help = "Set AUX register by number. This command does a " \
461 "raw JTAG request that bypasses OpenOCD register cache "\
462 "and thus is unsafe and can have unexpected consequences. "\
463 "Use at your own risk.",
464 .usage = "arc jtag set-aux-reg <regnum> <value>"
467 .name = "get-core-reg",
468 .jim_handler = jim_arc_get_core_reg,
469 .mode = COMMAND_EXEC,
470 .help = "Get/Set core register by number. This command does a " \
471 "raw JTAG request that bypasses OpenOCD register cache "\
472 "and thus is unsafe and can have unexpected consequences. "\
473 "Use at your own risk.",
474 .usage = "arc jtag get-core-reg <regnum> [<value>]"
477 .name = "set-core-reg",
478 .jim_handler = jim_arc_set_core_reg,
479 .mode = COMMAND_EXEC,
480 .help = "Get/Set core register by number. This command does a " \
481 "raw JTAG request that bypasses OpenOCD register cache "\
482 "and thus is unsafe and can have unexpected consequences. "\
483 "Use at your own risk.",
484 .usage = "arc jtag set-core-reg <regnum> [<value>]"
486 COMMAND_REGISTRATION_DONE
490 /* This function supports only bitfields. */
491 static int jim_arc_add_reg_type_struct(Jim_Interp *interp, int argc,
492 Jim_Obj * const *argv)
495 JIM_CHECK_RETVAL(Jim_GetOpt_Setup(&goi, interp, argc-1, argv+1));
499 struct command_context *ctx;
500 struct target *target;
502 ctx = current_command_context(interp);
504 target = get_current_target(ctx);
506 Jim_SetResultFormatted(goi.interp, "No current target");
512 /* Check if the amount of argnuments is not zero */
514 Jim_SetResultFormatted(goi.interp, "The command has no argnuments");
518 /* Estimate number of registers as (argc - 2)/4 as each -bitfield option has 3
519 * arguments while -name is required. */
520 unsigned int fields_sz = (goi.argc - 2) / 4;
521 unsigned int cur_field = 0;
523 /* Tha maximum amount of bitfilds is 32 */
524 if (fields_sz > 32) {
525 Jim_SetResultFormatted(goi.interp, "The amount of bitfields exceed 32");
529 struct arc_reg_data_type *type = calloc(1, sizeof(*type));
530 struct reg_data_type_struct *struct_type = &type->data_type_struct;
531 struct reg_data_type_struct_field *fields = calloc(fields_sz, sizeof(*fields));
532 type->reg_type_struct_field = fields;
533 struct arc_reg_bitfield *bitfields = calloc(fields_sz, sizeof(*bitfields));
534 if (!(type && fields && bitfields)) {
535 Jim_SetResultFormatted(goi.interp, "Failed to allocate memory.");
539 /* Initialize type */
540 type->data_type.id = type->data_type_id;
541 type->bitfields = bitfields;
542 type->data_type.type = REG_TYPE_ARCH_DEFINED;
543 type->data_type.type_class = REG_TYPE_CLASS_STRUCT;
544 type->data_type.reg_type_struct = struct_type;
545 struct_type->size = 4; /* For now ARC has only 32-bit registers */
547 while (goi.argc > 0 && e == JIM_OK) {
549 e = Jim_GetOpt_Nvp(&goi, nvp_add_reg_type_struct_opts, &n);
551 Jim_GetOpt_NvpUnknown(&goi, nvp_add_reg_type_struct_opts, 0);
556 case CFG_ADD_REG_TYPE_STRUCT_NAME:
558 const char *name = NULL;
561 e = jim_arc_read_reg_name_field(&goi, &name, &name_len);
563 Jim_SetResultFormatted(goi.interp, "Unable to read reg name.");
567 if (name_len > REG_TYPE_MAX_NAME_LENGTH) {
568 Jim_SetResultFormatted(goi.interp, "Reg type name is too big.");
572 strncpy((void *)type->data_type.id, name, name_len);
573 if (!type->data_type.id) {
574 Jim_SetResultFormatted(goi.interp, "Unable to setup reg type name.");
580 case CFG_ADD_REG_TYPE_STRUCT_BITFIELD:
582 const char *field_name = NULL;
583 int field_name_len = 0;
584 e = jim_arc_read_reg_type_field(&goi, &field_name, &field_name_len, bitfields,
585 cur_field, CFG_ADD_REG_TYPE_STRUCT);
587 Jim_SetResultFormatted(goi.interp, "Unable to add reg_type_struct field.");
591 if (field_name_len > REG_TYPE_MAX_NAME_LENGTH) {
592 Jim_SetResultFormatted(goi.interp, "Reg type field_name_len is too big.");
596 fields[cur_field].name = bitfields[cur_field].name;
597 strncpy(bitfields[cur_field].name, field_name, field_name_len);
598 if (!fields[cur_field].name) {
599 Jim_SetResultFormatted(goi.interp, "Unable to setup field name. ");
603 fields[cur_field].bitfield = &(bitfields[cur_field].bitfield);
604 fields[cur_field].use_bitfields = true;
606 fields[cur_field - 1].next = &(fields[cur_field]);
608 struct_type->fields = fields;
617 if (!type->data_type.id) {
618 Jim_SetResultFormatted(goi.interp, "-name is a required option");
622 arc_reg_data_type_add(target, type);
623 LOG_DEBUG("added struct type {name=%s}", type->data_type.id);
637 CFG_ADD_REG_ARCH_NUM,
640 CFG_ADD_REG_GDB_FEATURE,
645 static Jim_Nvp opts_nvp_add_reg[] = {
646 { .name = "-name", .value = CFG_ADD_REG_NAME },
647 { .name = "-num", .value = CFG_ADD_REG_ARCH_NUM },
648 { .name = "-core", .value = CFG_ADD_REG_IS_CORE },
649 { .name = "-bcr", .value = CFG_ADD_REG_IS_BCR },
650 { .name = "-feature", .value = CFG_ADD_REG_GDB_FEATURE },
651 { .name = "-type", .value = CFG_ADD_REG_TYPE },
652 { .name = "-g", .value = CFG_ADD_REG_GENERAL },
653 { .name = NULL, .value = -1 }
656 void free_reg_desc(struct arc_reg_desc *r)
659 free(r->gdb_xml_feature);
663 static int jim_arc_add_reg(Jim_Interp *interp, int argc, Jim_Obj * const *argv)
666 JIM_CHECK_RETVAL(Jim_GetOpt_Setup(&goi, interp, argc-1, argv+1));
668 struct arc_reg_desc *reg = calloc(1, sizeof(*reg));
670 Jim_SetResultFormatted(goi.interp, "Failed to allocate memory.");
674 /* There is no architecture number that we could treat as invalid, so
675 * separate variable requried to ensure that arch num has been set. */
676 bool arch_num_set = false;
677 const char *type_name = "int"; /* Default type */
678 int type_name_len = strlen(type_name);
681 /* At least we need to specify 4 parameters: name, number, type and gdb_feature,
682 * which means there should be 8 arguments */
685 Jim_SetResultFormatted(goi.interp,
686 "Should be at least 8 argnuments: -name <name> "
687 "-num <num> -type <type> -feature <gdb_feature>.");
692 while (goi.argc > 0) {
694 e = Jim_GetOpt_Nvp(&goi, opts_nvp_add_reg, &n);
696 Jim_GetOpt_NvpUnknown(&goi, opts_nvp_add_reg, 0);
702 case CFG_ADD_REG_NAME:
704 const char *reg_name = NULL;
705 int reg_name_len = 0;
707 e = jim_arc_read_reg_name_field(&goi, ®_name, ®_name_len);
709 Jim_SetResultFormatted(goi.interp, "Unable to read register name.");
714 reg->name = strndup(reg_name, reg_name_len);
717 case CFG_ADD_REG_IS_CORE:
720 case CFG_ADD_REG_IS_BCR:
723 case CFG_ADD_REG_ARCH_NUM:
729 Jim_WrongNumArgs(interp, goi.argc, goi.argv, "-num <int> ...");
733 e = Jim_GetOpt_Wide(&goi, &archnum);
739 reg->arch_num = archnum;
743 case CFG_ADD_REG_GDB_FEATURE:
745 const char *feature = NULL;
748 e = jim_arc_read_reg_name_field(&goi, &feature, &feature_len);
750 Jim_SetResultFormatted(goi.interp, "Unable to read gdb_feature.");
755 reg->gdb_xml_feature = strndup(feature, feature_len);
758 case CFG_ADD_REG_TYPE:
759 e = jim_arc_read_reg_name_field(&goi, &type_name, &type_name_len);
761 Jim_SetResultFormatted(goi.interp, "Unable to read register type.");
767 case CFG_ADD_REG_GENERAL:
768 reg->is_general = true;
771 LOG_DEBUG("Error: Unknown parameter");
777 /* Check that required fields are set */
778 const char * const errmsg = validate_register(reg, arch_num_set);
780 Jim_SetResultFormatted(goi.interp, errmsg);
785 /* Add new register */
786 struct command_context *ctx;
787 struct target *target;
789 ctx = current_command_context(interp);
791 target = get_current_target(ctx);
793 Jim_SetResultFormatted(goi.interp, "No current target");
798 reg->target = target;
800 e = arc_reg_add(target, reg, type_name, type_name_len);
801 if (e == ERROR_ARC_REGTYPE_NOT_FOUND) {
802 Jim_SetResultFormatted(goi.interp,
803 "Cannot find type `%s' for register `%s'.",
804 type_name, reg->name);
812 /* arc set-reg-exists ($reg_name)+
813 * Accepts any amount of register names - will set them as existing in a loop.*/
814 COMMAND_HANDLER(arc_set_reg_exists)
816 struct target * const target = get_current_target(CMD_CTX);
818 command_print(CMD, "Unable to get current target.");
823 command_print(CMD, "At least one register name must be specified.");
824 return ERROR_COMMAND_SYNTAX_ERROR;
827 for (unsigned int i = 0; i < CMD_ARGC; i++) {
828 const char * const reg_name = CMD_ARGV[i];
829 struct reg * const r = arc_reg_get_by_name(target->reg_cache, reg_name, true);
832 command_print(CMD, "Register `%s' is not found.", reg_name);
833 return ERROR_COMMAND_ARGUMENT_INVALID;
842 /* arc reg-field ($reg_name) ($reg_field)
843 * Reads struct type register field */
844 static int jim_arc_get_reg_field(Jim_Interp *interp, int argc, Jim_Obj * const *argv)
847 const char *reg_name, *field_name;
851 JIM_CHECK_RETVAL(Jim_GetOpt_Setup(&goi, interp, argc-1, argv+1));
853 LOG_DEBUG("Reading register field");
856 Jim_WrongNumArgs(interp, goi.argc, goi.argv, "<regname> <fieldname>");
857 else if (goi.argc == 1)
858 Jim_WrongNumArgs(interp, goi.argc, goi.argv, "<fieldname>");
860 Jim_WrongNumArgs(interp, goi.argc, goi.argv, "<regname> <fieldname>");
861 return ERROR_COMMAND_SYNTAX_ERROR;
864 JIM_CHECK_RETVAL(Jim_GetOpt_String(&goi, ®_name, NULL));
865 JIM_CHECK_RETVAL(Jim_GetOpt_String(&goi, &field_name, NULL));
869 struct command_context * const ctx = current_command_context(interp);
871 struct target * const target = get_current_target(ctx);
873 Jim_SetResultFormatted(goi.interp, "No current target");
877 retval = arc_reg_get_field(target, reg_name, field_name, &value);
882 case ERROR_ARC_REGISTER_NOT_FOUND:
883 Jim_SetResultFormatted(goi.interp,
884 "Register `%s' has not been found.", reg_name);
885 return ERROR_COMMAND_ARGUMENT_INVALID;
886 case ERROR_ARC_REGISTER_IS_NOT_STRUCT:
887 Jim_SetResultFormatted(goi.interp,
888 "Register `%s' must have 'struct' type.", reg_name);
889 return ERROR_COMMAND_ARGUMENT_INVALID;
890 case ERROR_ARC_REGISTER_FIELD_NOT_FOUND:
891 Jim_SetResultFormatted(goi.interp,
892 "Field `%s' has not been found in register `%s'.",
893 field_name, reg_name);
894 return ERROR_COMMAND_ARGUMENT_INVALID;
895 case ERROR_ARC_FIELD_IS_NOT_BITFIELD:
896 Jim_SetResultFormatted(goi.interp,
897 "Field `%s' is not a 'bitfield' field in a structure.",
899 return ERROR_COMMAND_ARGUMENT_INVALID;
901 /* Pass through other errors. */
905 Jim_SetResultInt(interp, value);
910 /* ----- Exported target commands ------------------------------------------ */
912 static const struct command_registration arc_core_command_handlers[] = {
914 .name = "add-reg-type-flags",
915 .jim_handler = jim_arc_add_reg_type_flags,
916 .mode = COMMAND_CONFIG,
917 .usage = "arc ardd-reg-type-flags -name <string> -flag <name> <position> "
918 "[-flag <name> <position>]...",
919 .help = "Add new 'flags' register data type. Only single bit flags "
920 "are supported. Type name is global. Bitsize of register is fixed "
924 .name = "add-reg-type-struct",
925 .jim_handler = jim_arc_add_reg_type_struct,
926 .mode = COMMAND_CONFIG,
927 .usage = "arc add-reg-type-struct -name <string> -bitfield <name> <start> <end> "
928 "[-bitfield <name> <start> <end>]...",
929 .help = "Add new 'struct' register data type. Only bit-fields are "
930 "supported so far, which means that for each bitfield start and end "
931 "position bits must be specified. GDB also support type-fields, "
932 "where common type can be used instead. Type name is global. Bitsize of "
933 "register is fixed at 32 bits.",
937 .jim_handler = jim_arc_add_reg,
938 .mode = COMMAND_CONFIG,
939 .usage = "arc add-reg -name <string> -num <int> -feature <string> [-gdbnum <int>] "
940 "[-core|-bcr] [-type <type_name>] [-g]",
941 .help = "Add new register. Name, architectural number and feature name "
942 "are requried options. GDB regnum will default to previous register "
943 "(gdbnum + 1) and shouldn't be specified in most cases. Type "
944 "defaults to default GDB 'int'.",
947 .name = "set-reg-exists",
948 .handler = arc_set_reg_exists,
950 .usage = "arc set-reg-exists <register-name> [<register-name>]...",
951 .help = "Set that register exists. Accepts multiple register names as "
955 .name = "get-reg-field",
956 .jim_handler = jim_arc_get_reg_field,
958 .usage = "arc get-reg-field <regname> <field_name>",
959 .help = "Returns value of field in a register with 'struct' type.",
964 .help = "ARC JTAG specific commands",
966 .chain = arc_jtag_command_group,
968 COMMAND_REGISTRATION_DONE
971 const struct command_registration arc_monitor_command_handlers[] = {
975 .help = "ARC monitor command group",
976 .usage = "Help info ...",
977 .chain = arc_core_command_handlers,
979 COMMAND_REGISTRATION_DONE