Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
Introduce ARCv2 architecture related code
[openocd.git] / src / target / arc_cmd.c
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> *
7 * *
8 * SPDX-License-Identifier: GPL-2.0-or-later *
9 ***************************************************************************/
10
11 #ifdef HAVE_CONFIG_H
12 #include "config.h"
13 #endif
14
15 #include "arc.h"
16
17 /* --------------------------------------------------------------------------
18 *
19 * ARC targets expose command interface.
20 * It can be accessed via GDB through the (gdb) monitor command.
21 *
22 * ------------------------------------------------------------------------- */
23
24
25 static int arc_cmd_jim_get_uint32(Jim_GetOptInfo *goi, uint32_t *value)
26 {
27 jim_wide value_wide;
28 JIM_CHECK_RETVAL(Jim_GetOpt_Wide(goi, &value_wide));
29 *value = (uint32_t)value_wide;
30 return JIM_OK;
31 }
32
33 enum add_reg_types {
34 CFG_ADD_REG_TYPE_FLAG,
35 CFG_ADD_REG_TYPE_STRUCT,
36 };
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,
41 };
42
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 }
47 };
48
49 /* Helper function to check if all field required for register
50 * are set up */
51 static const char *validate_register(const struct arc_reg_desc * const reg, bool arch_num_set)
52 {
53 /* Check that required fields are set */
54 if (!reg->name)
55 return "-name option is required";
56 if (!reg->gdb_xml_feature)
57 return "-feature option is required";
58 if (!arch_num_set)
59 return "-num option is required";
60 if (reg->is_bcr && reg->is_core)
61 return "Register cannot be both -core and -bcr.";
62 return NULL;
63 }
64
65 /* Helper function to read the name of register type or register from
66 * configure files */
67 static int jim_arc_read_reg_name_field(Jim_GetOptInfo *goi,
68 const char **name, int *name_len)
69 {
70 int e = JIM_OK;
71
72 if (!goi->argc) {
73 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-name <name> ...");
74 return JIM_ERR;
75 }
76 e = Jim_GetOpt_String(goi, name, name_len);
77 return e;
78 }
79
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)
83 {
84 jim_wide start_pos, end_pos;
85
86 int e = JIM_OK;
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");
90 return JIM_ERR;
91 }
92
93 e = Jim_GetOpt_String(goi, field_name, field_name_len);
94 if (e != JIM_OK)
95 return e;
96
97 /* read start position of bitfield/flag */
98 e = Jim_GetOpt_Wide(goi, &start_pos);
99 if (e != JIM_OK)
100 return e;
101
102 end_pos = start_pos;
103
104 /* Check if any argnuments remain,
105 * set bitfields[cur_field].end if flag is multibit */
106 if (goi->argc > 0)
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);
112 if (e != JIM_OK) {
113 Jim_SetResultFormatted(goi->interp, "Error reading end position");
114 return e;
115 }
116 }
117
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;
122 return e;
123 }
124
125 static int jim_arc_add_reg_type_flags(Jim_Interp *interp, int argc,
126 Jim_Obj * const *argv)
127 {
128 Jim_GetOptInfo goi;
129 JIM_CHECK_RETVAL(Jim_GetOpt_Setup(&goi, interp, argc-1, argv+1));
130
131 LOG_DEBUG("-");
132
133 struct command_context *ctx;
134 struct target *target;
135
136 ctx = current_command_context(interp);
137 assert(ctx);
138 target = get_current_target(ctx);
139 if (!target) {
140 Jim_SetResultFormatted(goi.interp, "No current target");
141 return JIM_ERR;
142 }
143
144 int e = JIM_OK;
145
146 /* Check if the amount of argnuments is not zero */
147 if (goi.argc <= 0) {
148 Jim_SetResultFormatted(goi.interp, "The command has no argnuments");
149 return JIM_ERR;
150 }
151
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;
156
157 /* Tha maximum amount of bitfilds is 32 */
158 if (fields_sz > 32) {
159 Jim_SetResultFormatted(goi.interp, "The amount of bitfields exceed 32");
160 return JIM_ERR;
161 }
162
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 struct arc_reg_bitfield *bitfields = calloc(fields_sz, sizeof(*type));
167 if (!(type && fields && bitfields)) {
168 Jim_SetResultFormatted(goi.interp, "Failed to allocate memory.");
169 goto fail;
170 }
171
172 /* Initialize type */
173 type->bitfields = bitfields;
174 type->data_type.id = type->data_type_id;
175 type->data_type.type = REG_TYPE_ARCH_DEFINED;
176 type->data_type.type_class = REG_TYPE_CLASS_FLAGS;
177 type->data_type.reg_type_flags = flags;
178 flags->size = 4; /* For now ARC has only 32-bit registers */
179
180 while (goi.argc > 0 && e == JIM_OK) {
181 Jim_Nvp *n;
182 e = Jim_GetOpt_Nvp(&goi, nvp_add_reg_type_flags_opts, &n);
183 if (e != JIM_OK) {
184 Jim_GetOpt_NvpUnknown(&goi, nvp_add_reg_type_flags_opts, 0);
185 continue;
186 }
187
188 switch (n->value) {
189 case CFG_ADD_REG_TYPE_FLAGS_NAME:
190 {
191 const char *name = NULL;
192 int name_len = 0;
193
194 e = jim_arc_read_reg_name_field(&goi, &name, &name_len);
195 if (e != JIM_OK) {
196 Jim_SetResultFormatted(goi.interp, "Unable to read reg name.");
197 goto fail;
198 }
199
200 if (name_len > REG_TYPE_MAX_NAME_LENGTH) {
201 Jim_SetResultFormatted(goi.interp, "Reg type name is too big.");
202 goto fail;
203 }
204
205 strncpy((void *)type->data_type.id, name, name_len);
206 if (!type->data_type.id) {
207 Jim_SetResultFormatted(goi.interp, "Unable to setup reg type name.");
208 goto fail;
209 }
210
211 break;
212 }
213
214 case CFG_ADD_REG_TYPE_FLAGS_FLAG:
215 {
216 const char *field_name = NULL;
217 int field_name_len = 0;
218
219 e = jim_arc_read_reg_type_field(&goi, &field_name, &field_name_len, bitfields,
220 cur_field, CFG_ADD_REG_TYPE_FLAG);
221 if (e != JIM_OK) {
222 Jim_SetResultFormatted(goi.interp, "Unable to add reg_type_flag field.");
223 goto fail;
224 }
225
226 if (field_name_len > REG_TYPE_MAX_NAME_LENGTH) {
227 Jim_SetResultFormatted(goi.interp, "Reg type field_name_len is too big.");
228 goto fail;
229 }
230
231 fields[cur_field].name = bitfields[cur_field].name;
232 strncpy(bitfields[cur_field].name, field_name, field_name_len);
233 if (!fields[cur_field].name) {
234 Jim_SetResultFormatted(goi.interp, "Unable to setup field name. ");
235 goto fail;
236 }
237
238 fields[cur_field].bitfield = &(bitfields[cur_field].bitfield);
239 if (cur_field > 0)
240 fields[cur_field - 1].next = &(fields[cur_field]);
241 else
242 flags->fields = fields;
243
244 cur_field += 1;
245 break;
246 }
247 }
248 }
249
250 if (!type->data_type.id) {
251 Jim_SetResultFormatted(goi.interp, "-name is a required option");
252 goto fail;
253 }
254
255 arc_reg_data_type_add(target, type);
256
257 LOG_DEBUG("added flags type {name=%s}", type->data_type.id);
258
259 return JIM_OK;
260 fail:
261 free(type);
262 free(fields);
263 free(bitfields);
264
265 return JIM_ERR;
266 }
267
268 /* Add struct register data type */
269 enum add_reg_type_struct {
270 CFG_ADD_REG_TYPE_STRUCT_NAME,
271 CFG_ADD_REG_TYPE_STRUCT_BITFIELD,
272 };
273
274 static Jim_Nvp nvp_add_reg_type_struct_opts[] = {
275 { .name = "-name", .value = CFG_ADD_REG_TYPE_STRUCT_NAME },
276 { .name = "-bitfield", .value = CFG_ADD_REG_TYPE_STRUCT_BITFIELD },
277 { .name = NULL, .value = -1 }
278 };
279
280 static int jim_arc_set_aux_reg(Jim_Interp *interp, int argc, Jim_Obj * const *argv)
281 {
282
283 struct command_context *context;
284 struct target *target;
285 uint32_t regnum;
286 uint32_t value;
287
288 Jim_GetOptInfo goi;
289 JIM_CHECK_RETVAL(Jim_GetOpt_Setup(&goi, interp, argc-1, argv+1));
290
291 if (goi.argc != 2) {
292 Jim_SetResultFormatted(goi.interp,
293 "usage: %s <aux_reg_num> <aux_reg_value>", Jim_GetString(argv[0], NULL));
294 return JIM_ERR;
295 }
296
297 context = current_command_context(interp);
298 assert(context);
299
300 target = get_current_target(context);
301 if (!target) {
302 Jim_SetResultFormatted(goi.interp, "No current target");
303 return JIM_ERR;
304 }
305
306 /* Register number */
307 JIM_CHECK_RETVAL(arc_cmd_jim_get_uint32(&goi, &regnum));
308
309 /* Register value */
310 JIM_CHECK_RETVAL(arc_cmd_jim_get_uint32(&goi, &value));
311
312 struct arc_common *arc = target_to_arc(target);
313 assert(arc);
314
315 CHECK_RETVAL(arc_jtag_write_aux_reg_one(&arc->jtag_info, regnum, value));
316
317 return ERROR_OK;
318 }
319
320 static int jim_arc_get_aux_reg(Jim_Interp *interp, int argc, Jim_Obj * const *argv)
321 {
322 struct command_context *context;
323 struct target *target;
324 uint32_t regnum;
325 uint32_t value;
326
327 Jim_GetOptInfo goi;
328 JIM_CHECK_RETVAL(Jim_GetOpt_Setup(&goi, interp, argc-1, argv+1));
329
330 if (goi.argc != 1) {
331 Jim_SetResultFormatted(goi.interp,
332 "usage: %s <aux_reg_num>", Jim_GetString(argv[0], NULL));
333 return JIM_ERR;
334 }
335
336 context = current_command_context(interp);
337 assert(context);
338
339 target = get_current_target(context);
340 if (!target) {
341 Jim_SetResultFormatted(goi.interp, "No current target");
342 return JIM_ERR;
343 }
344
345 /* Register number */
346 JIM_CHECK_RETVAL(arc_cmd_jim_get_uint32(&goi, &regnum));
347
348 struct arc_common *arc = target_to_arc(target);
349 assert(arc);
350
351 CHECK_RETVAL(arc_jtag_read_aux_reg_one(&arc->jtag_info, regnum, &value));
352 Jim_SetResultInt(interp, value);
353
354 return ERROR_OK;
355 }
356
357 static int jim_arc_get_core_reg(Jim_Interp *interp, int argc, Jim_Obj * const *argv)
358 {
359 struct command_context *context;
360 struct target *target;
361 uint32_t regnum;
362 uint32_t value;
363
364 Jim_GetOptInfo goi;
365 JIM_CHECK_RETVAL(Jim_GetOpt_Setup(&goi, interp, argc-1, argv+1));
366
367 if (goi.argc != 1) {
368 Jim_SetResultFormatted(goi.interp,
369 "usage: %s <core_reg_num>", Jim_GetString(argv[0], NULL));
370 return JIM_ERR;
371 }
372
373 context = current_command_context(interp);
374 assert(context);
375
376 target = get_current_target(context);
377 if (!target) {
378 Jim_SetResultFormatted(goi.interp, "No current target");
379 return JIM_ERR;
380 }
381
382 /* Register number */
383 JIM_CHECK_RETVAL(arc_cmd_jim_get_uint32(&goi, &regnum));
384 if (regnum > CORE_REG_MAX_NUMBER || regnum == CORE_R61_NUM || regnum == CORE_R62_NUM) {
385 Jim_SetResultFormatted(goi.interp, "Core register number %i " \
386 "is invalid. Must less then 64 and not 61 and 62.", regnum);
387 return JIM_ERR;
388 }
389
390 struct arc_common *arc = target_to_arc(target);
391 assert(arc);
392
393 /* Read value */
394 CHECK_RETVAL(arc_jtag_read_core_reg_one(&arc->jtag_info, regnum, &value));
395 Jim_SetResultInt(interp, value);
396
397 return ERROR_OK;
398 }
399
400 static int jim_arc_set_core_reg(Jim_Interp *interp, int argc, Jim_Obj * const *argv)
401 {
402 struct command_context *context;
403 struct target *target;
404 uint32_t regnum;
405 uint32_t value;
406
407 Jim_GetOptInfo goi;
408 JIM_CHECK_RETVAL(Jim_GetOpt_Setup(&goi, interp, argc-1, argv+1));
409
410 if (goi.argc != 2) {
411 Jim_SetResultFormatted(goi.interp,
412 "usage: %s <core_reg_num> <core_reg_value>", Jim_GetString(argv[0], NULL));
413 return JIM_ERR;
414 }
415
416 context = current_command_context(interp);
417 assert(context);
418
419 target = get_current_target(context);
420 if (!target) {
421 Jim_SetResultFormatted(goi.interp, "No current target");
422 return JIM_ERR;
423 }
424
425 /* Register number */
426 JIM_CHECK_RETVAL(arc_cmd_jim_get_uint32(&goi, &regnum));
427 if (regnum > CORE_REG_MAX_NUMBER || regnum == CORE_R61_NUM || regnum == CORE_R62_NUM) {
428 Jim_SetResultFormatted(goi.interp, "Core register number %i " \
429 "is invalid. Must less then 64 and not 61 and 62.", regnum);
430 return JIM_ERR;
431 }
432
433 /* Register value */
434 JIM_CHECK_RETVAL(arc_cmd_jim_get_uint32(&goi, &value));
435
436 struct arc_common *arc = target_to_arc(target);
437 assert(arc);
438
439 CHECK_RETVAL(arc_jtag_write_core_reg_one(&arc->jtag_info, regnum, value));
440
441 return ERROR_OK;
442 }
443
444 static const struct command_registration arc_jtag_command_group[] = {
445 {
446 .name = "get-aux-reg",
447 .jim_handler = jim_arc_get_aux_reg,
448 .mode = COMMAND_EXEC,
449 .help = "Get AUX register by number. This command does a " \
450 "raw JTAG request that bypasses OpenOCD register cache "\
451 "and thus is unsafe and can have unexpected consequences. "\
452 "Use at your own risk.",
453 .usage = "arc jtag get-aux-reg <regnum>"
454 },
455 {
456 .name = "set-aux-reg",
457 .jim_handler = jim_arc_set_aux_reg,
458 .mode = COMMAND_EXEC,
459 .help = "Set AUX register by number. This command does a " \
460 "raw JTAG request that bypasses OpenOCD register cache "\
461 "and thus is unsafe and can have unexpected consequences. "\
462 "Use at your own risk.",
463 .usage = "arc jtag set-aux-reg <regnum> <value>"
464 },
465 {
466 .name = "get-core-reg",
467 .jim_handler = jim_arc_get_core_reg,
468 .mode = COMMAND_EXEC,
469 .help = "Get/Set core register by number. This command does a " \
470 "raw JTAG request that bypasses OpenOCD register cache "\
471 "and thus is unsafe and can have unexpected consequences. "\
472 "Use at your own risk.",
473 .usage = "arc jtag get-core-reg <regnum> [<value>]"
474 },
475 {
476 .name = "set-core-reg",
477 .jim_handler = jim_arc_set_core_reg,
478 .mode = COMMAND_EXEC,
479 .help = "Get/Set core register by number. This command does a " \
480 "raw JTAG request that bypasses OpenOCD register cache "\
481 "and thus is unsafe and can have unexpected consequences. "\
482 "Use at your own risk.",
483 .usage = "arc jtag set-core-reg <regnum> [<value>]"
484 },
485 COMMAND_REGISTRATION_DONE
486 };
487
488
489 /* This function supports only bitfields. */
490 static int jim_arc_add_reg_type_struct(Jim_Interp *interp, int argc,
491 Jim_Obj * const *argv)
492 {
493 Jim_GetOptInfo goi;
494 JIM_CHECK_RETVAL(Jim_GetOpt_Setup(&goi, interp, argc-1, argv+1));
495
496 LOG_DEBUG("-");
497
498 struct command_context *ctx;
499 struct target *target;
500
501 ctx = current_command_context(interp);
502 assert(ctx);
503 target = get_current_target(ctx);
504 if (!target) {
505 Jim_SetResultFormatted(goi.interp, "No current target");
506 return JIM_ERR;
507 }
508
509 int e = JIM_OK;
510
511 /* Check if the amount of argnuments is not zero */
512 if (goi.argc <= 0) {
513 Jim_SetResultFormatted(goi.interp, "The command has no argnuments");
514 return JIM_ERR;
515 }
516
517 /* Estimate number of registers as (argc - 2)/4 as each -bitfield option has 3
518 * arguments while -name is required. */
519 unsigned int fields_sz = (goi.argc - 2) / 4;
520 unsigned int cur_field = 0;
521
522 /* Tha maximum amount of bitfilds is 32 */
523 if (fields_sz > 32) {
524 Jim_SetResultFormatted(goi.interp, "The amount of bitfields exceed 32");
525 return JIM_ERR;
526 }
527
528 struct arc_reg_data_type *type = calloc(1, sizeof(*type));
529 struct reg_data_type_struct *struct_type = &type->data_type_struct;
530 struct reg_data_type_struct_field *fields = calloc(fields_sz, sizeof(*fields));
531 struct arc_reg_bitfield *bitfields = calloc(fields_sz, sizeof(*type));
532 if (!(type && fields && bitfields)) {
533 Jim_SetResultFormatted(goi.interp, "Failed to allocate memory.");
534 goto fail;
535 }
536
537 /* Initialize type */
538 type->data_type.id = type->data_type_id;
539 type->bitfields = bitfields;
540 type->data_type.type = REG_TYPE_ARCH_DEFINED;
541 type->data_type.type_class = REG_TYPE_CLASS_STRUCT;
542 type->data_type.reg_type_struct = struct_type;
543 struct_type->size = 4; /* For now ARC has only 32-bit registers */
544
545 while (goi.argc > 0 && e == JIM_OK) {
546 Jim_Nvp *n;
547 e = Jim_GetOpt_Nvp(&goi, nvp_add_reg_type_struct_opts, &n);
548 if (e != JIM_OK) {
549 Jim_GetOpt_NvpUnknown(&goi, nvp_add_reg_type_struct_opts, 0);
550 continue;
551 }
552
553 switch (n->value) {
554 case CFG_ADD_REG_TYPE_STRUCT_NAME:
555 {
556 const char *name = NULL;
557 int name_len = 0;
558
559 e = jim_arc_read_reg_name_field(&goi, &name, &name_len);
560 if (e != JIM_OK) {
561 Jim_SetResultFormatted(goi.interp, "Unable to read reg name.");
562 goto fail;
563 }
564
565 if (name_len > REG_TYPE_MAX_NAME_LENGTH) {
566 Jim_SetResultFormatted(goi.interp, "Reg type name is too big.");
567 goto fail;
568 }
569
570 strncpy((void *)type->data_type.id, name, name_len);
571 if (!type->data_type.id) {
572 Jim_SetResultFormatted(goi.interp, "Unable to setup reg type name.");
573 goto fail;
574 }
575
576 break;
577 }
578 case CFG_ADD_REG_TYPE_STRUCT_BITFIELD:
579 {
580 const char *field_name = NULL;
581 int field_name_len = 0;
582 e = jim_arc_read_reg_type_field(&goi, &field_name, &field_name_len, bitfields,
583 cur_field, CFG_ADD_REG_TYPE_STRUCT);
584 if (e != JIM_OK) {
585 Jim_SetResultFormatted(goi.interp, "Unable to add reg_type_struct field.");
586 goto fail;
587 }
588
589 if (field_name_len > REG_TYPE_MAX_NAME_LENGTH) {
590 Jim_SetResultFormatted(goi.interp, "Reg type field_name_len is too big.");
591 goto fail;
592 }
593
594 fields[cur_field].name = bitfields[cur_field].name;
595 strncpy(bitfields[cur_field].name, field_name, field_name_len);
596 if (!fields[cur_field].name) {
597 Jim_SetResultFormatted(goi.interp, "Unable to setup field name. ");
598 goto fail;
599 }
600
601 fields[cur_field].bitfield = &(bitfields[cur_field].bitfield);
602 fields[cur_field].use_bitfields = true;
603 if (cur_field > 0)
604 fields[cur_field - 1].next = &(fields[cur_field]);
605 else
606 struct_type->fields = fields;
607
608 cur_field += 1;
609
610 break;
611 }
612 }
613 }
614
615 if (!type->data_type.id) {
616 Jim_SetResultFormatted(goi.interp, "-name is a required option");
617 goto fail;
618 }
619
620 arc_reg_data_type_add(target, type);
621 LOG_DEBUG("added struct type {name=%s}", type->data_type.id);
622 return JIM_OK;
623
624 fail:
625 free(type);
626 free(fields);
627 free(bitfields);
628
629 return JIM_ERR;
630 }
631
632 /* Add register */
633 enum opts_add_reg {
634 CFG_ADD_REG_NAME,
635 CFG_ADD_REG_ARCH_NUM,
636 CFG_ADD_REG_IS_CORE,
637 CFG_ADD_REG_IS_BCR,
638 CFG_ADD_REG_GDB_FEATURE,
639 CFG_ADD_REG_TYPE,
640 CFG_ADD_REG_GENERAL,
641 };
642
643 static Jim_Nvp opts_nvp_add_reg[] = {
644 { .name = "-name", .value = CFG_ADD_REG_NAME },
645 { .name = "-num", .value = CFG_ADD_REG_ARCH_NUM },
646 { .name = "-core", .value = CFG_ADD_REG_IS_CORE },
647 { .name = "-bcr", .value = CFG_ADD_REG_IS_BCR },
648 { .name = "-feature", .value = CFG_ADD_REG_GDB_FEATURE },
649 { .name = "-type", .value = CFG_ADD_REG_TYPE },
650 { .name = "-g", .value = CFG_ADD_REG_GENERAL },
651 { .name = NULL, .value = -1 }
652 };
653
654 void free_reg_desc(struct arc_reg_desc *r)
655 {
656 free(r->name);
657 free(r->gdb_xml_feature);
658 free(r);
659 }
660
661 static int jim_arc_add_reg(Jim_Interp *interp, int argc, Jim_Obj * const *argv)
662 {
663 Jim_GetOptInfo goi;
664 JIM_CHECK_RETVAL(Jim_GetOpt_Setup(&goi, interp, argc-1, argv+1));
665
666 struct arc_reg_desc *reg = calloc(1, sizeof(*reg));
667 if (!reg) {
668 Jim_SetResultFormatted(goi.interp, "Failed to allocate memory.");
669 return JIM_ERR;
670 }
671
672 /* There is no architecture number that we could treat as invalid, so
673 * separate variable requried to ensure that arch num has been set. */
674 bool arch_num_set = false;
675 const char *type_name = "int"; /* Default type */
676 int type_name_len = strlen(type_name);
677 int e = ERROR_OK;
678
679 /* At least we need to specify 4 parameters: name, number, type and gdb_feature,
680 * which means there should be 8 arguments */
681 if (goi.argc < 8) {
682 free_reg_desc(reg);
683 Jim_SetResultFormatted(goi.interp,
684 "Should be at least 8 argnuments: -name <name> "
685 "-num <num> -type <type> -feature <gdb_feature>.");
686 return JIM_ERR;
687 }
688
689 /* Parse options. */
690 while (goi.argc > 0) {
691 Jim_Nvp *n;
692 e = Jim_GetOpt_Nvp(&goi, opts_nvp_add_reg, &n);
693 if (e != JIM_OK) {
694 Jim_GetOpt_NvpUnknown(&goi, opts_nvp_add_reg, 0);
695 free_reg_desc(reg);
696 return e;
697 }
698
699 switch (n->value) {
700 case CFG_ADD_REG_NAME:
701 {
702 const char *reg_name = NULL;
703 int reg_name_len = 0;
704
705 e = jim_arc_read_reg_name_field(&goi, &reg_name, &reg_name_len);
706 if (e != JIM_OK) {
707 Jim_SetResultFormatted(goi.interp, "Unable to read register name.");
708 free_reg_desc(reg);
709 return e;
710 }
711
712 reg->name = strndup(reg_name, reg_name_len);
713 break;
714 }
715 case CFG_ADD_REG_IS_CORE:
716 reg->is_core = true;
717 break;
718 case CFG_ADD_REG_IS_BCR:
719 reg->is_bcr = true;
720 break;
721 case CFG_ADD_REG_ARCH_NUM:
722 {
723 jim_wide archnum;
724
725 if (!goi.argc) {
726 free_reg_desc(reg);
727 Jim_WrongNumArgs(interp, goi.argc, goi.argv, "-num <int> ...");
728 return JIM_ERR;
729 }
730
731 e = Jim_GetOpt_Wide(&goi, &archnum);
732 if (e != JIM_OK) {
733 free_reg_desc(reg);
734 return e;
735 }
736
737 reg->arch_num = archnum;
738 arch_num_set = true;
739 break;
740 }
741 case CFG_ADD_REG_GDB_FEATURE:
742 {
743 const char *feature = NULL;
744 int feature_len = 0;
745
746 e = jim_arc_read_reg_name_field(&goi, &feature, &feature_len);
747 if (e != JIM_OK) {
748 Jim_SetResultFormatted(goi.interp, "Unable to read gdb_feature.");
749 free_reg_desc(reg);
750 return e;
751 }
752
753 reg->gdb_xml_feature = strndup(feature, feature_len);
754 break;
755 }
756 case CFG_ADD_REG_TYPE:
757 e = jim_arc_read_reg_name_field(&goi, &type_name, &type_name_len);
758 if (e != JIM_OK) {
759 Jim_SetResultFormatted(goi.interp, "Unable to read register type.");
760 free_reg_desc(reg);
761 return e;
762 }
763
764 break;
765 case CFG_ADD_REG_GENERAL:
766 reg->is_general = true;
767 break;
768 default:
769 LOG_DEBUG("Error: Unknown parameter");
770 free_reg_desc(reg);
771 return JIM_ERR;
772 }
773 }
774
775 /* Check that required fields are set */
776 const char * const errmsg = validate_register(reg, arch_num_set);
777 if (errmsg) {
778 Jim_SetResultFormatted(goi.interp, errmsg);
779 free_reg_desc(reg);
780 return JIM_ERR;
781 }
782
783 /* Add new register */
784 struct command_context *ctx;
785 struct target *target;
786
787 ctx = current_command_context(interp);
788 assert(ctx);
789 target = get_current_target(ctx);
790 if (!target) {
791 Jim_SetResultFormatted(goi.interp, "No current target");
792 return JIM_ERR;
793 }
794
795 reg->target = target;
796
797 e = arc_reg_add(target, reg, type_name, type_name_len);
798 if (e == ERROR_ARC_REGTYPE_NOT_FOUND) {
799 Jim_SetResultFormatted(goi.interp,
800 "Cannot find type `%s' for register `%s'.",
801 type_name, reg->name);
802 free_reg_desc(reg);
803 return JIM_ERR;
804 }
805
806 return e;
807 }
808
809 /* arc set-reg-exists ($reg_name)+
810 * Accepts any amount of register names - will set them as existing in a loop.*/
811 COMMAND_HANDLER(arc_set_reg_exists)
812 {
813 struct target * const target = get_current_target(CMD_CTX);
814 if (!target) {
815 command_print(CMD, "Unable to get current target.");
816 return JIM_ERR;
817 }
818
819 if (!CMD_ARGC) {
820 command_print(CMD, "At least one register name must be specified.");
821 return ERROR_COMMAND_SYNTAX_ERROR;
822 }
823
824 for (unsigned int i = 0; i < CMD_ARGC; i++) {
825 const char * const reg_name = CMD_ARGV[i];
826 struct reg * const r = arc_reg_get_by_name(target->reg_cache, reg_name, true);
827
828 if (!r) {
829 command_print(CMD, "Register `%s' is not found.", reg_name);
830 return ERROR_COMMAND_ARGUMENT_INVALID;
831 }
832
833 r->exist = true;
834 }
835
836 return JIM_OK;
837 }
838
839 /* arc reg-field ($reg_name) ($reg_field)
840 * Reads struct type register field */
841 static int jim_arc_get_reg_field(Jim_Interp *interp, int argc, Jim_Obj * const *argv)
842 {
843 Jim_GetOptInfo goi;
844 const char *reg_name, *field_name;
845 uint32_t value;
846 int retval;
847
848 JIM_CHECK_RETVAL(Jim_GetOpt_Setup(&goi, interp, argc-1, argv+1));
849
850 LOG_DEBUG("Reading register field");
851 if (goi.argc != 2) {
852 if (!goi.argc)
853 Jim_WrongNumArgs(interp, goi.argc, goi.argv, "<regname> <fieldname>");
854 else if (goi.argc == 1)
855 Jim_WrongNumArgs(interp, goi.argc, goi.argv, "<fieldname>");
856 else
857 Jim_WrongNumArgs(interp, goi.argc, goi.argv, "<regname> <fieldname>");
858 return ERROR_COMMAND_SYNTAX_ERROR;
859 }
860
861 JIM_CHECK_RETVAL(Jim_GetOpt_String(&goi, &reg_name, NULL));
862 JIM_CHECK_RETVAL(Jim_GetOpt_String(&goi, &field_name, NULL));
863 assert(reg_name);
864 assert(field_name);
865
866 struct command_context * const ctx = current_command_context(interp);
867 assert(ctx);
868 struct target * const target = get_current_target(ctx);
869 if (!target) {
870 Jim_SetResultFormatted(goi.interp, "No current target");
871 return JIM_ERR;
872 }
873
874 retval = arc_reg_get_field(target, reg_name, field_name, &value);
875
876 switch (retval) {
877 case ERROR_OK:
878 break;
879 case ERROR_ARC_REGISTER_NOT_FOUND:
880 Jim_SetResultFormatted(goi.interp,
881 "Register `%s' has not been found.", reg_name);
882 return ERROR_COMMAND_ARGUMENT_INVALID;
883 case ERROR_ARC_REGISTER_IS_NOT_STRUCT:
884 Jim_SetResultFormatted(goi.interp,
885 "Register `%s' must have 'struct' type.", reg_name);
886 return ERROR_COMMAND_ARGUMENT_INVALID;
887 case ERROR_ARC_REGISTER_FIELD_NOT_FOUND:
888 Jim_SetResultFormatted(goi.interp,
889 "Field `%s' has not been found in register `%s'.",
890 field_name, reg_name);
891 return ERROR_COMMAND_ARGUMENT_INVALID;
892 case ERROR_ARC_FIELD_IS_NOT_BITFIELD:
893 Jim_SetResultFormatted(goi.interp,
894 "Field `%s' is not a 'bitfield' field in a structure.",
895 field_name);
896 return ERROR_COMMAND_ARGUMENT_INVALID;
897 default:
898 /* Pass through other errors. */
899 return retval;
900 }
901
902 Jim_SetResultInt(interp, value);
903
904 return JIM_OK;
905 }
906
907 /* ----- Exported target commands ------------------------------------------ */
908
909 static const struct command_registration arc_core_command_handlers[] = {
910 {
911 .name = "add-reg-type-flags",
912 .jim_handler = jim_arc_add_reg_type_flags,
913 .mode = COMMAND_CONFIG,
914 .usage = "arc ardd-reg-type-flags -name <string> -flag <name> <position> "
915 "[-flag <name> <position>]...",
916 .help = "Add new 'flags' register data type. Only single bit flags "
917 "are supported. Type name is global. Bitsize of register is fixed "
918 "at 32 bits.",
919 },
920 {
921 .name = "add-reg-type-struct",
922 .jim_handler = jim_arc_add_reg_type_struct,
923 .mode = COMMAND_CONFIG,
924 .usage = "arc add-reg-type-struct -name <string> -bitfield <name> <start> <end> "
925 "[-bitfield <name> <start> <end>]...",
926 .help = "Add new 'struct' register data type. Only bit-fields are "
927 "supported so far, which means that for each bitfield start and end "
928 "position bits must be specified. GDB also support type-fields, "
929 "where common type can be used instead. Type name is global. Bitsize of "
930 "register is fixed at 32 bits.",
931 },
932 {
933 .name = "add-reg",
934 .jim_handler = jim_arc_add_reg,
935 .mode = COMMAND_CONFIG,
936 .usage = "arc add-reg -name <string> -num <int> -feature <string> [-gdbnum <int>] "
937 "[-core|-bcr] [-type <type_name>] [-g]",
938 .help = "Add new register. Name, architectural number and feature name "
939 "are requried options. GDB regnum will default to previous register "
940 "(gdbnum + 1) and shouldn't be specified in most cases. Type "
941 "defaults to default GDB 'int'.",
942 },
943 {
944 .name = "set-reg-exists",
945 .handler = arc_set_reg_exists,
946 .mode = COMMAND_ANY,
947 .usage = "arc set-reg-exists <register-name> [<register-name>]...",
948 .help = "Set that register exists. Accepts multiple register names as "
949 "arguments.",
950 },
951 {
952 .name = "get-reg-field",
953 .jim_handler = jim_arc_get_reg_field,
954 .mode = COMMAND_ANY,
955 .usage = "arc get-reg-field <regname> <field_name>",
956 .help = "Returns value of field in a register with 'struct' type.",
957 },
958 {
959 .name = "jtag",
960 .mode = COMMAND_ANY,
961 .help = "ARC JTAG specific commands",
962 .usage = "",
963 .chain = arc_jtag_command_group,
964 },
965 COMMAND_REGISTRATION_DONE
966 };
967
968 const struct command_registration arc_monitor_command_handlers[] = {
969 {
970 .name = "arc",
971 .mode = COMMAND_ANY,
972 .help = "ARC monitor command group",
973 .usage = "Help info ...",
974 .chain = arc_core_command_handlers,
975 },
976 COMMAND_REGISTRATION_DONE
977 };
Open On-Chip Debugger

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)