Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
target/arc: fix clang static analyzer warnings
[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 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.");
170 goto fail;
171 }
172
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 */
180
181 while (goi.argc > 0 && e == JIM_OK) {
182 Jim_Nvp *n;
183 e = Jim_GetOpt_Nvp(&goi, nvp_add_reg_type_flags_opts, &n);
184 if (e != JIM_OK) {
185 Jim_GetOpt_NvpUnknown(&goi, nvp_add_reg_type_flags_opts, 0);
186 continue;
187 }
188
189 switch (n->value) {
190 case CFG_ADD_REG_TYPE_FLAGS_NAME:
191 {
192 const char *name = NULL;
193 int name_len = 0;
194
195 e = jim_arc_read_reg_name_field(&goi, &name, &name_len);
196 if (e != JIM_OK) {
197 Jim_SetResultFormatted(goi.interp, "Unable to read reg name.");
198 goto fail;
199 }
200
201 if (name_len > REG_TYPE_MAX_NAME_LENGTH) {
202 Jim_SetResultFormatted(goi.interp, "Reg type name is too big.");
203 goto fail;
204 }
205
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.");
209 goto fail;
210 }
211
212 break;
213 }
214
215 case CFG_ADD_REG_TYPE_FLAGS_FLAG:
216 {
217 const char *field_name = NULL;
218 int field_name_len = 0;
219
220 e = jim_arc_read_reg_type_field(&goi, &field_name, &field_name_len, bitfields,
221 cur_field, CFG_ADD_REG_TYPE_FLAG);
222 if (e != JIM_OK) {
223 Jim_SetResultFormatted(goi.interp, "Unable to add reg_type_flag field.");
224 goto fail;
225 }
226
227 if (field_name_len > REG_TYPE_MAX_NAME_LENGTH) {
228 Jim_SetResultFormatted(goi.interp, "Reg type field_name_len is too big.");
229 goto fail;
230 }
231
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. ");
236 goto fail;
237 }
238
239 fields[cur_field].bitfield = &(bitfields[cur_field].bitfield);
240 if (cur_field > 0)
241 fields[cur_field - 1].next = &(fields[cur_field]);
242 else
243 flags->fields = fields;
244
245 cur_field += 1;
246 break;
247 }
248 }
249 }
250
251 if (!type->data_type.id) {
252 Jim_SetResultFormatted(goi.interp, "-name is a required option");
253 goto fail;
254 }
255
256 arc_reg_data_type_add(target, type);
257
258 LOG_DEBUG("added flags type {name=%s}", type->data_type.id);
259
260 return JIM_OK;
261 fail:
262 free(type);
263 free(fields);
264 free(bitfields);
265
266 return JIM_ERR;
267 }
268
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,
273 };
274
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 }
279 };
280
281 static int jim_arc_set_aux_reg(Jim_Interp *interp, int argc, Jim_Obj * const *argv)
282 {
283
284 struct command_context *context;
285 struct target *target;
286 uint32_t regnum;
287 uint32_t value;
288
289 Jim_GetOptInfo goi;
290 JIM_CHECK_RETVAL(Jim_GetOpt_Setup(&goi, interp, argc-1, argv+1));
291
292 if (goi.argc != 2) {
293 Jim_SetResultFormatted(goi.interp,
294 "usage: %s <aux_reg_num> <aux_reg_value>", Jim_GetString(argv[0], NULL));
295 return JIM_ERR;
296 }
297
298 context = current_command_context(interp);
299 assert(context);
300
301 target = get_current_target(context);
302 if (!target) {
303 Jim_SetResultFormatted(goi.interp, "No current target");
304 return JIM_ERR;
305 }
306
307 /* Register number */
308 JIM_CHECK_RETVAL(arc_cmd_jim_get_uint32(&goi, &regnum));
309
310 /* Register value */
311 JIM_CHECK_RETVAL(arc_cmd_jim_get_uint32(&goi, &value));
312
313 struct arc_common *arc = target_to_arc(target);
314 assert(arc);
315
316 CHECK_RETVAL(arc_jtag_write_aux_reg_one(&arc->jtag_info, regnum, value));
317
318 return ERROR_OK;
319 }
320
321 static int jim_arc_get_aux_reg(Jim_Interp *interp, int argc, Jim_Obj * const *argv)
322 {
323 struct command_context *context;
324 struct target *target;
325 uint32_t regnum;
326 uint32_t value;
327
328 Jim_GetOptInfo goi;
329 JIM_CHECK_RETVAL(Jim_GetOpt_Setup(&goi, interp, argc-1, argv+1));
330
331 if (goi.argc != 1) {
332 Jim_SetResultFormatted(goi.interp,
333 "usage: %s <aux_reg_num>", Jim_GetString(argv[0], NULL));
334 return JIM_ERR;
335 }
336
337 context = current_command_context(interp);
338 assert(context);
339
340 target = get_current_target(context);
341 if (!target) {
342 Jim_SetResultFormatted(goi.interp, "No current target");
343 return JIM_ERR;
344 }
345
346 /* Register number */
347 JIM_CHECK_RETVAL(arc_cmd_jim_get_uint32(&goi, &regnum));
348
349 struct arc_common *arc = target_to_arc(target);
350 assert(arc);
351
352 CHECK_RETVAL(arc_jtag_read_aux_reg_one(&arc->jtag_info, regnum, &value));
353 Jim_SetResultInt(interp, value);
354
355 return ERROR_OK;
356 }
357
358 static int jim_arc_get_core_reg(Jim_Interp *interp, int argc, Jim_Obj * const *argv)
359 {
360 struct command_context *context;
361 struct target *target;
362 uint32_t regnum;
363 uint32_t value;
364
365 Jim_GetOptInfo goi;
366 JIM_CHECK_RETVAL(Jim_GetOpt_Setup(&goi, interp, argc-1, argv+1));
367
368 if (goi.argc != 1) {
369 Jim_SetResultFormatted(goi.interp,
370 "usage: %s <core_reg_num>", Jim_GetString(argv[0], NULL));
371 return JIM_ERR;
372 }
373
374 context = current_command_context(interp);
375 assert(context);
376
377 target = get_current_target(context);
378 if (!target) {
379 Jim_SetResultFormatted(goi.interp, "No current target");
380 return JIM_ERR;
381 }
382
383 /* Register number */
384 JIM_CHECK_RETVAL(arc_cmd_jim_get_uint32(&goi, &regnum));
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);
388 return JIM_ERR;
389 }
390
391 struct arc_common *arc = target_to_arc(target);
392 assert(arc);
393
394 /* Read value */
395 CHECK_RETVAL(arc_jtag_read_core_reg_one(&arc->jtag_info, regnum, &value));
396 Jim_SetResultInt(interp, value);
397
398 return ERROR_OK;
399 }
400
401 static int jim_arc_set_core_reg(Jim_Interp *interp, int argc, Jim_Obj * const *argv)
402 {
403 struct command_context *context;
404 struct target *target;
405 uint32_t regnum;
406 uint32_t value;
407
408 Jim_GetOptInfo goi;
409 JIM_CHECK_RETVAL(Jim_GetOpt_Setup(&goi, interp, argc-1, argv+1));
410
411 if (goi.argc != 2) {
412 Jim_SetResultFormatted(goi.interp,
413 "usage: %s <core_reg_num> <core_reg_value>", Jim_GetString(argv[0], NULL));
414 return JIM_ERR;
415 }
416
417 context = current_command_context(interp);
418 assert(context);
419
420 target = get_current_target(context);
421 if (!target) {
422 Jim_SetResultFormatted(goi.interp, "No current target");
423 return JIM_ERR;
424 }
425
426 /* Register number */
427 JIM_CHECK_RETVAL(arc_cmd_jim_get_uint32(&goi, &regnum));
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);
431 return JIM_ERR;
432 }
433
434 /* Register value */
435 JIM_CHECK_RETVAL(arc_cmd_jim_get_uint32(&goi, &value));
436
437 struct arc_common *arc = target_to_arc(target);
438 assert(arc);
439
440 CHECK_RETVAL(arc_jtag_write_core_reg_one(&arc->jtag_info, regnum, value));
441
442 return ERROR_OK;
443 }
444
445 static const struct command_registration arc_jtag_command_group[] = {
446 {
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>"
455 },
456 {
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>"
465 },
466 {
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>]"
475 },
476 {
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>]"
485 },
486 COMMAND_REGISTRATION_DONE
487 };
488
489
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)
493 {
494 Jim_GetOptInfo goi;
495 JIM_CHECK_RETVAL(Jim_GetOpt_Setup(&goi, interp, argc-1, argv+1));
496
497 LOG_DEBUG("-");
498
499 struct command_context *ctx;
500 struct target *target;
501
502 ctx = current_command_context(interp);
503 assert(ctx);
504 target = get_current_target(ctx);
505 if (!target) {
506 Jim_SetResultFormatted(goi.interp, "No current target");
507 return JIM_ERR;
508 }
509
510 int e = JIM_OK;
511
512 /* Check if the amount of argnuments is not zero */
513 if (goi.argc <= 0) {
514 Jim_SetResultFormatted(goi.interp, "The command has no argnuments");
515 return JIM_ERR;
516 }
517
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;
522
523 /* Tha maximum amount of bitfilds is 32 */
524 if (fields_sz > 32) {
525 Jim_SetResultFormatted(goi.interp, "The amount of bitfields exceed 32");
526 return JIM_ERR;
527 }
528
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.");
536 goto fail;
537 }
538
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 */
546
547 while (goi.argc > 0 && e == JIM_OK) {
548 Jim_Nvp *n;
549 e = Jim_GetOpt_Nvp(&goi, nvp_add_reg_type_struct_opts, &n);
550 if (e != JIM_OK) {
551 Jim_GetOpt_NvpUnknown(&goi, nvp_add_reg_type_struct_opts, 0);
552 continue;
553 }
554
555 switch (n->value) {
556 case CFG_ADD_REG_TYPE_STRUCT_NAME:
557 {
558 const char *name = NULL;
559 int name_len = 0;
560
561 e = jim_arc_read_reg_name_field(&goi, &name, &name_len);
562 if (e != JIM_OK) {
563 Jim_SetResultFormatted(goi.interp, "Unable to read reg name.");
564 goto fail;
565 }
566
567 if (name_len > REG_TYPE_MAX_NAME_LENGTH) {
568 Jim_SetResultFormatted(goi.interp, "Reg type name is too big.");
569 goto fail;
570 }
571
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.");
575 goto fail;
576 }
577
578 break;
579 }
580 case CFG_ADD_REG_TYPE_STRUCT_BITFIELD:
581 {
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);
586 if (e != JIM_OK) {
587 Jim_SetResultFormatted(goi.interp, "Unable to add reg_type_struct field.");
588 goto fail;
589 }
590
591 if (field_name_len > REG_TYPE_MAX_NAME_LENGTH) {
592 Jim_SetResultFormatted(goi.interp, "Reg type field_name_len is too big.");
593 goto fail;
594 }
595
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. ");
600 goto fail;
601 }
602
603 fields[cur_field].bitfield = &(bitfields[cur_field].bitfield);
604 fields[cur_field].use_bitfields = true;
605 if (cur_field > 0)
606 fields[cur_field - 1].next = &(fields[cur_field]);
607 else
608 struct_type->fields = fields;
609
610 cur_field += 1;
611
612 break;
613 }
614 }
615 }
616
617 if (!type->data_type.id) {
618 Jim_SetResultFormatted(goi.interp, "-name is a required option");
619 goto fail;
620 }
621
622 arc_reg_data_type_add(target, type);
623 LOG_DEBUG("added struct type {name=%s}", type->data_type.id);
624 return JIM_OK;
625
626 fail:
627 free(type);
628 free(fields);
629 free(bitfields);
630
631 return JIM_ERR;
632 }
633
634 /* Add register */
635 enum opts_add_reg {
636 CFG_ADD_REG_NAME,
637 CFG_ADD_REG_ARCH_NUM,
638 CFG_ADD_REG_IS_CORE,
639 CFG_ADD_REG_IS_BCR,
640 CFG_ADD_REG_GDB_FEATURE,
641 CFG_ADD_REG_TYPE,
642 CFG_ADD_REG_GENERAL,
643 };
644
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 }
654 };
655
656 void free_reg_desc(struct arc_reg_desc *r)
657 {
658 free(r->name);
659 free(r->gdb_xml_feature);
660 free(r);
661 }
662
663 static int jim_arc_add_reg(Jim_Interp *interp, int argc, Jim_Obj * const *argv)
664 {
665 Jim_GetOptInfo goi;
666 JIM_CHECK_RETVAL(Jim_GetOpt_Setup(&goi, interp, argc-1, argv+1));
667
668 struct arc_reg_desc *reg = calloc(1, sizeof(*reg));
669 if (!reg) {
670 Jim_SetResultFormatted(goi.interp, "Failed to allocate memory.");
671 return JIM_ERR;
672 }
673
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);
679 int e = ERROR_OK;
680
681 /* At least we need to specify 4 parameters: name, number, type and gdb_feature,
682 * which means there should be 8 arguments */
683 if (goi.argc < 8) {
684 free_reg_desc(reg);
685 Jim_SetResultFormatted(goi.interp,
686 "Should be at least 8 argnuments: -name <name> "
687 "-num <num> -type <type> -feature <gdb_feature>.");
688 return JIM_ERR;
689 }
690
691 /* Parse options. */
692 while (goi.argc > 0) {
693 Jim_Nvp *n;
694 e = Jim_GetOpt_Nvp(&goi, opts_nvp_add_reg, &n);
695 if (e != JIM_OK) {
696 Jim_GetOpt_NvpUnknown(&goi, opts_nvp_add_reg, 0);
697 free_reg_desc(reg);
698 return e;
699 }
700
701 switch (n->value) {
702 case CFG_ADD_REG_NAME:
703 {
704 const char *reg_name = NULL;
705 int reg_name_len = 0;
706
707 e = jim_arc_read_reg_name_field(&goi, &reg_name, &reg_name_len);
708 if (e != JIM_OK) {
709 Jim_SetResultFormatted(goi.interp, "Unable to read register name.");
710 free_reg_desc(reg);
711 return e;
712 }
713
714 reg->name = strndup(reg_name, reg_name_len);
715 break;
716 }
717 case CFG_ADD_REG_IS_CORE:
718 reg->is_core = true;
719 break;
720 case CFG_ADD_REG_IS_BCR:
721 reg->is_bcr = true;
722 break;
723 case CFG_ADD_REG_ARCH_NUM:
724 {
725 jim_wide archnum;
726
727 if (!goi.argc) {
728 free_reg_desc(reg);
729 Jim_WrongNumArgs(interp, goi.argc, goi.argv, "-num <int> ...");
730 return JIM_ERR;
731 }
732
733 e = Jim_GetOpt_Wide(&goi, &archnum);
734 if (e != JIM_OK) {
735 free_reg_desc(reg);
736 return e;
737 }
738
739 reg->arch_num = archnum;
740 arch_num_set = true;
741 break;
742 }
743 case CFG_ADD_REG_GDB_FEATURE:
744 {
745 const char *feature = NULL;
746 int feature_len = 0;
747
748 e = jim_arc_read_reg_name_field(&goi, &feature, &feature_len);
749 if (e != JIM_OK) {
750 Jim_SetResultFormatted(goi.interp, "Unable to read gdb_feature.");
751 free_reg_desc(reg);
752 return e;
753 }
754
755 reg->gdb_xml_feature = strndup(feature, feature_len);
756 break;
757 }
758 case CFG_ADD_REG_TYPE:
759 e = jim_arc_read_reg_name_field(&goi, &type_name, &type_name_len);
760 if (e != JIM_OK) {
761 Jim_SetResultFormatted(goi.interp, "Unable to read register type.");
762 free_reg_desc(reg);
763 return e;
764 }
765
766 break;
767 case CFG_ADD_REG_GENERAL:
768 reg->is_general = true;
769 break;
770 default:
771 LOG_DEBUG("Error: Unknown parameter");
772 free_reg_desc(reg);
773 return JIM_ERR;
774 }
775 }
776
777 /* Check that required fields are set */
778 const char * const errmsg = validate_register(reg, arch_num_set);
779 if (errmsg) {
780 Jim_SetResultFormatted(goi.interp, errmsg);
781 free_reg_desc(reg);
782 return JIM_ERR;
783 }
784
785 /* Add new register */
786 struct command_context *ctx;
787 struct target *target;
788
789 ctx = current_command_context(interp);
790 assert(ctx);
791 target = get_current_target(ctx);
792 if (!target) {
793 Jim_SetResultFormatted(goi.interp, "No current target");
794 free_reg_desc(reg);
795 return JIM_ERR;
796 }
797
798 reg->target = target;
799
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);
805 free_reg_desc(reg);
806 return JIM_ERR;
807 }
808
809 return e;
810 }
811
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)
815 {
816 struct target * const target = get_current_target(CMD_CTX);
817 if (!target) {
818 command_print(CMD, "Unable to get current target.");
819 return JIM_ERR;
820 }
821
822 if (!CMD_ARGC) {
823 command_print(CMD, "At least one register name must be specified.");
824 return ERROR_COMMAND_SYNTAX_ERROR;
825 }
826
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);
830
831 if (!r) {
832 command_print(CMD, "Register `%s' is not found.", reg_name);
833 return ERROR_COMMAND_ARGUMENT_INVALID;
834 }
835
836 r->exist = true;
837 }
838
839 return JIM_OK;
840 }
841
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)
845 {
846 Jim_GetOptInfo goi;
847 const char *reg_name, *field_name;
848 uint32_t value;
849 int retval;
850
851 JIM_CHECK_RETVAL(Jim_GetOpt_Setup(&goi, interp, argc-1, argv+1));
852
853 LOG_DEBUG("Reading register field");
854 if (goi.argc != 2) {
855 if (!goi.argc)
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>");
859 else
860 Jim_WrongNumArgs(interp, goi.argc, goi.argv, "<regname> <fieldname>");
861 return ERROR_COMMAND_SYNTAX_ERROR;
862 }
863
864 JIM_CHECK_RETVAL(Jim_GetOpt_String(&goi, &reg_name, NULL));
865 JIM_CHECK_RETVAL(Jim_GetOpt_String(&goi, &field_name, NULL));
866 assert(reg_name);
867 assert(field_name);
868
869 struct command_context * const ctx = current_command_context(interp);
870 assert(ctx);
871 struct target * const target = get_current_target(ctx);
872 if (!target) {
873 Jim_SetResultFormatted(goi.interp, "No current target");
874 return JIM_ERR;
875 }
876
877 retval = arc_reg_get_field(target, reg_name, field_name, &value);
878
879 switch (retval) {
880 case ERROR_OK:
881 break;
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.",
898 field_name);
899 return ERROR_COMMAND_ARGUMENT_INVALID;
900 default:
901 /* Pass through other errors. */
902 return retval;
903 }
904
905 Jim_SetResultInt(interp, value);
906
907 return JIM_OK;
908 }
909
910 /* ----- Exported target commands ------------------------------------------ */
911
912 static const struct command_registration arc_core_command_handlers[] = {
913 {
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 "
921 "at 32 bits.",
922 },
923 {
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.",
934 },
935 {
936 .name = "add-reg",
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'.",
945 },
946 {
947 .name = "set-reg-exists",
948 .handler = arc_set_reg_exists,
949 .mode = COMMAND_ANY,
950 .usage = "arc set-reg-exists <register-name> [<register-name>]...",
951 .help = "Set that register exists. Accepts multiple register names as "
952 "arguments.",
953 },
954 {
955 .name = "get-reg-field",
956 .jim_handler = jim_arc_get_reg_field,
957 .mode = COMMAND_ANY,
958 .usage = "arc get-reg-field <regname> <field_name>",
959 .help = "Returns value of field in a register with 'struct' type.",
960 },
961 {
962 .name = "jtag",
963 .mode = COMMAND_ANY,
964 .help = "ARC JTAG specific commands",
965 .usage = "",
966 .chain = arc_jtag_command_group,
967 },
968 COMMAND_REGISTRATION_DONE
969 };
970
971 const struct command_registration arc_monitor_command_handlers[] = {
972 {
973 .name = "arc",
974 .mode = COMMAND_ANY,
975 .help = "ARC monitor command group",
976 .usage = "Help info ...",
977 .chain = arc_core_command_handlers,
978 },
979 COMMAND_REGISTRATION_DONE
980 };
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)