OpenOCD
riscv.c
Go to the documentation of this file.
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 
3 #include <assert.h>
4 #include <stdlib.h>
5 #include <time.h>
6 
7 #ifdef HAVE_CONFIG_H
8 #include "config.h"
9 #endif
10 
11 #include <helper/log.h>
12 #include <helper/time_support.h>
13 #include "target/target.h"
14 #include "target/algorithm.h"
15 #include "target/target_type.h"
16 #include <target/smp.h>
17 #include "jtag/jtag.h"
18 #include "target/register.h"
19 #include "target/breakpoints.h"
20 #include "riscv.h"
21 #include "gdb_regs.h"
22 #include "rtos/rtos.h"
23 #include "debug_defines.h"
24 #include <helper/bits.h>
25 
26 #define get_field(reg, mask) (((reg) & (mask)) / ((mask) & ~((mask) << 1)))
27 #define set_field(reg, mask, val) (((reg) & ~(mask)) | (((val) * ((mask) & ~((mask) << 1))) & (mask)))
28 
29 /* Constants for legacy SiFive hardware breakpoints. */
30 #define CSR_BPCONTROL_X (1<<0)
31 #define CSR_BPCONTROL_W (1<<1)
32 #define CSR_BPCONTROL_R (1<<2)
33 #define CSR_BPCONTROL_U (1<<3)
34 #define CSR_BPCONTROL_S (1<<4)
35 #define CSR_BPCONTROL_H (1<<5)
36 #define CSR_BPCONTROL_M (1<<6)
37 #define CSR_BPCONTROL_BPMATCH (0xf<<7)
38 #define CSR_BPCONTROL_BPACTION (0xff<<11)
39 
40 #define DEBUG_ROM_START 0x800
41 #define DEBUG_ROM_RESUME (DEBUG_ROM_START + 4)
42 #define DEBUG_ROM_EXCEPTION (DEBUG_ROM_START + 8)
43 #define DEBUG_RAM_START 0x400
44 
45 #define SETHALTNOT 0x10c
46 
47 /*** JTAG registers. ***/
48 
49 #define DTMCONTROL 0x10
50 #define DTMCONTROL_DBUS_RESET (1<<16)
51 #define DTMCONTROL_IDLE (7<<10)
52 #define DTMCONTROL_ADDRBITS (0xf<<4)
53 #define DTMCONTROL_VERSION (0xf)
54 
55 #define DBUS 0x11
56 #define DBUS_OP_START 0
57 #define DBUS_OP_SIZE 2
58 typedef enum {
61  DBUS_OP_WRITE = 2
63 typedef enum {
68 #define DBUS_DATA_START 2
69 #define DBUS_DATA_SIZE 34
70 #define DBUS_ADDRESS_START 36
71 
72 typedef enum slot {
77 
78 /*** Debug Bus registers. ***/
79 
80 #define DMCONTROL 0x10
81 #define DMCONTROL_INTERRUPT (((uint64_t)1)<<33)
82 #define DMCONTROL_HALTNOT (((uint64_t)1)<<32)
83 #define DMCONTROL_BUSERROR (7<<19)
84 #define DMCONTROL_SERIAL (3<<16)
85 #define DMCONTROL_AUTOINCREMENT (1<<15)
86 #define DMCONTROL_ACCESS (7<<12)
87 #define DMCONTROL_HARTID (0x3ff<<2)
88 #define DMCONTROL_NDRESET (1<<1)
89 #define DMCONTROL_FULLRESET 1
90 
91 #define DMINFO 0x11
92 #define DMINFO_ABUSSIZE (0x7fU<<25)
93 #define DMINFO_SERIALCOUNT (0xf<<21)
94 #define DMINFO_ACCESS128 (1<<20)
95 #define DMINFO_ACCESS64 (1<<19)
96 #define DMINFO_ACCESS32 (1<<18)
97 #define DMINFO_ACCESS16 (1<<17)
98 #define DMINFO_ACCESS8 (1<<16)
99 #define DMINFO_DRAMSIZE (0x3f<<10)
100 #define DMINFO_AUTHENTICATED (1<<5)
101 #define DMINFO_AUTHBUSY (1<<4)
102 #define DMINFO_AUTHTYPE (3<<2)
103 #define DMINFO_VERSION 3
104 
105 /*** Info about the core being debugged. ***/
106 
107 #define DBUS_ADDRESS_UNKNOWN 0xffff
108 
109 #define MAX_HWBPS 16
110 #define DRAM_CACHE_SIZE 16
111 
112 static uint8_t ir_dtmcontrol[4] = {DTMCONTROL};
113 struct scan_field select_dtmcontrol = {
114  .in_value = NULL,
115  .out_value = ir_dtmcontrol
116 };
117 static uint8_t ir_dbus[4] = {DBUS};
118 struct scan_field select_dbus = {
119  .in_value = NULL,
120  .out_value = ir_dbus
121 };
122 static uint8_t ir_idcode[4] = {0x1};
123 struct scan_field select_idcode = {
124  .in_value = NULL,
125  .out_value = ir_idcode
126 };
127 
129 int bscan_tunnel_ir_width; /* if zero, then tunneling is not present/active */
130 
131 static const uint8_t bscan_zero[4] = {0};
132 static const uint8_t bscan_one[4] = {1};
133 
134 static uint8_t ir_user4[4];
135 static struct scan_field select_user4 = {
136  .in_value = NULL,
137  .out_value = ir_user4
138 };
139 
140 
141 static uint8_t bscan_tunneled_ir_width[4] = {5}; /* overridden by assignment in riscv_init_target */
143  {
144  .num_bits = 3,
145  .out_value = bscan_zero,
146  .in_value = NULL,
147  },
148  {
149  .num_bits = 5, /* initialized in riscv_init_target to ir width of DM */
150  .out_value = ir_dbus,
151  .in_value = NULL,
152  },
153  {
154  .num_bits = 7,
155  .out_value = bscan_tunneled_ir_width,
156  .in_value = NULL,
157  },
158  {
159  .num_bits = 1,
160  .out_value = bscan_zero,
161  .in_value = NULL,
162  }
163 };
164 
166  {
167  .num_bits = 1,
168  .out_value = bscan_zero,
169  .in_value = NULL,
170  },
171  {
172  .num_bits = 7,
173  .out_value = bscan_tunneled_ir_width,
174  .in_value = NULL,
175  },
176  {
177  .num_bits = 0, /* initialized in riscv_init_target to ir width of DM */
178  .out_value = ir_dbus,
179  .in_value = NULL,
180  },
181  {
182  .num_bits = 3,
183  .out_value = bscan_zero,
184  .in_value = NULL,
185  }
186 };
189 
192 
193 struct trigger {
194  uint64_t address;
195  uint32_t length;
196  uint64_t mask;
197  uint64_t value;
198  bool read, write, execute;
199  int unique_id;
200 };
201 
202 /* Wall-clock timeout for a command/access. Settable via RISC-V Target commands.*/
204 
205 /* Wall-clock timeout after reset. Settable via RISC-V Target commands.*/
207 
208 static bool riscv_enable_virt2phys = true;
209 bool riscv_ebreakm = true;
210 bool riscv_ebreaks = true;
211 bool riscv_ebreaku = true;
212 
214 
215 static enum {
219 
220 static const virt2phys_info_t sv32 = {
221  .name = "Sv32",
222  .va_bits = 32,
223  .level = 2,
224  .pte_shift = 2,
225  .vpn_shift = {12, 22},
226  .vpn_mask = {0x3ff, 0x3ff},
227  .pte_ppn_shift = {10, 20},
228  .pte_ppn_mask = {0x3ff, 0xfff},
229  .pa_ppn_shift = {12, 22},
230  .pa_ppn_mask = {0x3ff, 0xfff},
231 };
232 
233 static const virt2phys_info_t sv39 = {
234  .name = "Sv39",
235  .va_bits = 39,
236  .level = 3,
237  .pte_shift = 3,
238  .vpn_shift = {12, 21, 30},
239  .vpn_mask = {0x1ff, 0x1ff, 0x1ff},
240  .pte_ppn_shift = {10, 19, 28},
241  .pte_ppn_mask = {0x1ff, 0x1ff, 0x3ffffff},
242  .pa_ppn_shift = {12, 21, 30},
243  .pa_ppn_mask = {0x1ff, 0x1ff, 0x3ffffff},
244 };
245 
246 static const virt2phys_info_t sv48 = {
247  .name = "Sv48",
248  .va_bits = 48,
249  .level = 4,
250  .pte_shift = 3,
251  .vpn_shift = {12, 21, 30, 39},
252  .vpn_mask = {0x1ff, 0x1ff, 0x1ff, 0x1ff},
253  .pte_ppn_shift = {10, 19, 28, 37},
254  .pte_ppn_mask = {0x1ff, 0x1ff, 0x1ff, 0x1ffff},
255  .pa_ppn_shift = {12, 21, 30, 39},
256  .pa_ppn_mask = {0x1ff, 0x1ff, 0x1ff, 0x1ffff},
257 };
258 
259 static enum riscv_halt_reason riscv_halt_reason(struct target *target, int hartid);
260 static void riscv_info_init(struct target *target, struct riscv_info *r);
261 static void riscv_invalidate_register_cache(struct target *target);
262 static int riscv_step_rtos_hart(struct target *target);
263 
264 static void riscv_sample_buf_maybe_add_timestamp(struct target *target, bool before)
265 {
266  RISCV_INFO(r);
267  uint32_t now = timeval_ms() & 0xffffffff;
268  if (r->sample_buf.used + 5 < r->sample_buf.size) {
269  if (before)
270  r->sample_buf.buf[r->sample_buf.used++] = RISCV_SAMPLE_BUF_TIMESTAMP_BEFORE;
271  else
272  r->sample_buf.buf[r->sample_buf.used++] = RISCV_SAMPLE_BUF_TIMESTAMP_AFTER;
273  r->sample_buf.buf[r->sample_buf.used++] = now & 0xff;
274  r->sample_buf.buf[r->sample_buf.used++] = (now >> 8) & 0xff;
275  r->sample_buf.buf[r->sample_buf.used++] = (now >> 16) & 0xff;
276  r->sample_buf.buf[r->sample_buf.used++] = (now >> 24) & 0xff;
277  }
278 }
279 
280 static int riscv_resume_go_all_harts(struct target *target);
281 
283 {
288  else /* BSCAN_TUNNEL_NESTED_TAP */
291 }
292 
293 uint32_t dtmcontrol_scan_via_bscan(struct target *target, uint32_t out)
294 {
295  /* On BSCAN TAP: Select IR=USER4, issue tunneled IR scan via BSCAN TAP's DR */
296  uint8_t tunneled_ir_width[4] = {bscan_tunnel_ir_width};
297  uint8_t tunneled_dr_width[4] = {32};
298  uint8_t out_value[5] = {0};
299  uint8_t in_value[5] = {0};
300 
301  buf_set_u32(out_value, 0, 32, out);
302  struct scan_field tunneled_ir[4] = {};
303  struct scan_field tunneled_dr[4] = {};
304 
306  tunneled_ir[0].num_bits = 3;
307  tunneled_ir[0].out_value = bscan_zero;
308  tunneled_ir[0].in_value = NULL;
309  tunneled_ir[1].num_bits = bscan_tunnel_ir_width;
310  tunneled_ir[1].out_value = ir_dtmcontrol;
311  tunneled_ir[1].in_value = NULL;
312  tunneled_ir[2].num_bits = 7;
313  tunneled_ir[2].out_value = tunneled_ir_width;
314  tunneled_ir[2].in_value = NULL;
315  tunneled_ir[3].num_bits = 1;
316  tunneled_ir[3].out_value = bscan_zero;
317  tunneled_ir[3].in_value = NULL;
318 
319  tunneled_dr[0].num_bits = 3;
320  tunneled_dr[0].out_value = bscan_zero;
321  tunneled_dr[0].in_value = NULL;
322  tunneled_dr[1].num_bits = 32 + 1;
323  tunneled_dr[1].out_value = out_value;
324  tunneled_dr[1].in_value = in_value;
325  tunneled_dr[2].num_bits = 7;
326  tunneled_dr[2].out_value = tunneled_dr_width;
327  tunneled_dr[2].in_value = NULL;
328  tunneled_dr[3].num_bits = 1;
329  tunneled_dr[3].out_value = bscan_one;
330  tunneled_dr[3].in_value = NULL;
331  } else {
332  /* BSCAN_TUNNEL_NESTED_TAP */
333  tunneled_ir[3].num_bits = 3;
334  tunneled_ir[3].out_value = bscan_zero;
335  tunneled_ir[3].in_value = NULL;
336  tunneled_ir[2].num_bits = bscan_tunnel_ir_width;
337  tunneled_ir[2].out_value = ir_dtmcontrol;
338  tunneled_ir[1].in_value = NULL;
339  tunneled_ir[1].num_bits = 7;
340  tunneled_ir[1].out_value = tunneled_ir_width;
341  tunneled_ir[2].in_value = NULL;
342  tunneled_ir[0].num_bits = 1;
343  tunneled_ir[0].out_value = bscan_zero;
344  tunneled_ir[0].in_value = NULL;
345 
346  tunneled_dr[3].num_bits = 3;
347  tunneled_dr[3].out_value = bscan_zero;
348  tunneled_dr[3].in_value = NULL;
349  tunneled_dr[2].num_bits = 32 + 1;
350  tunneled_dr[2].out_value = out_value;
351  tunneled_dr[2].in_value = in_value;
352  tunneled_dr[1].num_bits = 7;
353  tunneled_dr[1].out_value = tunneled_dr_width;
354  tunneled_dr[1].in_value = NULL;
355  tunneled_dr[0].num_bits = 1;
356  tunneled_dr[0].out_value = bscan_one;
357  tunneled_dr[0].in_value = NULL;
358  }
360  jtag_add_dr_scan(target->tap, ARRAY_SIZE(tunneled_ir), tunneled_ir, TAP_IDLE);
361  jtag_add_dr_scan(target->tap, ARRAY_SIZE(tunneled_dr), tunneled_dr, TAP_IDLE);
363 
364  int retval = jtag_execute_queue();
365  if (retval != ERROR_OK) {
366  LOG_ERROR("failed jtag scan: %d", retval);
367  return retval;
368  }
369  /* Note the starting offset is bit 1, not bit 0. In BSCAN tunnel, there is a one-bit TCK skew between
370  output and input */
371  uint32_t in = buf_get_u32(in_value, 1, 32);
372  LOG_DEBUG("DTMCS: 0x%x -> 0x%x", out, in);
373 
374  return in;
375 }
376 
377 static uint32_t dtmcontrol_scan(struct target *target, uint32_t out)
378 {
379  struct scan_field field;
380  uint8_t in_value[4];
381  uint8_t out_value[4] = { 0 };
382 
383  if (bscan_tunnel_ir_width != 0)
384  return dtmcontrol_scan_via_bscan(target, out);
385 
386 
387  buf_set_u32(out_value, 0, 32, out);
388 
390 
391  field.num_bits = 32;
392  field.out_value = out_value;
393  field.in_value = in_value;
394  jtag_add_dr_scan(target->tap, 1, &field, TAP_IDLE);
395 
396  /* Always return to dbus. */
398 
399  int retval = jtag_execute_queue();
400  if (retval != ERROR_OK) {
401  LOG_ERROR("failed jtag scan: %d", retval);
402  return retval;
403  }
404 
405  uint32_t in = buf_get_u32(field.in_value, 0, 32);
406  LOG_DEBUG("DTMCONTROL: 0x%x -> 0x%x", out, in);
407 
408  return in;
409 }
410 
411 static struct target_type *get_target_type(struct target *target)
412 {
413  if (!target->arch_info) {
414  LOG_ERROR("Target has not been initialized");
415  return NULL;
416  }
417 
418  RISCV_INFO(info);
419  switch (info->dtm_version) {
420  case 0:
421  return &riscv011_target;
422  case 1:
423  return &riscv013_target;
424  default:
425  LOG_ERROR("Unsupported DTM version: %d", info->dtm_version);
426  return NULL;
427  }
428 }
429 
430 static int riscv_create_target(struct target *target, Jim_Interp *interp)
431 {
432  LOG_DEBUG("riscv_create_target()");
433  target->arch_info = calloc(1, sizeof(struct riscv_info));
434  if (!target->arch_info) {
435  LOG_ERROR("Failed to allocate RISC-V target structure.");
436  return ERROR_FAIL;
437  }
439  return ERROR_OK;
440 }
441 
442 static int riscv_init_target(struct command_context *cmd_ctx,
443  struct target *target)
444 {
445  LOG_DEBUG("riscv_init_target()");
446  RISCV_INFO(info);
447  info->cmd_ctx = cmd_ctx;
448 
452 
453  if (bscan_tunnel_ir_width != 0) {
454  assert(target->tap->ir_length >= 6);
455  uint32_t ir_user4_raw = 0x23 << (target->tap->ir_length - 6);
456  h_u32_to_le(ir_user4, ir_user4_raw);
461  else /* BSCAN_TUNNEL_NESTED_TAP */
463  }
464 
466 
468 
469  return ERROR_OK;
470 }
471 
472 static void riscv_free_registers(struct target *target)
473 {
474  /* Free the shared structure use for most registers. */
475  if (target->reg_cache) {
476  if (target->reg_cache->reg_list) {
477  free(target->reg_cache->reg_list[0].arch_info);
478  /* Free the ones we allocated separately. */
479  for (unsigned i = GDB_REGNO_COUNT; i < target->reg_cache->num_regs; i++)
480  free(target->reg_cache->reg_list[i].arch_info);
481  for (unsigned int i = 0; i < target->reg_cache->num_regs; i++)
482  free(target->reg_cache->reg_list[i].value);
483  free(target->reg_cache->reg_list);
484  }
485  free(target->reg_cache);
486  }
487 }
488 
489 static void riscv_deinit_target(struct target *target)
490 {
491  LOG_DEBUG("riscv_deinit_target()");
492 
493  struct riscv_info *info = target->arch_info;
494  struct target_type *tt = get_target_type(target);
495 
496  if (tt && info && info->version_specific)
497  tt->deinit_target(target);
498 
500 
501  if (!info)
502  return;
503 
504  range_list_t *entry, *tmp;
505  list_for_each_entry_safe(entry, tmp, &info->expose_csr, list) {
506  free(entry->name);
507  free(entry);
508  }
509 
510  list_for_each_entry_safe(entry, tmp, &info->expose_custom, list) {
511  free(entry->name);
512  free(entry);
513  }
514 
515  free(info->reg_names);
516  free(target->arch_info);
517 
518  target->arch_info = NULL;
519 }
520 
522  const struct breakpoint *breakpoint)
523 {
526  trigger->mask = ~0LL;
527  trigger->read = false;
528  trigger->write = false;
529  trigger->execute = true;
530  /* unique_id is unique across both breakpoints and watchpoints. */
532 }
533 
534 static int maybe_add_trigger_t1(struct target *target,
535  struct trigger *trigger, uint64_t tdata1)
536 {
537  RISCV_INFO(r);
538 
539  const uint32_t bpcontrol_x = 1<<0;
540  const uint32_t bpcontrol_w = 1<<1;
541  const uint32_t bpcontrol_r = 1<<2;
542  const uint32_t bpcontrol_u = 1<<3;
543  const uint32_t bpcontrol_s = 1<<4;
544  const uint32_t bpcontrol_h = 1<<5;
545  const uint32_t bpcontrol_m = 1<<6;
546  const uint32_t bpcontrol_bpmatch = 0xf << 7;
547  const uint32_t bpcontrol_bpaction = 0xff << 11;
548 
549  if (tdata1 & (bpcontrol_r | bpcontrol_w | bpcontrol_x)) {
550  /* Trigger is already in use, presumably by user code. */
552  }
553 
554  tdata1 = set_field(tdata1, bpcontrol_r, trigger->read);
555  tdata1 = set_field(tdata1, bpcontrol_w, trigger->write);
556  tdata1 = set_field(tdata1, bpcontrol_x, trigger->execute);
557  tdata1 = set_field(tdata1, bpcontrol_u,
558  !!(r->misa & BIT('U' - 'A')));
559  tdata1 = set_field(tdata1, bpcontrol_s,
560  !!(r->misa & BIT('S' - 'A')));
561  tdata1 = set_field(tdata1, bpcontrol_h,
562  !!(r->misa & BIT('H' - 'A')));
563  tdata1 |= bpcontrol_m;
564  tdata1 = set_field(tdata1, bpcontrol_bpmatch, 0); /* exact match */
565  tdata1 = set_field(tdata1, bpcontrol_bpaction, 0); /* cause bp exception */
566 
568 
569  riscv_reg_t tdata1_rb;
570  if (riscv_get_register(target, &tdata1_rb, GDB_REGNO_TDATA1) != ERROR_OK)
571  return ERROR_FAIL;
572  LOG_DEBUG("tdata1=0x%" PRIx64, tdata1_rb);
573 
574  if (tdata1 != tdata1_rb) {
575  LOG_DEBUG("Trigger doesn't support what we need; After writing 0x%"
576  PRIx64 " to tdata1 it contains 0x%" PRIx64,
577  tdata1, tdata1_rb);
580  }
581 
583 
584  return ERROR_OK;
585 }
586 
587 static int maybe_add_trigger_t2(struct target *target,
588  struct trigger *trigger, uint64_t tdata1)
589 {
590  RISCV_INFO(r);
591 
592  /* tselect is already set */
593  if (tdata1 & (MCONTROL_EXECUTE | MCONTROL_STORE | MCONTROL_LOAD)) {
594  /* Trigger is already in use, presumably by user code. */
596  }
597 
598  /* address/data match trigger */
599  tdata1 |= MCONTROL_DMODE(riscv_xlen(target));
600  tdata1 = set_field(tdata1, MCONTROL_ACTION,
602  tdata1 = set_field(tdata1, MCONTROL_MATCH, MCONTROL_MATCH_EQUAL);
603  tdata1 |= MCONTROL_M;
604  if (r->misa & (1 << ('S' - 'A')))
605  tdata1 |= MCONTROL_S;
606  if (r->misa & (1 << ('U' - 'A')))
607  tdata1 |= MCONTROL_U;
608 
609  if (trigger->execute)
610  tdata1 |= MCONTROL_EXECUTE;
611  if (trigger->read)
612  tdata1 |= MCONTROL_LOAD;
613  if (trigger->write)
614  tdata1 |= MCONTROL_STORE;
615 
617 
618  uint64_t tdata1_rb;
619  int result = riscv_get_register(target, &tdata1_rb, GDB_REGNO_TDATA1);
620  if (result != ERROR_OK)
621  return result;
622  LOG_DEBUG("tdata1=0x%" PRIx64, tdata1_rb);
623 
624  if (tdata1 != tdata1_rb) {
625  LOG_DEBUG("Trigger doesn't support what we need; After writing 0x%"
626  PRIx64 " to tdata1 it contains 0x%" PRIx64,
627  tdata1, tdata1_rb);
630  }
631 
633 
634  return ERROR_OK;
635 }
636 
637 static int maybe_add_trigger_t6(struct target *target,
638  struct trigger *trigger, uint64_t tdata1)
639 {
640  RISCV_INFO(r);
641 
642  /* tselect is already set */
644  /* Trigger is already in use, presumably by user code. */
646  }
647 
648  /* address/data match trigger */
649  tdata1 |= MCONTROL_DMODE(riscv_xlen(target));
650  tdata1 = set_field(tdata1, CSR_MCONTROL6_ACTION,
653  tdata1 |= CSR_MCONTROL6_M;
654  if (r->misa & (1 << ('H' - 'A')))
656  if (r->misa & (1 << ('S' - 'A')))
657  tdata1 |= CSR_MCONTROL6_S;
658  if (r->misa & (1 << ('U' - 'A')))
659  tdata1 |= CSR_MCONTROL6_U;
660 
661  if (trigger->execute)
662  tdata1 |= CSR_MCONTROL6_EXECUTE;
663  if (trigger->read)
664  tdata1 |= CSR_MCONTROL6_LOAD;
665  if (trigger->write)
666  tdata1 |= CSR_MCONTROL6_STORE;
667 
669 
670  uint64_t tdata1_rb;
671  int result = riscv_get_register(target, &tdata1_rb, GDB_REGNO_TDATA1);
672  if (result != ERROR_OK)
673  return result;
674  LOG_DEBUG("tdata1=0x%" PRIx64, tdata1_rb);
675 
676  if (tdata1 != tdata1_rb) {
677  LOG_DEBUG("Trigger doesn't support what we need; After writing 0x%"
678  PRIx64 " to tdata1 it contains 0x%" PRIx64,
679  tdata1, tdata1_rb);
682  }
683 
685 
686  return ERROR_OK;
687 }
688 
689 static int add_trigger(struct target *target, struct trigger *trigger)
690 {
691  RISCV_INFO(r);
692 
694  return ERROR_FAIL;
695 
696  riscv_reg_t tselect;
698  return ERROR_FAIL;
699 
700  unsigned int i;
701  for (i = 0; i < r->trigger_count; i++) {
702  if (r->trigger_unique_id[i] != -1)
703  continue;
704 
706 
707  uint64_t tdata1;
708  int result = riscv_get_register(target, &tdata1, GDB_REGNO_TDATA1);
709  if (result != ERROR_OK)
710  return result;
711  int type = get_field(tdata1, MCONTROL_TYPE(riscv_xlen(target)));
712 
713  switch (type) {
714  case 1:
715  result = maybe_add_trigger_t1(target, trigger, tdata1);
716  break;
717  case 2:
718  result = maybe_add_trigger_t2(target, trigger, tdata1);
719  break;
720  case 6:
721  result = maybe_add_trigger_t6(target, trigger, tdata1);
722  break;
723  default:
724  LOG_DEBUG("trigger %d has unknown type %d", i, type);
725  continue;
726  }
727 
728  if (result != ERROR_OK)
729  continue;
730 
731  LOG_DEBUG("[%d] Using trigger %d (type %d) for bp %d", target->coreid,
732  i, type, trigger->unique_id);
733  r->trigger_unique_id[i] = trigger->unique_id;
734  break;
735  }
736 
738 
739  if (i >= r->trigger_count) {
740  LOG_ERROR("Couldn't find an available hardware trigger.");
742  }
743 
744  return ERROR_OK;
745 }
746 
751 static int write_by_given_size(struct target *target, target_addr_t address,
752  uint32_t size, uint8_t *buffer, uint32_t access_size)
753 {
754  assert(size == 1 || size == 2 || size == 4 || size == 8);
755  assert(access_size == 1 || access_size == 2 || access_size == 4 || access_size == 8);
756 
757  if (access_size <= size && address % access_size == 0)
758  /* Can do the memory access directly without a helper buffer. */
759  return target_write_memory(target, address, access_size, size / access_size, buffer);
760 
761  unsigned int offset_head = address % access_size;
762  unsigned int n_blocks = ((size + offset_head) <= access_size) ? 1 : 2;
763  uint8_t helper_buf[n_blocks * access_size];
764 
765  /* Read from memory */
766  if (target_read_memory(target, address - offset_head, access_size, n_blocks, helper_buf) != ERROR_OK)
767  return ERROR_FAIL;
768 
769  /* Modify and write back */
770  memcpy(helper_buf + offset_head, buffer, size);
771  return target_write_memory(target, address - offset_head, access_size, n_blocks, helper_buf);
772 }
773 
778 static int read_by_given_size(struct target *target, target_addr_t address,
779  uint32_t size, uint8_t *buffer, uint32_t access_size)
780 {
781  assert(size == 1 || size == 2 || size == 4 || size == 8);
782  assert(access_size == 1 || access_size == 2 || access_size == 4 || access_size == 8);
783 
784  if (access_size <= size && address % access_size == 0)
785  /* Can do the memory access directly without a helper buffer. */
786  return target_read_memory(target, address, access_size, size / access_size, buffer);
787 
788  unsigned int offset_head = address % access_size;
789  unsigned int n_blocks = ((size + offset_head) <= access_size) ? 1 : 2;
790  uint8_t helper_buf[n_blocks * access_size];
791 
792  /* Read from memory */
793  if (target_read_memory(target, address - offset_head, access_size, n_blocks, helper_buf) != ERROR_OK)
794  return ERROR_FAIL;
795 
796  /* Pick the requested portion from the buffer */
797  memcpy(buffer, helper_buf + offset_head, size);
798  return ERROR_OK;
799 }
800 
805 int riscv_write_by_any_size(struct target *target, target_addr_t address, uint32_t size, uint8_t *buffer)
806 {
807  assert(size == 1 || size == 2 || size == 4 || size == 8);
808 
809  /* Find access size that correspond to data size and the alignment. */
810  unsigned int preferred_size = size;
811  while (address % preferred_size != 0)
812  preferred_size /= 2;
813 
814  /* First try the preferred (most natural) access size. */
815  if (write_by_given_size(target, address, size, buffer, preferred_size) == ERROR_OK)
816  return ERROR_OK;
817 
818  /* On failure, try other access sizes.
819  Minimize the number of accesses by trying first the largest size. */
820  for (unsigned int access_size = 8; access_size > 0; access_size /= 2) {
821  if (access_size == preferred_size)
822  /* Already tried this size. */
823  continue;
824 
825  if (write_by_given_size(target, address, size, buffer, access_size) == ERROR_OK)
826  return ERROR_OK;
827  }
828 
829  /* No access attempt succeeded. */
830  return ERROR_FAIL;
831 }
832 
837 int riscv_read_by_any_size(struct target *target, target_addr_t address, uint32_t size, uint8_t *buffer)
838 {
839  assert(size == 1 || size == 2 || size == 4 || size == 8);
840 
841  /* Find access size that correspond to data size and the alignment. */
842  unsigned int preferred_size = size;
843  while (address % preferred_size != 0)
844  preferred_size /= 2;
845 
846  /* First try the preferred (most natural) access size. */
847  if (read_by_given_size(target, address, size, buffer, preferred_size) == ERROR_OK)
848  return ERROR_OK;
849 
850  /* On failure, try other access sizes.
851  Minimize the number of accesses by trying first the largest size. */
852  for (unsigned int access_size = 8; access_size > 0; access_size /= 2) {
853  if (access_size == preferred_size)
854  /* Already tried this size. */
855  continue;
856 
857  if (read_by_given_size(target, address, size, buffer, access_size) == ERROR_OK)
858  return ERROR_OK;
859  }
860 
861  /* No access attempt succeeded. */
862  return ERROR_FAIL;
863 }
864 
866 {
868  assert(breakpoint);
869  if (breakpoint->type == BKPT_SOFT) {
871  if (!(breakpoint->length == 4 || breakpoint->length == 2)) {
872  LOG_ERROR("Invalid breakpoint length %d", breakpoint->length);
873  return ERROR_FAIL;
874  }
875 
876  if (0 != (breakpoint->address % 2)) {
877  LOG_ERROR("Invalid breakpoint alignment for address 0x%" TARGET_PRIxADDR, breakpoint->address);
878  return ERROR_FAIL;
879  }
880 
881  /* Read the original instruction. */
884  LOG_ERROR("Failed to read original instruction at 0x%" TARGET_PRIxADDR,
886  return ERROR_FAIL;
887  }
888 
889  uint8_t buff[4] = { 0 };
890  buf_set_u32(buff, 0, breakpoint->length * CHAR_BIT, breakpoint->length == 4 ? ebreak() : ebreak_c());
891  /* Write the ebreak instruction. */
893  LOG_ERROR("Failed to write %d-byte breakpoint instruction at 0x%"
895  return ERROR_FAIL;
896  }
897 
898  } else if (breakpoint->type == BKPT_HARD) {
899  struct trigger trigger;
901  int const result = add_trigger(target, &trigger);
902  if (result != ERROR_OK)
903  return result;
904  } else {
905  LOG_INFO("OpenOCD only supports hardware and software breakpoints.");
907  }
908 
909  breakpoint->is_set = true;
910  return ERROR_OK;
911 }
912 
913 static int remove_trigger(struct target *target, struct trigger *trigger)
914 {
915  RISCV_INFO(r);
916 
918  return ERROR_FAIL;
919 
920  unsigned int i;
921  for (i = 0; i < r->trigger_count; i++) {
922  if (r->trigger_unique_id[i] == trigger->unique_id)
923  break;
924  }
925  if (i >= r->trigger_count) {
926  LOG_ERROR("Couldn't find the hardware resources used by hardware "
927  "trigger.");
928  return ERROR_FAIL;
929  }
930  LOG_DEBUG("[%d] Stop using resource %d for bp %d", target->coreid, i,
931  trigger->unique_id);
932 
933  riscv_reg_t tselect;
934  int result = riscv_get_register(target, &tselect, GDB_REGNO_TSELECT);
935  if (result != ERROR_OK)
936  return result;
940  r->trigger_unique_id[i] = -1;
941 
942  return ERROR_OK;
943 }
944 
946  struct breakpoint *breakpoint)
947 {
948  if (breakpoint->type == BKPT_SOFT) {
949  /* Write the original instruction. */
952  LOG_ERROR("Failed to restore instruction for %d-byte breakpoint at "
954  return ERROR_FAIL;
955  }
956 
957  } else if (breakpoint->type == BKPT_HARD) {
958  struct trigger trigger;
960  int result = remove_trigger(target, &trigger);
961  if (result != ERROR_OK)
962  return result;
963 
964  } else {
965  LOG_INFO("OpenOCD only supports hardware and software breakpoints.");
967  }
968 
969  breakpoint->is_set = false;
970 
971  return ERROR_OK;
972 }
973 
975  const struct watchpoint *watchpoint)
976 {
983  trigger->execute = false;
984  /* unique_id is unique across both breakpoints and watchpoints. */
986 }
987 
989 {
990  struct trigger trigger;
992 
993  int result = add_trigger(target, &trigger);
994  if (result != ERROR_OK)
995  return result;
996  watchpoint->is_set = true;
997 
998  return ERROR_OK;
999 }
1000 
1002  struct watchpoint *watchpoint)
1003 {
1005 
1006  struct trigger trigger;
1008 
1009  int result = remove_trigger(target, &trigger);
1010  if (result != ERROR_OK)
1011  return result;
1012  watchpoint->is_set = false;
1013 
1014  return ERROR_OK;
1015 }
1016 
1017 /* Sets *hit_watchpoint to the first watchpoint identified as causing the
1018  * current halt.
1019  *
1020  * The GDB server uses this information to tell GDB what data address has
1021  * been hit, which enables GDB to print the hit variable along with its old
1022  * and new value. */
1023 static int riscv_hit_watchpoint(struct target *target, struct watchpoint **hit_watchpoint)
1024 {
1025  struct watchpoint *wp = target->watchpoints;
1026 
1027  LOG_DEBUG("Current hartid = %d", riscv_current_hartid(target));
1028 
1029  /*TODO instead of disassembling the instruction that we think caused the
1030  * trigger, check the hit bit of each watchpoint first. The hit bit is
1031  * simpler and more reliable to check but as it is optional and relatively
1032  * new, not all hardware will implement it */
1033  riscv_reg_t dpc;
1035  const uint8_t length = 4;
1036  LOG_DEBUG("dpc is 0x%" PRIx64, dpc);
1037 
1038  /* fetch the instruction at dpc */
1039  uint8_t buffer[length];
1040  if (target_read_buffer(target, dpc, length, buffer) != ERROR_OK) {
1041  LOG_ERROR("Failed to read instruction at dpc 0x%" PRIx64, dpc);
1042  return ERROR_FAIL;
1043  }
1044 
1045  uint32_t instruction = 0;
1046 
1047  for (int i = 0; i < length; i++) {
1048  LOG_DEBUG("Next byte is %x", buffer[i]);
1049  instruction += (buffer[i] << 8 * i);
1050  }
1051  LOG_DEBUG("Full instruction is %x", instruction);
1052 
1053  /* find out which memory address is accessed by the instruction at dpc */
1054  /* opcode is first 7 bits of the instruction */
1055  uint8_t opcode = instruction & 0x7F;
1056  uint32_t rs1;
1057  int16_t imm;
1058  riscv_reg_t mem_addr;
1059 
1060  if (opcode == MATCH_LB || opcode == MATCH_SB) {
1061  rs1 = (instruction & 0xf8000) >> 15;
1062  riscv_get_register(target, &mem_addr, rs1);
1063 
1064  if (opcode == MATCH_SB) {
1065  LOG_DEBUG("%x is store instruction", instruction);
1066  imm = ((instruction & 0xf80) >> 7) | ((instruction & 0xfe000000) >> 20);
1067  } else {
1068  LOG_DEBUG("%x is load instruction", instruction);
1069  imm = (instruction & 0xfff00000) >> 20;
1070  }
1071  /* sign extend 12-bit imm to 16-bits */
1072  if (imm & (1 << 11))
1073  imm |= 0xf000;
1074  mem_addr += imm;
1075  LOG_DEBUG("memory address=0x%" PRIx64, mem_addr);
1076  } else {
1077  LOG_DEBUG("%x is not a RV32I load or store", instruction);
1078  return ERROR_FAIL;
1079  }
1080 
1081  while (wp) {
1082  /*TODO support length/mask */
1083  if (wp->address == mem_addr) {
1084  *hit_watchpoint = wp;
1085  LOG_DEBUG("Hit address=%" TARGET_PRIxADDR, wp->address);
1086  return ERROR_OK;
1087  }
1088  wp = wp->next;
1089  }
1090 
1091  /* No match found - either we hit a watchpoint caused by an instruction that
1092  * this function does not yet disassemble, or we hit a breakpoint.
1093  *
1094  * OpenOCD will behave as if this function had never been implemented i.e.
1095  * report the halt to GDB with no address information. */
1096  return ERROR_FAIL;
1097 }
1098 
1099 
1100 static int oldriscv_step(struct target *target, int current, uint32_t address,
1101  int handle_breakpoints)
1102 {
1103  struct target_type *tt = get_target_type(target);
1104  return tt->step(target, current, address, handle_breakpoints);
1105 }
1106 
1107 static int old_or_new_riscv_step(struct target *target, int current,
1108  target_addr_t address, int handle_breakpoints)
1109 {
1110  RISCV_INFO(r);
1111  LOG_DEBUG("handle_breakpoints=%d", handle_breakpoints);
1112  if (!r->is_halted)
1113  return oldriscv_step(target, current, address, handle_breakpoints);
1114  else
1115  return riscv_openocd_step(target, current, address, handle_breakpoints);
1116 }
1117 
1118 
1119 static int riscv_examine(struct target *target)
1120 {
1121  LOG_DEBUG("riscv_examine()");
1122  if (target_was_examined(target)) {
1123  LOG_DEBUG("Target was already examined.");
1124  return ERROR_OK;
1125  }
1126 
1127  /* Don't need to select dbus, since the first thing we do is read dtmcontrol. */
1128 
1129  RISCV_INFO(info);
1130  uint32_t dtmcontrol = dtmcontrol_scan(target, 0);
1131  LOG_DEBUG("dtmcontrol=0x%x", dtmcontrol);
1132  info->dtm_version = get_field(dtmcontrol, DTMCONTROL_VERSION);
1133  LOG_DEBUG(" version=0x%x", info->dtm_version);
1134 
1135  struct target_type *tt = get_target_type(target);
1136  if (!tt)
1137  return ERROR_FAIL;
1138 
1139  int result = tt->init_target(info->cmd_ctx, target);
1140  if (result != ERROR_OK)
1141  return result;
1142 
1143  return tt->examine(target);
1144 }
1145 
1146 static int oldriscv_poll(struct target *target)
1147 {
1148  struct target_type *tt = get_target_type(target);
1149  return tt->poll(target);
1150 }
1151 
1153 {
1154  RISCV_INFO(r);
1155  if (!r->is_halted)
1156  return oldriscv_poll(target);
1157  else
1158  return riscv_openocd_poll(target);
1159 }
1160 
1162 {
1164 }
1165 
1166 static int halt_prep(struct target *target)
1167 {
1168  RISCV_INFO(r);
1169 
1170  LOG_DEBUG("[%s] prep hart, debug_reason=%d", target_name(target),
1171  target->debug_reason);
1173  return ERROR_FAIL;
1174  if (riscv_is_halted(target)) {
1175  LOG_DEBUG("[%s] Hart is already halted (reason=%d).",
1177  } else {
1178  if (r->halt_prep(target) != ERROR_OK)
1179  return ERROR_FAIL;
1180  r->prepped = true;
1181  }
1182 
1183  return ERROR_OK;
1184 }
1185 
1187 {
1188  RISCV_INFO(r);
1189 
1191  return ERROR_FAIL;
1192  if (riscv_is_halted(target)) {
1193  LOG_DEBUG("[%s] Hart is already halted.", target_name(target));
1194  } else {
1195  if (r->halt_go(target) != ERROR_OK)
1196  return ERROR_FAIL;
1197  }
1198 
1200 
1201  return ERROR_OK;
1202 }
1203 
1204 static int halt_go(struct target *target)
1205 {
1206  RISCV_INFO(r);
1207  int result;
1208  if (!r->is_halted) {
1209  struct target_type *tt = get_target_type(target);
1210  result = tt->halt(target);
1211  } else {
1212  result = riscv_halt_go_all_harts(target);
1213  }
1217 
1218  return result;
1219 }
1220 
1221 static int halt_finish(struct target *target)
1222 {
1224 }
1225 
1227 {
1228  RISCV_INFO(r);
1229 
1230  if (!r->is_halted) {
1231  struct target_type *tt = get_target_type(target);
1232  return tt->halt(target);
1233  }
1234 
1235  LOG_DEBUG("[%d] halting all harts", target->coreid);
1236 
1237  int result = ERROR_OK;
1238  if (target->smp) {
1239  struct target_list *tlist;
1241  struct target *t = tlist->target;
1242  if (halt_prep(t) != ERROR_OK)
1243  result = ERROR_FAIL;
1244  }
1245 
1247  struct target *t = tlist->target;
1248  struct riscv_info *i = riscv_info(t);
1249  if (i->prepped) {
1250  if (halt_go(t) != ERROR_OK)
1251  result = ERROR_FAIL;
1252  }
1253  }
1254 
1256  struct target *t = tlist->target;
1257  if (halt_finish(t) != ERROR_OK)
1258  return ERROR_FAIL;
1259  }
1260 
1261  } else {
1262  if (halt_prep(target) != ERROR_OK)
1263  result = ERROR_FAIL;
1264  if (halt_go(target) != ERROR_OK)
1265  result = ERROR_FAIL;
1266  if (halt_finish(target) != ERROR_OK)
1267  return ERROR_FAIL;
1268  }
1269 
1270  return result;
1271 }
1272 
1273 static int riscv_assert_reset(struct target *target)
1274 {
1275  LOG_DEBUG("[%d]", target->coreid);
1276  struct target_type *tt = get_target_type(target);
1278  return tt->assert_reset(target);
1279 }
1280 
1282 {
1283  LOG_DEBUG("[%d]", target->coreid);
1284  struct target_type *tt = get_target_type(target);
1285  return tt->deassert_reset(target);
1286 }
1287 
1289 {
1290  RISCV_INFO(r);
1291 
1292  LOG_DEBUG("[%s] prep hart", target_name(target));
1294  return ERROR_FAIL;
1295  if (riscv_is_halted(target)) {
1296  if (r->resume_prep(target) != ERROR_OK)
1297  return ERROR_FAIL;
1298  } else {
1299  LOG_DEBUG("[%s] hart requested resume, but was already resumed",
1300  target_name(target));
1301  }
1302 
1303  LOG_DEBUG("[%s] mark as prepped", target_name(target));
1304  r->prepped = true;
1305 
1306  return ERROR_OK;
1307 }
1308 
1309 /* state must be riscv_reg_t state[RISCV_MAX_HWBPS] = {0}; */
1311 {
1312  RISCV_INFO(r);
1313 
1314  LOG_DEBUG("deal with triggers");
1315 
1317  return ERROR_FAIL;
1318 
1319  if (r->manual_hwbp_set) {
1320  /* Look at every trigger that may have been set. */
1321  riscv_reg_t tselect;
1323  return ERROR_FAIL;
1324  for (unsigned int t = 0; t < r->trigger_count; t++) {
1326  return ERROR_FAIL;
1327  riscv_reg_t tdata1;
1329  return ERROR_FAIL;
1330  if (tdata1 & MCONTROL_DMODE(riscv_xlen(target))) {
1331  state[t] = tdata1;
1333  return ERROR_FAIL;
1334  }
1335  }
1337  return ERROR_FAIL;
1338 
1339  } else {
1340  /* Just go through the triggers we manage. */
1342  int i = 0;
1343  while (watchpoint) {
1344  LOG_DEBUG("watchpoint %d: set=%d", i, watchpoint->is_set);
1345  state[i] = watchpoint->is_set;
1346  if (watchpoint->is_set) {
1348  return ERROR_FAIL;
1349  }
1351  i++;
1352  }
1353  }
1354 
1355  return ERROR_OK;
1356 }
1357 
1359 {
1360  RISCV_INFO(r);
1361 
1362  if (r->manual_hwbp_set) {
1363  /* Look at every trigger that may have been set. */
1364  riscv_reg_t tselect;
1366  return ERROR_FAIL;
1367  for (unsigned int t = 0; t < r->trigger_count; t++) {
1368  if (state[t] != 0) {
1370  return ERROR_FAIL;
1372  return ERROR_FAIL;
1373  }
1374  }
1376  return ERROR_FAIL;
1377 
1378  } else {
1380  int i = 0;
1381  while (watchpoint) {
1382  LOG_DEBUG("watchpoint %d: cleared=%" PRId64, i, state[i]);
1383  if (state[i]) {
1385  return ERROR_FAIL;
1386  }
1388  i++;
1389  }
1390  }
1391 
1392  return ERROR_OK;
1393 }
1394 
1398 static int resume_prep(struct target *target, int current,
1399  target_addr_t address, int handle_breakpoints, int debug_execution)
1400 {
1401  RISCV_INFO(r);
1402  LOG_DEBUG("[%d]", target->coreid);
1403 
1404  if (!current)
1406 
1408  /* To be able to run off a trigger, disable all the triggers, step, and
1409  * then resume as usual. */
1410  riscv_reg_t trigger_state[RISCV_MAX_HWBPS] = {0};
1411 
1412  if (disable_triggers(target, trigger_state) != ERROR_OK)
1413  return ERROR_FAIL;
1414 
1415  if (old_or_new_riscv_step(target, true, 0, false) != ERROR_OK)
1416  return ERROR_FAIL;
1417 
1418  if (enable_triggers(target, trigger_state) != ERROR_OK)
1419  return ERROR_FAIL;
1420  }
1421 
1422  if (r->is_halted) {
1424  return ERROR_FAIL;
1425  }
1426 
1427  LOG_DEBUG("[%d] mark as prepped", target->coreid);
1428  r->prepped = true;
1429 
1430  return ERROR_OK;
1431 }
1432 
1437 static int resume_go(struct target *target, int current,
1438  target_addr_t address, int handle_breakpoints, int debug_execution)
1439 {
1440  RISCV_INFO(r);
1441  int result;
1442  if (!r->is_halted) {
1443  struct target_type *tt = get_target_type(target);
1444  result = tt->resume(target, current, address, handle_breakpoints,
1445  debug_execution);
1446  } else {
1448  }
1449 
1450  return result;
1451 }
1452 
1453 static int resume_finish(struct target *target)
1454 {
1456 
1460 }
1461 
1466 static int riscv_resume(
1467  struct target *target,
1468  int current,
1469  target_addr_t address,
1470  int handle_breakpoints,
1471  int debug_execution,
1472  bool single_hart)
1473 {
1474  LOG_DEBUG("handle_breakpoints=%d", handle_breakpoints);
1475  int result = ERROR_OK;
1476  if (target->smp && !single_hart) {
1477  struct target_list *tlist;
1479  tlist, target->smp_targets) {
1480  struct target *t = tlist->target;
1481  if (resume_prep(t, current, address, handle_breakpoints,
1482  debug_execution) != ERROR_OK)
1483  result = ERROR_FAIL;
1484  }
1485 
1487  tlist, target->smp_targets) {
1488  struct target *t = tlist->target;
1489  struct riscv_info *i = riscv_info(t);
1490  if (i->prepped) {
1491  if (resume_go(t, current, address, handle_breakpoints,
1492  debug_execution) != ERROR_OK)
1493  result = ERROR_FAIL;
1494  }
1495  }
1496 
1498  tlist, target->smp_targets) {
1499  struct target *t = tlist->target;
1500  if (resume_finish(t) != ERROR_OK)
1501  return ERROR_FAIL;
1502  }
1503 
1504  } else {
1505  if (resume_prep(target, current, address, handle_breakpoints,
1506  debug_execution) != ERROR_OK)
1507  result = ERROR_FAIL;
1508  if (resume_go(target, current, address, handle_breakpoints,
1509  debug_execution) != ERROR_OK)
1510  result = ERROR_FAIL;
1511  if (resume_finish(target) != ERROR_OK)
1512  return ERROR_FAIL;
1513  }
1514 
1515  return result;
1516 }
1517 
1518 static int riscv_target_resume(struct target *target, int current, target_addr_t address,
1519  int handle_breakpoints, int debug_execution)
1520 {
1521  return riscv_resume(target, current, address, handle_breakpoints,
1522  debug_execution, false);
1523 }
1524 
1525 static int riscv_mmu(struct target *target, int *enabled)
1526 {
1527  if (!riscv_enable_virt2phys) {
1528  *enabled = 0;
1529  return ERROR_OK;
1530  }
1531 
1532  /* Don't use MMU in explicit or effective M (machine) mode */
1533  riscv_reg_t priv;
1535  LOG_ERROR("Failed to read priv register.");
1536  return ERROR_FAIL;
1537  }
1538 
1539  riscv_reg_t mstatus;
1540  if (riscv_get_register(target, &mstatus, GDB_REGNO_MSTATUS) != ERROR_OK) {
1541  LOG_ERROR("Failed to read mstatus register.");
1542  return ERROR_FAIL;
1543  }
1544 
1545  if ((get_field(mstatus, MSTATUS_MPRV) ? get_field(mstatus, MSTATUS_MPP) : priv) == PRV_M) {
1546  LOG_DEBUG("SATP/MMU ignored in Machine mode (mstatus=0x%" PRIx64 ").", mstatus);
1547  *enabled = 0;
1548  return ERROR_OK;
1549  }
1550 
1551  riscv_reg_t satp;
1553  LOG_DEBUG("Couldn't read SATP.");
1554  /* If we can't read SATP, then there must not be an MMU. */
1555  *enabled = 0;
1556  return ERROR_OK;
1557  }
1558 
1560  LOG_DEBUG("MMU is disabled.");
1561  *enabled = 0;
1562  } else {
1563  LOG_DEBUG("MMU is enabled.");
1564  *enabled = 1;
1565  }
1566 
1567  return ERROR_OK;
1568 }
1569 
1571  target_addr_t virtual, target_addr_t *physical)
1572 {
1573  RISCV_INFO(r);
1574  riscv_reg_t satp_value;
1575  int mode;
1576  uint64_t ppn_value;
1577  target_addr_t table_address;
1578  const virt2phys_info_t *info;
1579  uint64_t pte = 0;
1580  int i;
1581 
1582  int result = riscv_get_register(target, &satp_value, GDB_REGNO_SATP);
1583  if (result != ERROR_OK)
1584  return result;
1585 
1586  unsigned xlen = riscv_xlen(target);
1587  mode = get_field(satp_value, RISCV_SATP_MODE(xlen));
1588  switch (mode) {
1589  case SATP_MODE_SV32:
1590  info = &sv32;
1591  break;
1592  case SATP_MODE_SV39:
1593  info = &sv39;
1594  break;
1595  case SATP_MODE_SV48:
1596  info = &sv48;
1597  break;
1598  case SATP_MODE_OFF:
1599  LOG_ERROR("No translation or protection." \
1600  " (satp: 0x%" PRIx64 ")", satp_value);
1601  return ERROR_FAIL;
1602  default:
1603  LOG_ERROR("The translation mode is not supported." \
1604  " (satp: 0x%" PRIx64 ")", satp_value);
1605  return ERROR_FAIL;
1606  }
1607  LOG_DEBUG("virtual=0x%" TARGET_PRIxADDR "; mode=%s", virtual, info->name);
1608 
1609  /* verify bits xlen-1:va_bits-1 are all equal */
1610  assert(xlen >= info->va_bits);
1611  target_addr_t mask = ((target_addr_t)1 << (xlen - (info->va_bits - 1))) - 1;
1612  target_addr_t masked_msbs = (virtual >> (info->va_bits - 1)) & mask;
1613  if (masked_msbs != 0 && masked_msbs != mask) {
1614  LOG_ERROR("Virtual address 0x%" TARGET_PRIxADDR " is not sign-extended "
1615  "for %s mode.", virtual, info->name);
1616  return ERROR_FAIL;
1617  }
1618 
1619  ppn_value = get_field(satp_value, RISCV_SATP_PPN(xlen));
1620  table_address = ppn_value << RISCV_PGSHIFT;
1621  i = info->level - 1;
1622  while (i >= 0) {
1623  uint64_t vpn = virtual >> info->vpn_shift[i];
1624  vpn &= info->vpn_mask[i];
1625  target_addr_t pte_address = table_address +
1626  (vpn << info->pte_shift);
1627  uint8_t buffer[8];
1628  assert(info->pte_shift <= 3);
1629  int retval = r->read_memory(target, pte_address,
1630  4, (1 << info->pte_shift) / 4, buffer, 4);
1631  if (retval != ERROR_OK)
1632  return ERROR_FAIL;
1633 
1634  if (info->pte_shift == 2)
1635  pte = buf_get_u32(buffer, 0, 32);
1636  else
1637  pte = buf_get_u64(buffer, 0, 64);
1638 
1639  LOG_DEBUG("i=%d; PTE @0x%" TARGET_PRIxADDR " = 0x%" PRIx64, i,
1640  pte_address, pte);
1641 
1642  if (!(pte & PTE_V) || (!(pte & PTE_R) && (pte & PTE_W)))
1643  return ERROR_FAIL;
1644 
1645  if ((pte & PTE_R) || (pte & PTE_X)) /* Found leaf PTE. */
1646  break;
1647 
1648  i--;
1649  if (i < 0)
1650  break;
1651  ppn_value = pte >> PTE_PPN_SHIFT;
1652  table_address = ppn_value << RISCV_PGSHIFT;
1653  }
1654 
1655  if (i < 0) {
1656  LOG_ERROR("Couldn't find the PTE.");
1657  return ERROR_FAIL;
1658  }
1659 
1660  /* Make sure to clear out the high bits that may be set. */
1661  *physical = virtual & (((target_addr_t)1 << info->va_bits) - 1);
1662 
1663  while (i < info->level) {
1664  ppn_value = pte >> info->pte_ppn_shift[i];
1665  ppn_value &= info->pte_ppn_mask[i];
1666  *physical &= ~(((target_addr_t)info->pa_ppn_mask[i]) <<
1667  info->pa_ppn_shift[i]);
1668  *physical |= (ppn_value << info->pa_ppn_shift[i]);
1669  i++;
1670  }
1671  LOG_DEBUG("0x%" TARGET_PRIxADDR " -> 0x%" TARGET_PRIxADDR, virtual,
1672  *physical);
1673 
1674  return ERROR_OK;
1675 }
1676 
1677 static int riscv_virt2phys(struct target *target, target_addr_t virtual, target_addr_t *physical)
1678 {
1679  int enabled;
1680  if (riscv_mmu(target, &enabled) == ERROR_OK) {
1681  if (!enabled)
1682  return ERROR_FAIL;
1683 
1684  if (riscv_address_translate(target, virtual, physical) == ERROR_OK)
1685  return ERROR_OK;
1686  }
1687 
1688  return ERROR_FAIL;
1689 }
1690 
1691 static int riscv_read_phys_memory(struct target *target, target_addr_t phys_address,
1692  uint32_t size, uint32_t count, uint8_t *buffer)
1693 {
1694  RISCV_INFO(r);
1696  return ERROR_FAIL;
1697  return r->read_memory(target, phys_address, size, count, buffer, size);
1698 }
1699 
1700 static int riscv_read_memory(struct target *target, target_addr_t address,
1701  uint32_t size, uint32_t count, uint8_t *buffer)
1702 {
1703  if (count == 0) {
1704  LOG_WARNING("0-length read from 0x%" TARGET_PRIxADDR, address);
1705  return ERROR_OK;
1706  }
1707 
1709  return ERROR_FAIL;
1710 
1711  target_addr_t physical_addr;
1712  if (target->type->virt2phys(target, address, &physical_addr) == ERROR_OK)
1713  address = physical_addr;
1714 
1715  RISCV_INFO(r);
1716  return r->read_memory(target, address, size, count, buffer, size);
1717 }
1718 
1719 static int riscv_write_phys_memory(struct target *target, target_addr_t phys_address,
1720  uint32_t size, uint32_t count, const uint8_t *buffer)
1721 {
1723  return ERROR_FAIL;
1724  struct target_type *tt = get_target_type(target);
1725  return tt->write_memory(target, phys_address, size, count, buffer);
1726 }
1727 
1728 static int riscv_write_memory(struct target *target, target_addr_t address,
1729  uint32_t size, uint32_t count, const uint8_t *buffer)
1730 {
1731  if (count == 0) {
1732  LOG_WARNING("0-length write to 0x%" TARGET_PRIxADDR, address);
1733  return ERROR_OK;
1734  }
1735 
1737  return ERROR_FAIL;
1738 
1739  target_addr_t physical_addr;
1740  if (target->type->virt2phys(target, address, &physical_addr) == ERROR_OK)
1741  address = physical_addr;
1742 
1743  struct target_type *tt = get_target_type(target);
1744  return tt->write_memory(target, address, size, count, buffer);
1745 }
1746 
1747 static const char *riscv_get_gdb_arch(struct target *target)
1748 {
1749  switch (riscv_xlen(target)) {
1750  case 32:
1751  return "riscv:rv32";
1752  case 64:
1753  return "riscv:rv64";
1754  }
1755  LOG_ERROR("Unsupported xlen: %d", riscv_xlen(target));
1756  return NULL;
1757 }
1758 
1760  struct reg **reg_list[], int *reg_list_size,
1761  enum target_register_class reg_class, bool read)
1762 {
1763  RISCV_INFO(r);
1764  LOG_DEBUG("[%s] {%d} reg_class=%d, read=%d",
1765  target_name(target), r->current_hartid, reg_class, read);
1766 
1767  if (!target->reg_cache) {
1768  LOG_ERROR("Target not initialized. Return ERROR_FAIL.");
1769  return ERROR_FAIL;
1770  }
1771 
1773  return ERROR_FAIL;
1774 
1775  switch (reg_class) {
1776  case REG_CLASS_GENERAL:
1777  *reg_list_size = 33;
1778  break;
1779  case REG_CLASS_ALL:
1780  *reg_list_size = target->reg_cache->num_regs;
1781  break;
1782  default:
1783  LOG_ERROR("Unsupported reg_class: %d", reg_class);
1784  return ERROR_FAIL;
1785  }
1786 
1787  *reg_list = calloc(*reg_list_size, sizeof(struct reg *));
1788  if (!*reg_list)
1789  return ERROR_FAIL;
1790 
1791  for (int i = 0; i < *reg_list_size; i++) {
1792  assert(!target->reg_cache->reg_list[i].valid ||
1793  target->reg_cache->reg_list[i].size > 0);
1794  (*reg_list)[i] = &target->reg_cache->reg_list[i];
1795  if (read &&
1796  target->reg_cache->reg_list[i].exist &&
1797  !target->reg_cache->reg_list[i].valid) {
1798  if (target->reg_cache->reg_list[i].type->get(
1799  &target->reg_cache->reg_list[i]) != ERROR_OK)
1800  return ERROR_FAIL;
1801  }
1802  }
1803 
1804  return ERROR_OK;
1805 }
1806 
1808  struct reg **reg_list[], int *reg_list_size,
1809  enum target_register_class reg_class)
1810 {
1811  return riscv_get_gdb_reg_list_internal(target, reg_list, reg_list_size,
1812  reg_class, false);
1813 }
1814 
1816  struct reg **reg_list[], int *reg_list_size,
1817  enum target_register_class reg_class)
1818 {
1819  return riscv_get_gdb_reg_list_internal(target, reg_list, reg_list_size,
1820  reg_class, true);
1821 }
1822 
1823 static int riscv_arch_state(struct target *target)
1824 {
1825  struct target_type *tt = get_target_type(target);
1826  return tt->arch_state(target);
1827 }
1828 
1829 /* Algorithm must end with a software breakpoint instruction. */
1830 static int riscv_run_algorithm(struct target *target, int num_mem_params,
1831  struct mem_param *mem_params, int num_reg_params,
1832  struct reg_param *reg_params, target_addr_t entry_point,
1833  target_addr_t exit_point, int timeout_ms, void *arch_info)
1834 {
1835  RISCV_INFO(info);
1836 
1837  if (num_mem_params > 0) {
1838  LOG_ERROR("Memory parameters are not supported for RISC-V algorithms.");
1839  return ERROR_FAIL;
1840  }
1841 
1842  if (target->state != TARGET_HALTED) {
1843  LOG_WARNING("target not halted");
1844  return ERROR_TARGET_NOT_HALTED;
1845  }
1846 
1847  /* Save registers */
1848  struct reg *reg_pc = register_get_by_name(target->reg_cache, "pc", true);
1849  if (!reg_pc || reg_pc->type->get(reg_pc) != ERROR_OK)
1850  return ERROR_FAIL;
1851  uint64_t saved_pc = buf_get_u64(reg_pc->value, 0, reg_pc->size);
1852  LOG_DEBUG("saved_pc=0x%" PRIx64, saved_pc);
1853 
1854  uint64_t saved_regs[32];
1855  for (int i = 0; i < num_reg_params; i++) {
1856  LOG_DEBUG("save %s", reg_params[i].reg_name);
1857  struct reg *r = register_get_by_name(target->reg_cache, reg_params[i].reg_name, false);
1858  if (!r) {
1859  LOG_ERROR("Couldn't find register named '%s'", reg_params[i].reg_name);
1860  return ERROR_FAIL;
1861  }
1862 
1863  if (r->size != reg_params[i].size) {
1864  LOG_ERROR("Register %s is %d bits instead of %d bits.",
1865  reg_params[i].reg_name, r->size, reg_params[i].size);
1866  return ERROR_FAIL;
1867  }
1868 
1869  if (r->number > GDB_REGNO_XPR31) {
1870  LOG_ERROR("Only GPRs can be use as argument registers.");
1871  return ERROR_FAIL;
1872  }
1873 
1874  if (r->type->get(r) != ERROR_OK)
1875  return ERROR_FAIL;
1876  saved_regs[r->number] = buf_get_u64(r->value, 0, r->size);
1877 
1878  if (reg_params[i].direction == PARAM_OUT || reg_params[i].direction == PARAM_IN_OUT) {
1879  if (r->type->set(r, reg_params[i].value) != ERROR_OK)
1880  return ERROR_FAIL;
1881  }
1882  }
1883 
1884 
1885  /* Disable Interrupts before attempting to run the algorithm. */
1886  uint64_t current_mstatus;
1887  uint8_t mstatus_bytes[8] = { 0 };
1888 
1889  LOG_DEBUG("Disabling Interrupts");
1890  struct reg *reg_mstatus = register_get_by_name(target->reg_cache,
1891  "mstatus", true);
1892  if (!reg_mstatus) {
1893  LOG_ERROR("Couldn't find mstatus!");
1894  return ERROR_FAIL;
1895  }
1896 
1897  reg_mstatus->type->get(reg_mstatus);
1898  current_mstatus = buf_get_u64(reg_mstatus->value, 0, reg_mstatus->size);
1899  uint64_t ie_mask = MSTATUS_MIE | MSTATUS_HIE | MSTATUS_SIE | MSTATUS_UIE;
1900  buf_set_u64(mstatus_bytes, 0, info->xlen, set_field(current_mstatus,
1901  ie_mask, 0));
1902 
1903  reg_mstatus->type->set(reg_mstatus, mstatus_bytes);
1904 
1905  /* Run algorithm */
1906  LOG_DEBUG("resume at 0x%" TARGET_PRIxADDR, entry_point);
1907  if (riscv_resume(target, 0, entry_point, 0, 0, true) != ERROR_OK)
1908  return ERROR_FAIL;
1909 
1910  int64_t start = timeval_ms();
1911  while (target->state != TARGET_HALTED) {
1912  LOG_DEBUG("poll()");
1913  int64_t now = timeval_ms();
1914  if (now - start > timeout_ms) {
1915  LOG_ERROR("Algorithm timed out after %" PRId64 " ms.", now - start);
1916  riscv_halt(target);
1918  enum gdb_regno regnums[] = {
1927  GDB_REGNO_PC,
1929  };
1930  for (unsigned i = 0; i < ARRAY_SIZE(regnums); i++) {
1931  enum gdb_regno regno = regnums[i];
1932  riscv_reg_t reg_value;
1933  if (riscv_get_register(target, &reg_value, regno) != ERROR_OK)
1934  break;
1935  LOG_ERROR("%s = 0x%" PRIx64, gdb_regno_name(regno), reg_value);
1936  }
1937  return ERROR_TARGET_TIMEOUT;
1938  }
1939 
1940  int result = old_or_new_riscv_poll(target);
1941  if (result != ERROR_OK)
1942  return result;
1943  }
1944 
1945  /* The current hart id might have been changed in poll(). */
1947  return ERROR_FAIL;
1948 
1949  if (reg_pc->type->get(reg_pc) != ERROR_OK)
1950  return ERROR_FAIL;
1951  uint64_t final_pc = buf_get_u64(reg_pc->value, 0, reg_pc->size);
1952  if (exit_point && final_pc != exit_point) {
1953  LOG_ERROR("PC ended up at 0x%" PRIx64 " instead of 0x%"
1954  TARGET_PRIxADDR, final_pc, exit_point);
1955  return ERROR_FAIL;
1956  }
1957 
1958  /* Restore Interrupts */
1959  LOG_DEBUG("Restoring Interrupts");
1960  buf_set_u64(mstatus_bytes, 0, info->xlen, current_mstatus);
1961  reg_mstatus->type->set(reg_mstatus, mstatus_bytes);
1962 
1963  /* Restore registers */
1964  uint8_t buf[8] = { 0 };
1965  buf_set_u64(buf, 0, info->xlen, saved_pc);
1966  if (reg_pc->type->set(reg_pc, buf) != ERROR_OK)
1967  return ERROR_FAIL;
1968 
1969  for (int i = 0; i < num_reg_params; i++) {
1970  if (reg_params[i].direction == PARAM_IN ||
1971  reg_params[i].direction == PARAM_IN_OUT) {
1972  struct reg *r = register_get_by_name(target->reg_cache, reg_params[i].reg_name, false);
1973  if (r->type->get(r) != ERROR_OK) {
1974  LOG_ERROR("get(%s) failed", r->name);
1975  return ERROR_FAIL;
1976  }
1977  buf_cpy(r->value, reg_params[i].value, reg_params[i].size);
1978  }
1979  LOG_DEBUG("restore %s", reg_params[i].reg_name);
1980  struct reg *r = register_get_by_name(target->reg_cache, reg_params[i].reg_name, false);
1981  buf_set_u64(buf, 0, info->xlen, saved_regs[r->number]);
1982  if (r->type->set(r, buf) != ERROR_OK) {
1983  LOG_ERROR("set(%s) failed", r->name);
1984  return ERROR_FAIL;
1985  }
1986  }
1987 
1988  return ERROR_OK;
1989 }
1990 
1992  target_addr_t address, uint32_t count,
1993  uint32_t *checksum)
1994 {
1995  struct working_area *crc_algorithm;
1996  struct reg_param reg_params[2];
1997  int retval;
1998 
1999  LOG_DEBUG("address=0x%" TARGET_PRIxADDR "; count=0x%" PRIx32, address, count);
2000 
2001  static const uint8_t riscv32_crc_code[] = {
2002 #include "../../../contrib/loaders/checksum/riscv32_crc.inc"
2003  };
2004  static const uint8_t riscv64_crc_code[] = {
2005 #include "../../../contrib/loaders/checksum/riscv64_crc.inc"
2006  };
2007 
2008  static const uint8_t *crc_code;
2009 
2010  unsigned xlen = riscv_xlen(target);
2011  unsigned crc_code_size;
2012  if (xlen == 32) {
2013  crc_code = riscv32_crc_code;
2014  crc_code_size = sizeof(riscv32_crc_code);
2015  } else {
2016  crc_code = riscv64_crc_code;
2017  crc_code_size = sizeof(riscv64_crc_code);
2018  }
2019 
2020  if (count < crc_code_size * 4) {
2021  /* Don't use the algorithm for relatively small buffers. It's faster
2022  * just to read the memory. target_checksum_memory() will take care of
2023  * that if we fail. */
2024  return ERROR_FAIL;
2025  }
2026 
2027  retval = target_alloc_working_area(target, crc_code_size, &crc_algorithm);
2028  if (retval != ERROR_OK)
2029  return retval;
2030 
2031  if (crc_algorithm->address + crc_algorithm->size > address &&
2032  crc_algorithm->address < address + count) {
2033  /* Region to checksum overlaps with the work area we've been assigned.
2034  * Bail. (Would be better to manually checksum what we read there, and
2035  * use the algorithm for the rest.) */
2036  target_free_working_area(target, crc_algorithm);
2037  return ERROR_FAIL;
2038  }
2039 
2040  retval = target_write_buffer(target, crc_algorithm->address, crc_code_size,
2041  crc_code);
2042  if (retval != ERROR_OK) {
2043  LOG_ERROR("Failed to write code to " TARGET_ADDR_FMT ": %d",
2044  crc_algorithm->address, retval);
2045  target_free_working_area(target, crc_algorithm);
2046  return retval;
2047  }
2048 
2049  init_reg_param(&reg_params[0], "a0", xlen, PARAM_IN_OUT);
2050  init_reg_param(&reg_params[1], "a1", xlen, PARAM_OUT);
2051  buf_set_u64(reg_params[0].value, 0, xlen, address);
2052  buf_set_u64(reg_params[1].value, 0, xlen, count);
2053 
2054  /* 20 second timeout/megabyte */
2055  int timeout = 20000 * (1 + (count / (1024 * 1024)));
2056 
2057  retval = target_run_algorithm(target, 0, NULL, 2, reg_params,
2058  crc_algorithm->address,
2059  0, /* Leave exit point unspecified because we don't know. */
2060  timeout, NULL);
2061 
2062  if (retval == ERROR_OK)
2063  *checksum = buf_get_u32(reg_params[0].value, 0, 32);
2064  else
2065  LOG_ERROR("error executing RISC-V CRC algorithm");
2066 
2067  destroy_reg_param(&reg_params[0]);
2068  destroy_reg_param(&reg_params[1]);
2069 
2070  target_free_working_area(target, crc_algorithm);
2071 
2072  LOG_DEBUG("checksum=0x%" PRIx32 ", result=%d", *checksum, retval);
2073 
2074  return retval;
2075 }
2076 
2077 /*** OpenOCD Helper Functions ***/
2078 
2083  RPH_ERROR
2084 };
2085 static enum riscv_poll_hart riscv_poll_hart(struct target *target, int hartid)
2086 {
2087  RISCV_INFO(r);
2088  if (riscv_set_current_hartid(target, hartid) != ERROR_OK)
2089  return RPH_ERROR;
2090 
2091  LOG_DEBUG("polling hart %d, target->state=%d", hartid, target->state);
2092 
2093  /* If OpenOCD thinks we're running but this hart is halted then it's time
2094  * to raise an event. */
2095  bool halted = riscv_is_halted(target);
2096  if (target->state != TARGET_HALTED && halted) {
2097  LOG_DEBUG(" triggered a halt");
2098  r->on_halt(target);
2099  return RPH_DISCOVERED_HALTED;
2100  } else if (target->state != TARGET_RUNNING && !halted) {
2101  LOG_DEBUG(" triggered running");
2104  return RPH_DISCOVERED_RUNNING;
2105  }
2106 
2107  return RPH_NO_CHANGE;
2108 }
2109 
2110 static int set_debug_reason(struct target *target, enum riscv_halt_reason halt_reason)
2111 {
2112  switch (halt_reason) {
2113  case RISCV_HALT_BREAKPOINT:
2115  break;
2116  case RISCV_HALT_TRIGGER:
2118  break;
2119  case RISCV_HALT_INTERRUPT:
2120  case RISCV_HALT_GROUP:
2122  break;
2123  case RISCV_HALT_SINGLESTEP:
2125  break;
2126  case RISCV_HALT_UNKNOWN:
2128  break;
2129  case RISCV_HALT_ERROR:
2130  return ERROR_FAIL;
2131  }
2132  LOG_DEBUG("[%s] debug_reason=%d", target_name(target), target->debug_reason);
2133  return ERROR_OK;
2134 }
2135 
2136 static int sample_memory(struct target *target)
2137 {
2138  RISCV_INFO(r);
2139 
2140  if (!r->sample_buf.buf || !r->sample_config.enabled)
2141  return ERROR_OK;
2142 
2143  LOG_DEBUG("buf used/size: %d/%d", r->sample_buf.used, r->sample_buf.size);
2144 
2145  uint64_t start = timeval_ms();
2147  int result = ERROR_OK;
2148  if (r->sample_memory) {
2149  result = r->sample_memory(target, &r->sample_buf, &r->sample_config,
2151  if (result != ERROR_NOT_IMPLEMENTED)
2152  goto exit;
2153  }
2154 
2155  /* Default slow path. */
2157  for (unsigned int i = 0; i < ARRAY_SIZE(r->sample_config.bucket); i++) {
2158  if (r->sample_config.bucket[i].enabled &&
2159  r->sample_buf.used + 1 + r->sample_config.bucket[i].size_bytes < r->sample_buf.size) {
2161  r->sample_buf.buf[r->sample_buf.used] = i;
2162  result = riscv_read_phys_memory(
2163  target, r->sample_config.bucket[i].address,
2164  r->sample_config.bucket[i].size_bytes, 1,
2165  r->sample_buf.buf + r->sample_buf.used + 1);
2166  if (result == ERROR_OK)
2167  r->sample_buf.used += 1 + r->sample_config.bucket[i].size_bytes;
2168  else
2169  goto exit;
2170  }
2171  }
2172  }
2173 
2174 exit:
2176  if (result != ERROR_OK) {
2177  LOG_INFO("Turning off memory sampling because it failed.");
2178  r->sample_config.enabled = false;
2179  }
2180  return result;
2181 }
2182 
2183 /*** OpenOCD Interface ***/
2185 {
2186  LOG_DEBUG("polling all harts");
2187  int halted_hart = -1;
2188 
2189  if (target->smp) {
2190  unsigned halts_discovered = 0;
2191  unsigned should_remain_halted = 0;
2192  unsigned should_resume = 0;
2193  struct target_list *list;
2195  struct target *t = list->target;
2196  struct riscv_info *r = riscv_info(t);
2198  switch (out) {
2199  case RPH_NO_CHANGE:
2200  break;
2202  t->state = TARGET_RUNNING;
2204  break;
2205  case RPH_DISCOVERED_HALTED:
2206  halts_discovered++;
2207  t->state = TARGET_HALTED;
2211  return ERROR_FAIL;
2212 
2214  int retval;
2215  switch (riscv_semihosting(t, &retval)) {
2216  case SEMIHOSTING_NONE:
2217  case SEMIHOSTING_WAITING:
2218  /* This hart should remain halted. */
2219  should_remain_halted++;
2220  break;
2221  case SEMIHOSTING_HANDLED:
2222  /* This hart should be resumed, along with any other
2223  * harts that halted due to haltgroups. */
2224  should_resume++;
2225  break;
2226  case SEMIHOSTING_ERROR:
2227  return retval;
2228  }
2229  } else if (halt_reason != RISCV_HALT_GROUP) {
2230  should_remain_halted++;
2231  }
2232  break;
2233 
2234  case RPH_ERROR:
2235  return ERROR_FAIL;
2236  }
2237  }
2238 
2239  LOG_DEBUG("should_remain_halted=%d, should_resume=%d",
2240  should_remain_halted, should_resume);
2241  if (should_remain_halted && should_resume) {
2242  LOG_WARNING("%d harts should remain halted, and %d should resume.",
2243  should_remain_halted, should_resume);
2244  }
2245  if (should_remain_halted) {
2246  LOG_DEBUG("halt all");
2247  riscv_halt(target);
2248  } else if (should_resume) {
2249  LOG_DEBUG("resume all");
2250  riscv_resume(target, true, 0, 0, 0, false);
2251  }
2252 
2253  /* Sample memory if any target is running. */
2255  struct target *t = list->target;
2256  if (t->state == TARGET_RUNNING) {
2258  break;
2259  }
2260  }
2261 
2262  return ERROR_OK;
2263 
2264  } else {
2267  if (out == RPH_NO_CHANGE || out == RPH_DISCOVERED_RUNNING) {
2268  if (target->state == TARGET_RUNNING)
2270  return ERROR_OK;
2271  } else if (out == RPH_ERROR) {
2272  return ERROR_FAIL;
2273  }
2274 
2275  halted_hart = riscv_current_hartid(target);
2276  LOG_DEBUG(" hart %d halted", halted_hart);
2277 
2278  enum riscv_halt_reason halt_reason = riscv_halt_reason(target, halted_hart);
2279  if (set_debug_reason(target, halt_reason) != ERROR_OK)
2280  return ERROR_FAIL;
2282  }
2283 
2285  int retval;
2286  switch (riscv_semihosting(target, &retval)) {
2287  case SEMIHOSTING_NONE:
2288  case SEMIHOSTING_WAITING:
2290  break;
2291  case SEMIHOSTING_HANDLED:
2292  if (riscv_resume(target, true, 0, 0, 0, false) != ERROR_OK)
2293  return ERROR_FAIL;
2294  break;
2295  case SEMIHOSTING_ERROR:
2296  return retval;
2297  }
2298  } else {
2300  }
2301 
2302  return ERROR_OK;
2303 }
2304 
2305 int riscv_openocd_step(struct target *target, int current,
2306  target_addr_t address, int handle_breakpoints)
2307 {
2308  LOG_DEBUG("stepping rtos hart");
2309 
2310  if (!current)
2312 
2313  riscv_reg_t trigger_state[RISCV_MAX_HWBPS] = {0};
2314  if (disable_triggers(target, trigger_state) != ERROR_OK)
2315  return ERROR_FAIL;
2316 
2317  int out = riscv_step_rtos_hart(target);
2318  if (out != ERROR_OK) {
2319  LOG_ERROR("unable to step rtos hart");
2320  return out;
2321  }
2322 
2324 
2325  if (enable_triggers(target, trigger_state) != ERROR_OK)
2326  return ERROR_FAIL;
2327 
2333  return out;
2334 }
2335 
2336 /* Command Handlers */
2337 COMMAND_HANDLER(riscv_set_command_timeout_sec)
2338 {
2339  if (CMD_ARGC != 1) {
2340  LOG_ERROR("Command takes exactly 1 parameter");
2342  }
2343  int timeout = atoi(CMD_ARGV[0]);
2344  if (timeout <= 0) {
2345  LOG_ERROR("%s is not a valid integer argument for command.", CMD_ARGV[0]);
2346  return ERROR_FAIL;
2347  }
2348 
2350 
2351  return ERROR_OK;
2352 }
2353 
2354 COMMAND_HANDLER(riscv_set_reset_timeout_sec)
2355 {
2356  if (CMD_ARGC != 1) {
2357  LOG_ERROR("Command takes exactly 1 parameter");
2359  }
2360  int timeout = atoi(CMD_ARGV[0]);
2361  if (timeout <= 0) {
2362  LOG_ERROR("%s is not a valid integer argument for command.", CMD_ARGV[0]);
2363  return ERROR_FAIL;
2364  }
2365 
2367  return ERROR_OK;
2368 }
2369 
2370 COMMAND_HANDLER(riscv_set_prefer_sba)
2371 {
2373  RISCV_INFO(r);
2374  bool prefer_sba;
2375  LOG_WARNING("`riscv set_prefer_sba` is deprecated. Please use `riscv set_mem_access` instead.");
2376  if (CMD_ARGC != 1) {
2377  LOG_ERROR("Command takes exactly 1 parameter");
2379  }
2380  COMMAND_PARSE_ON_OFF(CMD_ARGV[0], prefer_sba);
2381  if (prefer_sba) {
2382  /* Use system bus with highest priority */
2383  r->mem_access_methods[0] = RISCV_MEM_ACCESS_SYSBUS;
2384  r->mem_access_methods[1] = RISCV_MEM_ACCESS_PROGBUF;
2385  r->mem_access_methods[2] = RISCV_MEM_ACCESS_ABSTRACT;
2386  } else {
2387  /* Use progbuf with highest priority */
2388  r->mem_access_methods[0] = RISCV_MEM_ACCESS_PROGBUF;
2389  r->mem_access_methods[1] = RISCV_MEM_ACCESS_SYSBUS;
2390  r->mem_access_methods[2] = RISCV_MEM_ACCESS_ABSTRACT;
2391  }
2392 
2393  /* Reset warning flags */
2394  r->mem_access_progbuf_warn = true;
2395  r->mem_access_sysbus_warn = true;
2396  r->mem_access_abstract_warn = true;
2397 
2398  return ERROR_OK;
2399 }
2400 
2401 COMMAND_HANDLER(riscv_set_mem_access)
2402 {
2404  RISCV_INFO(r);
2405  int progbuf_cnt = 0;
2406  int sysbus_cnt = 0;
2407  int abstract_cnt = 0;
2408 
2409  if (CMD_ARGC < 1 || CMD_ARGC > RISCV_NUM_MEM_ACCESS_METHODS) {
2410  LOG_ERROR("Command takes 1 to %d parameters", RISCV_NUM_MEM_ACCESS_METHODS);
2412  }
2413 
2414  /* Check argument validity */
2415  for (unsigned int i = 0; i < CMD_ARGC; i++) {
2416  if (strcmp("progbuf", CMD_ARGV[i]) == 0) {
2417  progbuf_cnt++;
2418  } else if (strcmp("sysbus", CMD_ARGV[i]) == 0) {
2419  sysbus_cnt++;
2420  } else if (strcmp("abstract", CMD_ARGV[i]) == 0) {
2421  abstract_cnt++;
2422  } else {
2423  LOG_ERROR("Unknown argument '%s'. "
2424  "Must be one of: 'progbuf', 'sysbus' or 'abstract'.", CMD_ARGV[i]);
2426  }
2427  }
2428  if (progbuf_cnt > 1 || sysbus_cnt > 1 || abstract_cnt > 1) {
2429  LOG_ERROR("Syntax error - duplicate arguments to `riscv set_mem_access`.");
2431  }
2432 
2433  /* Args are valid, store them */
2434  for (unsigned int i = 0; i < RISCV_NUM_MEM_ACCESS_METHODS; i++)
2435  r->mem_access_methods[i] = RISCV_MEM_ACCESS_UNSPECIFIED;
2436  for (unsigned int i = 0; i < CMD_ARGC; i++) {
2437  if (strcmp("progbuf", CMD_ARGV[i]) == 0)
2438  r->mem_access_methods[i] = RISCV_MEM_ACCESS_PROGBUF;
2439  else if (strcmp("sysbus", CMD_ARGV[i]) == 0)
2440  r->mem_access_methods[i] = RISCV_MEM_ACCESS_SYSBUS;
2441  else if (strcmp("abstract", CMD_ARGV[i]) == 0)
2442  r->mem_access_methods[i] = RISCV_MEM_ACCESS_ABSTRACT;
2443  }
2444 
2445  /* Reset warning flags */
2446  r->mem_access_progbuf_warn = true;
2447  r->mem_access_sysbus_warn = true;
2448  r->mem_access_abstract_warn = true;
2449 
2450  return ERROR_OK;
2451 }
2452 
2453 COMMAND_HANDLER(riscv_set_enable_virtual)
2454 {
2455  if (CMD_ARGC != 1) {
2456  LOG_ERROR("Command takes exactly 1 parameter");
2458  }
2460  return ERROR_OK;
2461 }
2462 
2463 static int parse_ranges(struct list_head *ranges, const char *tcl_arg, const char *reg_type, unsigned int max_val)
2464 {
2465  char *args = strdup(tcl_arg);
2466  if (!args)
2467  return ERROR_FAIL;
2468 
2469  /* For backward compatibility, allow multiple parameters within one TCL argument, separated by ',' */
2470  char *arg = strtok(args, ",");
2471  while (arg) {
2472  unsigned low = 0;
2473  unsigned high = 0;
2474  char *name = NULL;
2475 
2476  char *dash = strchr(arg, '-');
2477  char *equals = strchr(arg, '=');
2478  unsigned int pos;
2479 
2480  if (!dash && !equals) {
2481  /* Expecting single register number. */
2482  if (sscanf(arg, "%u%n", &low, &pos) != 1 || pos != strlen(arg)) {
2483  LOG_ERROR("Failed to parse single register number from '%s'.", arg);
2484  free(args);
2486  }
2487  } else if (dash && !equals) {
2488  /* Expecting register range - two numbers separated by a dash: ##-## */
2489  *dash = 0;
2490  dash++;
2491  if (sscanf(arg, "%u%n", &low, &pos) != 1 || pos != strlen(arg)) {
2492  LOG_ERROR("Failed to parse single register number from '%s'.", arg);
2493  free(args);
2495  }
2496  if (sscanf(dash, "%u%n", &high, &pos) != 1 || pos != strlen(dash)) {
2497  LOG_ERROR("Failed to parse single register number from '%s'.", dash);
2498  free(args);
2500  }
2501  if (high < low) {
2502  LOG_ERROR("Incorrect range encountered [%u, %u].", low, high);
2503  free(args);
2504  return ERROR_FAIL;
2505  }
2506  } else if (!dash && equals) {
2507  /* Expecting single register number with textual name specified: ##=name */
2508  *equals = 0;
2509  equals++;
2510  if (sscanf(arg, "%u%n", &low, &pos) != 1 || pos != strlen(arg)) {
2511  LOG_ERROR("Failed to parse single register number from '%s'.", arg);
2512  free(args);
2514  }
2515 
2516  name = calloc(1, strlen(equals) + strlen(reg_type) + 2);
2517  if (!name) {
2518  LOG_ERROR("Failed to allocate register name.");
2519  free(args);
2520  return ERROR_FAIL;
2521  }
2522 
2523  /* Register prefix: "csr_" or "custom_" */
2524  strcpy(name, reg_type);
2525  name[strlen(reg_type)] = '_';
2526 
2527  if (sscanf(equals, "%[_a-zA-Z0-9]%n", name + strlen(reg_type) + 1, &pos) != 1 || pos != strlen(equals)) {
2528  LOG_ERROR("Failed to parse register name from '%s'.", equals);
2529  free(args);
2530  free(name);
2532  }
2533  } else {
2534  LOG_ERROR("Invalid argument '%s'.", arg);
2535  free(args);
2537  }
2538 
2539  high = high > low ? high : low;
2540 
2541  if (high > max_val) {
2542  LOG_ERROR("Cannot expose %s register number %u, maximum allowed value is %u.", reg_type, high, max_val);
2543  free(name);
2544  free(args);
2545  return ERROR_FAIL;
2546  }
2547 
2548  /* Check for overlap, name uniqueness. */
2549  range_list_t *entry;
2550  list_for_each_entry(entry, ranges, list) {
2551  if ((entry->low <= high) && (low <= entry->high)) {
2552  if (low == high)
2553  LOG_WARNING("Duplicate %s register number - "
2554  "Register %u has already been exposed previously", reg_type, low);
2555  else
2556  LOG_WARNING("Overlapping register ranges - Register range starting from %u overlaps "
2557  "with already exposed register/range at %u.", low, entry->low);
2558  }
2559 
2560  if (entry->name && name && (strcasecmp(entry->name, name) == 0)) {
2561  LOG_ERROR("Duplicate register name \"%s\" found.", name);
2562  free(name);
2563  free(args);
2564  return ERROR_FAIL;
2565  }
2566  }
2567 
2568  range_list_t *range = calloc(1, sizeof(range_list_t));
2569  if (!range) {
2570  LOG_ERROR("Failed to allocate range list.");
2571  free(name);
2572  free(args);
2573  return ERROR_FAIL;
2574  }
2575 
2576  range->low = low;
2577  range->high = high;
2578  range->name = name;
2579  list_add(&range->list, ranges);
2580 
2581  arg = strtok(NULL, ",");
2582  }
2583 
2584  free(args);
2585  return ERROR_OK;
2586 }
2587 
2588 COMMAND_HANDLER(riscv_set_expose_csrs)
2589 {
2590  if (CMD_ARGC == 0) {
2591  LOG_ERROR("Command expects parameters");
2593  }
2594 
2596  RISCV_INFO(info);
2597  int ret = ERROR_OK;
2598 
2599  for (unsigned int i = 0; i < CMD_ARGC; i++) {
2600  ret = parse_ranges(&info->expose_csr, CMD_ARGV[i], "csr", 0xfff);
2601  if (ret != ERROR_OK)
2602  break;
2603  }
2604 
2605  return ret;
2606 }
2607 
2608 COMMAND_HANDLER(riscv_set_expose_custom)
2609 {
2610  if (CMD_ARGC == 0) {
2611  LOG_ERROR("Command expects parameters");
2613  }
2614 
2616  RISCV_INFO(info);
2617  int ret = ERROR_OK;
2618 
2619  for (unsigned int i = 0; i < CMD_ARGC; i++) {
2620  ret = parse_ranges(&info->expose_custom, CMD_ARGV[i], "custom", 0x3fff);
2621  if (ret != ERROR_OK)
2622  break;
2623  }
2624 
2625  return ret;
2626 }
2627 
2628 COMMAND_HANDLER(riscv_authdata_read)
2629 {
2630  unsigned int index = 0;
2631  if (CMD_ARGC == 0) {
2632  /* nop */
2633  } else if (CMD_ARGC == 1) {
2634  COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], index);
2635  } else {
2636  LOG_ERROR("Command takes at most one parameter");
2638  }
2639 
2641  if (!target) {
2642  LOG_ERROR("target is NULL!");
2643  return ERROR_FAIL;
2644  }
2645 
2646  RISCV_INFO(r);
2647  if (!r) {
2648  LOG_ERROR("riscv_info is NULL!");
2649  return ERROR_FAIL;
2650  }
2651 
2652  if (r->authdata_read) {
2653  uint32_t value;
2654  if (r->authdata_read(target, &value, index) != ERROR_OK)
2655  return ERROR_FAIL;
2656  command_print_sameline(CMD, "0x%08" PRIx32, value);
2657  return ERROR_OK;
2658  } else {
2659  LOG_ERROR("authdata_read is not implemented for this target.");
2660  return ERROR_FAIL;
2661  }
2662 }
2663 
2664 COMMAND_HANDLER(riscv_authdata_write)
2665 {
2666  uint32_t value;
2667  unsigned int index = 0;
2668 
2669  if (CMD_ARGC == 0 || CMD_ARGC > 2)
2671 
2672  if (CMD_ARGC == 1) {
2673  COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], value);
2674  } else {
2675  COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], index);
2676  COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], value);
2677  }
2678 
2680  RISCV_INFO(r);
2681 
2682  if (!r->authdata_write) {
2683  LOG_ERROR("authdata_write is not implemented for this target.");
2684  return ERROR_FAIL;
2685  }
2686 
2687  return r->authdata_write(target, value, index);
2688 }
2689 
2690 COMMAND_HANDLER(riscv_dmi_read)
2691 {
2692  if (CMD_ARGC != 1) {
2693  LOG_ERROR("Command takes 1 parameter");
2695  }
2696 
2698  if (!target) {
2699  LOG_ERROR("target is NULL!");
2700  return ERROR_FAIL;
2701  }
2702 
2703  RISCV_INFO(r);
2704  if (!r) {
2705  LOG_ERROR("riscv_info is NULL!");
2706  return ERROR_FAIL;
2707  }
2708 
2709  if (r->dmi_read) {
2710  uint32_t address, value;
2711  COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], address);
2712  if (r->dmi_read(target, &value, address) != ERROR_OK)
2713  return ERROR_FAIL;
2714  command_print(CMD, "0x%" PRIx32, value);
2715  return ERROR_OK;
2716  } else {
2717  LOG_ERROR("dmi_read is not implemented for this target.");
2718  return ERROR_FAIL;
2719  }
2720 }
2721 
2722 
2723 COMMAND_HANDLER(riscv_dmi_write)
2724 {
2725  if (CMD_ARGC != 2) {
2726  LOG_ERROR("Command takes exactly 2 arguments");
2728  }
2729 
2731  RISCV_INFO(r);
2732 
2733  uint32_t address, value;
2734  COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], address);
2735  COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], value);
2736 
2737  if (r->dmi_write) {
2738  return r->dmi_write(target, address, value);
2739  } else {
2740  LOG_ERROR("dmi_write is not implemented for this target.");
2741  return ERROR_FAIL;
2742  }
2743 }
2744 
2745 COMMAND_HANDLER(riscv_test_sba_config_reg)
2746 {
2747  LOG_WARNING("Command \"riscv test_sba_config_reg\" is deprecated. "
2748  "It will be removed in a future OpenOCD version.");
2749 
2750  if (CMD_ARGC != 4) {
2751  LOG_ERROR("Command takes exactly 4 arguments");
2753  }
2754 
2756  RISCV_INFO(r);
2757 
2758  target_addr_t legal_address;
2759  uint32_t num_words;
2760  target_addr_t illegal_address;
2761  bool run_sbbusyerror_test;
2762 
2763  COMMAND_PARSE_NUMBER(target_addr, CMD_ARGV[0], legal_address);
2764  COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], num_words);
2765  COMMAND_PARSE_NUMBER(target_addr, CMD_ARGV[2], illegal_address);
2766  COMMAND_PARSE_ON_OFF(CMD_ARGV[3], run_sbbusyerror_test);
2767 
2768  if (r->test_sba_config_reg) {
2769  return r->test_sba_config_reg(target, legal_address, num_words,
2770  illegal_address, run_sbbusyerror_test);
2771  } else {
2772  LOG_ERROR("test_sba_config_reg is not implemented for this target.");
2773  return ERROR_FAIL;
2774  }
2775 }
2776 
2777 COMMAND_HANDLER(riscv_reset_delays)
2778 {
2779  int wait = 0;
2780 
2781  if (CMD_ARGC > 1) {
2782  LOG_ERROR("Command takes at most one argument");
2784  }
2785 
2786  if (CMD_ARGC == 1)
2787  COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], wait);
2788 
2790  RISCV_INFO(r);
2791  r->reset_delays_wait = wait;
2792  return ERROR_OK;
2793 }
2794 
2795 COMMAND_HANDLER(riscv_set_ir)
2796 {
2797  if (CMD_ARGC != 2) {
2798  LOG_ERROR("Command takes exactly 2 arguments");
2800  }
2801 
2802  uint32_t value;
2803  COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], value);
2804 
2805  if (!strcmp(CMD_ARGV[0], "idcode"))
2806  buf_set_u32(ir_idcode, 0, 32, value);
2807  else if (!strcmp(CMD_ARGV[0], "dtmcs"))
2808  buf_set_u32(ir_dtmcontrol, 0, 32, value);
2809  else if (!strcmp(CMD_ARGV[0], "dmi"))
2810  buf_set_u32(ir_dbus, 0, 32, value);
2811  else
2812  return ERROR_FAIL;
2813 
2814  return ERROR_OK;
2815 }
2816 
2817 COMMAND_HANDLER(riscv_resume_order)
2818 {
2819  if (CMD_ARGC > 1) {
2820  LOG_ERROR("Command takes at most one argument");
2822  }
2823 
2824  if (!strcmp(CMD_ARGV[0], "normal")) {
2826  } else if (!strcmp(CMD_ARGV[0], "reversed")) {
2828  } else {
2829  LOG_ERROR("Unsupported resume order: %s", CMD_ARGV[0]);
2830  return ERROR_FAIL;
2831  }
2832 
2833  return ERROR_OK;
2834 }
2835 
2836 COMMAND_HANDLER(riscv_use_bscan_tunnel)
2837 {
2838  int irwidth = 0;
2839  int tunnel_type = BSCAN_TUNNEL_NESTED_TAP;
2840 
2841  if (CMD_ARGC > 2) {
2842  LOG_ERROR("Command takes at most two arguments");
2844  } else if (CMD_ARGC == 1) {
2845  COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], irwidth);
2846  } else if (CMD_ARGC == 2) {
2847  COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], irwidth);
2848  COMMAND_PARSE_NUMBER(int, CMD_ARGV[1], tunnel_type);
2849  }
2850  if (tunnel_type == BSCAN_TUNNEL_NESTED_TAP)
2851  LOG_INFO("Nested Tap based Bscan Tunnel Selected");
2852  else if (tunnel_type == BSCAN_TUNNEL_DATA_REGISTER)
2853  LOG_INFO("Simple Register based Bscan Tunnel Selected");
2854  else
2855  LOG_INFO("Invalid Tunnel type selected ! : selecting default Nested Tap Type");
2856 
2857  bscan_tunnel_type = tunnel_type;
2858  bscan_tunnel_ir_width = irwidth;
2859  return ERROR_OK;
2860 }
2861 
2862 COMMAND_HANDLER(riscv_set_enable_virt2phys)
2863 {
2864  if (CMD_ARGC != 1) {
2865  LOG_ERROR("Command takes exactly 1 parameter");
2867  }
2869  return ERROR_OK;
2870 }
2871 
2872 COMMAND_HANDLER(riscv_set_ebreakm)
2873 {
2874  if (CMD_ARGC != 1) {
2875  LOG_ERROR("Command takes exactly 1 parameter");
2877  }
2879  return ERROR_OK;
2880 }
2881 
2882 COMMAND_HANDLER(riscv_set_ebreaks)
2883 {
2884  if (CMD_ARGC != 1) {
2885  LOG_ERROR("Command takes exactly 1 parameter");
2887  }
2889  return ERROR_OK;
2890 }
2891 
2892 COMMAND_HANDLER(riscv_set_ebreaku)
2893 {
2894  if (CMD_ARGC != 1) {
2895  LOG_ERROR("Command takes exactly 1 parameter");
2897  }
2899  return ERROR_OK;
2900 }
2901 
2902 COMMAND_HELPER(riscv_print_info_line, const char *section, const char *key,
2903  unsigned int value)
2904 {
2905  char full_key[80];
2906  snprintf(full_key, sizeof(full_key), "%s.%s", section, key);
2907  command_print(CMD, "%-21s %3d", full_key, value);
2908  return 0;
2909 }
2910 
2911 COMMAND_HANDLER(handle_info)
2912 {
2914  RISCV_INFO(r);
2915 
2916  /* This output format can be fed directly into TCL's "array set". */
2917 
2918  riscv_print_info_line(CMD, "hart", "xlen", riscv_xlen(target));
2920  riscv_print_info_line(CMD, "hart", "trigger_count",
2921  r->trigger_count);
2922 
2923  if (r->print_info)
2924  return CALL_COMMAND_HANDLER(r->print_info, target);
2925 
2926  return 0;
2927 }
2928 
2929 static const struct command_registration riscv_exec_command_handlers[] = {
2930  {
2931  .name = "info",
2932  .handler = handle_info,
2933  .mode = COMMAND_EXEC,
2934  .usage = "",
2935  .help = "Displays some information OpenOCD detected about the target."
2936  },
2937  {
2938  .name = "set_command_timeout_sec",
2939  .handler = riscv_set_command_timeout_sec,
2940  .mode = COMMAND_ANY,
2941  .usage = "[sec]",
2942  .help = "Set the wall-clock timeout (in seconds) for individual commands"
2943  },
2944  {
2945  .name = "set_reset_timeout_sec",
2946  .handler = riscv_set_reset_timeout_sec,
2947  .mode = COMMAND_ANY,
2948  .usage = "[sec]",
2949  .help = "Set the wall-clock timeout (in seconds) after reset is deasserted"
2950  },
2951  {
2952  .name = "set_prefer_sba",
2953  .handler = riscv_set_prefer_sba,
2954  .mode = COMMAND_ANY,
2955  .usage = "on|off",
2956  .help = "When on, prefer to use System Bus Access to access memory. "
2957  "When off (default), prefer to use the Program Buffer to access memory."
2958  },
2959  {
2960  .name = "set_mem_access",
2961  .handler = riscv_set_mem_access,
2962  .mode = COMMAND_ANY,
2963  .usage = "method1 [method2] [method3]",
2964  .help = "Set which memory access methods shall be used and in which order "
2965  "of priority. Method can be one of: 'progbuf', 'sysbus' or 'abstract'."
2966  },
2967  {
2968  .name = "set_enable_virtual",
2969  .handler = riscv_set_enable_virtual,
2970  .mode = COMMAND_ANY,
2971  .usage = "on|off",
2972  .help = "When on, memory accesses are performed on physical or virtual "
2973  "memory depending on the current system configuration. "
2974  "When off (default), all memory accessses are performed on physical memory."
2975  },
2976  {
2977  .name = "expose_csrs",
2978  .handler = riscv_set_expose_csrs,
2979  .mode = COMMAND_CONFIG,
2980  .usage = "n0[-m0|=name0][,n1[-m1|=name1]]...",
2981  .help = "Configure a list of inclusive ranges for CSRs to expose in "
2982  "addition to the standard ones. This must be executed before "
2983  "`init`."
2984  },
2985  {
2986  .name = "expose_custom",
2987  .handler = riscv_set_expose_custom,
2988  .mode = COMMAND_CONFIG,
2989  .usage = "n0[-m0|=name0][,n1[-m1|=name1]]...",
2990  .help = "Configure a list of inclusive ranges for custom registers to "
2991  "expose. custom0 is accessed as abstract register number 0xc000, "
2992  "etc. This must be executed before `init`."
2993  },
2994  {
2995  .name = "authdata_read",
2996  .handler = riscv_authdata_read,
2997  .usage = "[index]",
2998  .mode = COMMAND_ANY,
2999  .help = "Return the 32-bit value read from authdata or authdata0 "
3000  "(index=0), or authdata1 (index=1)."
3001  },
3002  {
3003  .name = "authdata_write",
3004  .handler = riscv_authdata_write,
3005  .mode = COMMAND_ANY,
3006  .usage = "[index] value",
3007  .help = "Write the 32-bit value to authdata or authdata0 (index=0), "
3008  "or authdata1 (index=1)."
3009  },
3010  {
3011  .name = "dmi_read",
3012  .handler = riscv_dmi_read,
3013  .mode = COMMAND_ANY,
3014  .usage = "address",
3015  .help = "Perform a 32-bit DMI read at address, returning the value."
3016  },
3017  {
3018  .name = "dmi_write",
3019  .handler = riscv_dmi_write,
3020  .mode = COMMAND_ANY,
3021  .usage = "address value",
3022  .help = "Perform a 32-bit DMI write of value at address."
3023  },
3024  {
3025  .name = "test_sba_config_reg",
3026  .handler = riscv_test_sba_config_reg,
3027  .mode = COMMAND_ANY,
3028  .usage = "legal_address num_words "
3029  "illegal_address run_sbbusyerror_test[on/off]",
3030  .help = "Perform a series of tests on the SBCS register. "
3031  "Inputs are a legal, 128-byte aligned address and a number of words to "
3032  "read/write starting at that address (i.e., address range [legal address, "
3033  "legal_address+word_size*num_words) must be legally readable/writable), "
3034  "an illegal, 128-byte aligned address for error flag/handling cases, "
3035  "and whether sbbusyerror test should be run."
3036  },
3037  {
3038  .name = "reset_delays",
3039  .handler = riscv_reset_delays,
3040  .mode = COMMAND_ANY,
3041  .usage = "[wait]",
3042  .help = "OpenOCD learns how many Run-Test/Idle cycles are required "
3043  "between scans to avoid encountering the target being busy. This "
3044  "command resets those learned values after `wait` scans. It's only "
3045  "useful for testing OpenOCD itself."
3046  },
3047  {
3048  .name = "resume_order",
3049  .handler = riscv_resume_order,
3050  .mode = COMMAND_ANY,
3051  .usage = "normal|reversed",
3052  .help = "Choose the order that harts are resumed in when `hasel` is not "
3053  "supported. Normal order is from lowest hart index to highest. "
3054  "Reversed order is from highest hart index to lowest."
3055  },
3056  {
3057  .name = "set_ir",
3058  .handler = riscv_set_ir,
3059  .mode = COMMAND_ANY,
3060  .usage = "[idcode|dtmcs|dmi] value",
3061  .help = "Set IR value for specified JTAG register."
3062  },
3063  {
3064  .name = "use_bscan_tunnel",
3065  .handler = riscv_use_bscan_tunnel,
3066  .mode = COMMAND_ANY,
3067  .usage = "value [type]",
3068  .help = "Enable or disable use of a BSCAN tunnel to reach DM. Supply "
3069  "the width of the DM transport TAP's instruction register to "
3070  "enable. Supply a value of 0 to disable. Pass A second argument "
3071  "(optional) to indicate Bscan Tunnel Type {0:(default) NESTED_TAP , "
3072  "1: DATA_REGISTER}"
3073  },
3074  {
3075  .name = "set_enable_virt2phys",
3076  .handler = riscv_set_enable_virt2phys,
3077  .mode = COMMAND_ANY,
3078  .usage = "on|off",
3079  .help = "When on (default), enable translation from virtual address to "
3080  "physical address."
3081  },
3082  {
3083  .name = "set_ebreakm",
3084  .handler = riscv_set_ebreakm,
3085  .mode = COMMAND_ANY,
3086  .usage = "on|off",
3087  .help = "Control dcsr.ebreakm. When off, M-mode ebreak instructions "
3088  "don't trap to OpenOCD. Defaults to on."
3089  },
3090  {
3091  .name = "set_ebreaks",
3092  .handler = riscv_set_ebreaks,
3093  .mode = COMMAND_ANY,
3094  .usage = "on|off",
3095  .help = "Control dcsr.ebreaks. When off, S-mode ebreak instructions "
3096  "don't trap to OpenOCD. Defaults to on."
3097  },
3098  {
3099  .name = "set_ebreaku",
3100  .handler = riscv_set_ebreaku,
3101  .mode = COMMAND_ANY,
3102  .usage = "on|off",
3103  .help = "Control dcsr.ebreaku. When off, U-mode ebreak instructions "
3104  "don't trap to OpenOCD. Defaults to on."
3105  },
3107 };
3108 
3109 /*
3110  * To be noted that RISC-V targets use the same semihosting commands as
3111  * ARM targets.
3112  *
3113  * The main reason is compatibility with existing tools. For example the
3114  * Eclipse OpenOCD/SEGGER J-Link/QEMU plug-ins have several widgets to
3115  * configure semihosting, which generate commands like `arm semihosting
3116  * enable`.
3117  * A secondary reason is the fact that the protocol used is exactly the
3118  * one specified by ARM. If RISC-V will ever define its own semihosting
3119  * protocol, then a command like `riscv semihosting enable` will make
3120  * sense, but for now all semihosting commands are prefixed with `arm`.
3121  */
3122 
3123 static const struct command_registration riscv_command_handlers[] = {
3124  {
3125  .name = "riscv",
3126  .mode = COMMAND_ANY,
3127  .help = "RISC-V Command Group",
3128  .usage = "",
3130  },
3131  {
3132  .name = "arm",
3133  .mode = COMMAND_ANY,
3134  .help = "ARM Command Group",
3135  .usage = "",
3137  },
3139 };
3140 
3141 static unsigned riscv_xlen_nonconst(struct target *target)
3142 {
3143  return riscv_xlen(target);
3144 }
3145 
3146 static unsigned int riscv_data_bits(struct target *target)
3147 {
3148  RISCV_INFO(r);
3149  if (r->data_bits)
3150  return r->data_bits(target);
3151  return riscv_xlen(target);
3152 }
3153 
3154 struct target_type riscv_target = {
3155  .name = "riscv",
3156 
3157  .target_create = riscv_create_target,
3158  .init_target = riscv_init_target,
3159  .deinit_target = riscv_deinit_target,
3160  .examine = riscv_examine,
3161 
3162  /* poll current target status */
3163  .poll = old_or_new_riscv_poll,
3164 
3165  .halt = riscv_halt,
3166  .resume = riscv_target_resume,
3167  .step = old_or_new_riscv_step,
3168 
3169  .assert_reset = riscv_assert_reset,
3170  .deassert_reset = riscv_deassert_reset,
3171 
3172  .read_memory = riscv_read_memory,
3173  .write_memory = riscv_write_memory,
3174  .read_phys_memory = riscv_read_phys_memory,
3175  .write_phys_memory = riscv_write_phys_memory,
3176 
3177  .checksum_memory = riscv_checksum_memory,
3178 
3179  .mmu = riscv_mmu,
3180  .virt2phys = riscv_virt2phys,
3181 
3182  .get_gdb_arch = riscv_get_gdb_arch,
3183  .get_gdb_reg_list = riscv_get_gdb_reg_list,
3184  .get_gdb_reg_list_noread = riscv_get_gdb_reg_list_noread,
3185 
3186  .add_breakpoint = riscv_add_breakpoint,
3187  .remove_breakpoint = riscv_remove_breakpoint,
3188 
3189  .add_watchpoint = riscv_add_watchpoint,
3190  .remove_watchpoint = riscv_remove_watchpoint,
3191  .hit_watchpoint = riscv_hit_watchpoint,
3192 
3193  .arch_state = riscv_arch_state,
3194 
3195  .run_algorithm = riscv_run_algorithm,
3196 
3197  .commands = riscv_command_handlers,
3198 
3199  .address_bits = riscv_xlen_nonconst,
3200  .data_bits = riscv_data_bits
3201 };
3202 
3203 /*** RISC-V Interface ***/
3204 
3205 /* Initializes the shared RISC-V structure. */
3206 static void riscv_info_init(struct target *target, struct riscv_info *r)
3207 {
3208  memset(r, 0, sizeof(*r));
3209 
3211 
3212  r->dtm_version = 1;
3214  r->version_specific = NULL;
3215 
3216  memset(r->trigger_unique_id, 0xff, sizeof(r->trigger_unique_id));
3217 
3218  r->xlen = -1;
3219 
3223 
3224  r->mem_access_progbuf_warn = true;
3225  r->mem_access_sysbus_warn = true;
3226  r->mem_access_abstract_warn = true;
3227 
3230 }
3231 
3233 {
3234  RISCV_INFO(r);
3235 
3236  LOG_DEBUG("[%s] resuming hart", target_name(target));
3238  return ERROR_FAIL;
3239  if (riscv_is_halted(target)) {
3240  if (r->resume_go(target) != ERROR_OK)
3241  return ERROR_FAIL;
3242  } else {
3243  LOG_DEBUG("[%s] hart requested resume, but was already resumed",
3244  target_name(target));
3245  }
3246 
3248  return ERROR_OK;
3249 }
3250 
3251 /* Steps the hart that's currently selected in the RTOS, or if there is no RTOS
3252  * then the only hart. */
3254 {
3255  RISCV_INFO(r);
3257  return ERROR_FAIL;
3258  LOG_DEBUG("[%s] stepping", target_name(target));
3259 
3260  if (!riscv_is_halted(target)) {
3261  LOG_ERROR("Hart isn't halted before single step!");
3262  return ERROR_FAIL;
3263  }
3265  r->on_step(target);
3266  if (r->step_current_hart(target) != ERROR_OK)
3267  return ERROR_FAIL;
3269  r->on_halt(target);
3270  if (!riscv_is_halted(target)) {
3271  LOG_ERROR("Hart was not halted after single step!");
3272  return ERROR_FAIL;
3273  }
3274  return ERROR_OK;
3275 }
3276 
3277 bool riscv_supports_extension(struct target *target, char letter)
3278 {
3279  RISCV_INFO(r);
3280  unsigned num;
3281  if (letter >= 'a' && letter <= 'z')
3282  num = letter - 'a';
3283  else if (letter >= 'A' && letter <= 'Z')
3284  num = letter - 'A';
3285  else
3286  return false;
3287  return r->misa & BIT(num);
3288 }
3289 
3290 unsigned riscv_xlen(const struct target *target)
3291 {
3292  RISCV_INFO(r);
3293  return r->xlen;
3294 }
3295 
3296 int riscv_set_current_hartid(struct target *target, int hartid)
3297 {
3298  RISCV_INFO(r);
3299  if (!r->select_current_hart)
3300  return ERROR_OK;
3301 
3302  int previous_hartid = riscv_current_hartid(target);
3303  r->current_hartid = hartid;
3304  LOG_DEBUG("setting hartid to %d, was %d", hartid, previous_hartid);
3305  if (r->select_current_hart(target) != ERROR_OK)
3306  return ERROR_FAIL;
3307 
3308  return ERROR_OK;
3309 }
3310 
3311 /* Invalidates the register cache. */
3313 {
3314  LOG_DEBUG("[%d]", target->coreid);
3316  for (size_t i = 0; i < target->reg_cache->num_regs; ++i) {
3317  struct reg *reg = &target->reg_cache->reg_list[i];
3318  reg->valid = false;
3319  }
3320 }
3321 
3323 {
3324  RISCV_INFO(r);
3325  return r->current_hartid;
3326 }
3327 
3329 {
3330  if (!target)
3331  return 1;
3332  RISCV_INFO(r);
3333  if (!r || !r->hart_count)
3334  return 1;
3335  return r->hart_count(target);
3336 }
3337 
3346 static bool gdb_regno_cacheable(enum gdb_regno regno, bool write)
3347 {
3348  /* GPRs, FPRs, vector registers are just normal data stores. */
3349  if (regno <= GDB_REGNO_XPR31 ||
3350  (regno >= GDB_REGNO_FPR0 && regno <= GDB_REGNO_FPR31) ||
3351  (regno >= GDB_REGNO_V0 && regno <= GDB_REGNO_V31))
3352  return true;
3353 
3354  /* Most CSRs won't change value on us, but we can't assume it about arbitrary
3355  * CSRs. */
3356  switch (regno) {
3357  case GDB_REGNO_DPC:
3358  return true;
3359 
3360  case GDB_REGNO_VSTART:
3361  case GDB_REGNO_VXSAT:
3362  case GDB_REGNO_VXRM:
3363  case GDB_REGNO_VLENB:
3364  case GDB_REGNO_VL:
3365  case GDB_REGNO_VTYPE:
3366  case GDB_REGNO_MISA:
3367  case GDB_REGNO_DCSR:
3368  case GDB_REGNO_DSCRATCH0:
3369  case GDB_REGNO_MSTATUS:
3370  case GDB_REGNO_MEPC:
3371  case GDB_REGNO_MCAUSE:
3372  case GDB_REGNO_SATP:
3373  /*
3374  * WARL registers might not contain the value we just wrote, but
3375  * these ones won't spontaneously change their value either. *
3376  */
3377  return !write;
3378 
3379  case GDB_REGNO_TSELECT: /* I think this should be above, but then it doesn't work. */
3380  case GDB_REGNO_TDATA1: /* Changes value when tselect is changed. */
3381  case GDB_REGNO_TDATA2: /* Changse value when tselect is changed. */
3382  default:
3383  return false;
3384  }
3385 }
3386 
3392 {
3393  RISCV_INFO(r);
3394  LOG_DEBUG("[%s] %s <- %" PRIx64, target_name(target), gdb_regno_name(regid), value);
3395  assert(r->set_register);
3396 
3397  keep_alive();
3398 
3399  /* TODO: Hack to deal with gdb that thinks these registers still exist. */
3400  if (regid > GDB_REGNO_XPR15 && regid <= GDB_REGNO_XPR31 && value == 0 &&
3402  return ERROR_OK;
3403 
3404  struct reg *reg = &target->reg_cache->reg_list[regid];
3405  buf_set_u64(reg->value, 0, reg->size, value);
3406 
3407  int result = r->set_register(target, regid, value);
3408  if (result == ERROR_OK)
3409  reg->valid = gdb_regno_cacheable(regid, true);
3410  else
3411  reg->valid = false;
3412  LOG_DEBUG("[%s] wrote 0x%" PRIx64 " to %s valid=%d",
3414  return result;
3415 }
3416 
3418  enum gdb_regno regid)
3419 {
3420  RISCV_INFO(r);
3421 
3422  keep_alive();
3423 
3424  struct reg *reg = &target->reg_cache->reg_list[regid];
3425  if (!reg->exist) {
3426  LOG_DEBUG("[%s] %s does not exist.",
3427  target_name(target), gdb_regno_name(regid));
3428  return ERROR_FAIL;
3429  }
3430 
3431  if (reg && reg->valid) {
3432  *value = buf_get_u64(reg->value, 0, reg->size);
3433  LOG_DEBUG("[%s] %s: %" PRIx64 " (cached)", target_name(target),
3434  gdb_regno_name(regid), *value);
3435  return ERROR_OK;
3436  }
3437 
3438  /* TODO: Hack to deal with gdb that thinks these registers still exist. */
3439  if (regid > GDB_REGNO_XPR15 && regid <= GDB_REGNO_XPR31 &&
3441  *value = 0;
3442  return ERROR_OK;
3443  }
3444 
3445  int result = r->get_register(target, value, regid);
3446 
3447  if (result == ERROR_OK)
3448  reg->valid = gdb_regno_cacheable(regid, false);
3449 
3450  LOG_DEBUG("[%s] %s: %" PRIx64, target_name(target),
3451  gdb_regno_name(regid), *value);
3452  return result;
3453 }
3454 
3456 {
3457  RISCV_INFO(r);
3458  assert(r->is_halted);
3459  return r->is_halted(target);
3460 }
3461 
3462 static enum riscv_halt_reason riscv_halt_reason(struct target *target, int hartid)
3463 {
3464  RISCV_INFO(r);
3465  if (riscv_set_current_hartid(target, hartid) != ERROR_OK)
3466  return RISCV_HALT_ERROR;
3467  if (!riscv_is_halted(target)) {
3468  LOG_ERROR("Hart is not halted!");
3469  return RISCV_HALT_UNKNOWN;
3470  }
3471  return r->halt_reason(target);
3472 }
3473 
3475 {
3476  RISCV_INFO(r);
3477  return r->debug_buffer_size;
3478 }
3479 
3481 {
3482  RISCV_INFO(r);
3483  r->write_debug_buffer(target, index, insn);
3484  return ERROR_OK;
3485 }
3486 
3488 {
3489  RISCV_INFO(r);
3490  return r->read_debug_buffer(target, index);
3491 }
3492 
3494 {
3495  RISCV_INFO(r);
3496  return r->execute_debug_buffer(target);
3497 }
3498 
3499 void riscv_fill_dmi_write_u64(struct target *target, char *buf, int a, uint64_t d)
3500 {
3501  RISCV_INFO(r);
3502  r->fill_dmi_write_u64(target, buf, a, d);
3503 }
3504 
3505 void riscv_fill_dmi_read_u64(struct target *target, char *buf, int a)
3506 {
3507  RISCV_INFO(r);
3508  r->fill_dmi_read_u64(target, buf, a);
3509 }
3510 
3511 void riscv_fill_dmi_nop_u64(struct target *target, char *buf)
3512 {
3513  RISCV_INFO(r);
3514  r->fill_dmi_nop_u64(target, buf);
3515 }
3516 
3518 {
3519  RISCV_INFO(r);
3520  return r->dmi_write_u64_bits(target);
3521 }
3522 
3531 {
3532  RISCV_INFO(r);
3533 
3534  if (r->triggers_enumerated)
3535  return ERROR_OK;
3536 
3537  r->triggers_enumerated = true; /* At the very least we tried. */
3538 
3539  riscv_reg_t tselect;
3540  int result = riscv_get_register(target, &tselect, GDB_REGNO_TSELECT);
3541  /* If tselect is not readable, the trigger module is likely not
3542  * implemented. There are no triggers to enumerate then and no error
3543  * should be thrown. */
3544  if (result != ERROR_OK) {
3545  LOG_DEBUG("[%s] Cannot access tselect register. "
3546  "Assuming that triggers are not implemented.", target_name(target));
3547  r->trigger_count = 0;
3548  return ERROR_OK;
3549  }
3550 
3551  for (unsigned int t = 0; t < RISCV_MAX_TRIGGERS; ++t) {
3552  r->trigger_count = t;
3553 
3554  /* If we can't write tselect, then this hart does not support triggers. */
3556  break;
3557  uint64_t tselect_rb;
3558  result = riscv_get_register(target, &tselect_rb, GDB_REGNO_TSELECT);
3559  if (result != ERROR_OK)
3560  return result;
3561  /* Mask off the top bit, which is used as tdrmode in old
3562  * implementations. */
3563  tselect_rb &= ~(1ULL << (riscv_xlen(target) - 1));
3564  if (tselect_rb != t)
3565  break;
3566  uint64_t tdata1;
3567  result = riscv_get_register(target, &tdata1, GDB_REGNO_TDATA1);
3568  if (result != ERROR_OK)
3569  return result;
3570 
3571  int type = get_field(tdata1, MCONTROL_TYPE(riscv_xlen(target)));
3572  if (type == 0)
3573  break;
3574  switch (type) {
3575  case 1:
3576  /* On these older cores we don't support software using
3577  * triggers. */
3579  break;
3580  case 2:
3581  if (tdata1 & MCONTROL_DMODE(riscv_xlen(target)))
3583  break;
3584  case 6:
3585  if (tdata1 & MCONTROL_DMODE(riscv_xlen(target)))
3587  break;
3588  }
3589  }
3590 
3592 
3593  LOG_INFO("[%s] Found %d triggers", target_name(target), r->trigger_count);
3594 
3595  return ERROR_OK;
3596 }
3597 
3598 const char *gdb_regno_name(enum gdb_regno regno)
3599 {
3600  static char buf[32];
3601 
3602  switch (regno) {
3603  case GDB_REGNO_ZERO:
3604  return "zero";
3605  case GDB_REGNO_RA:
3606  return "ra";
3607  case GDB_REGNO_SP:
3608  return "sp";
3609  case GDB_REGNO_GP:
3610  return "gp";
3611  case GDB_REGNO_TP:
3612  return "tp";
3613  case GDB_REGNO_T0:
3614  return "t0";
3615  case GDB_REGNO_T1:
3616  return "t1";
3617  case GDB_REGNO_T2:
3618  return "t2";
3619  case GDB_REGNO_S0:
3620  return "s0";
3621  case GDB_REGNO_S1:
3622  return "s1";
3623  case GDB_REGNO_A0:
3624  return "a0";
3625  case GDB_REGNO_A1:
3626  return "a1";
3627  case GDB_REGNO_A2:
3628  return "a2";
3629  case GDB_REGNO_A3:
3630  return "a3";
3631  case GDB_REGNO_A4:
3632  return "a4";
3633  case GDB_REGNO_A5:
3634  return "a5";
3635  case GDB_REGNO_A6:
3636  return "a6";
3637  case GDB_REGNO_A7:
3638  return "a7";
3639  case GDB_REGNO_S2:
3640  return "s2";
3641  case GDB_REGNO_S3:
3642  return "s3";
3643  case GDB_REGNO_S4:
3644  return "s4";
3645  case GDB_REGNO_S5:
3646  return "s5";
3647  case GDB_REGNO_S6:
3648  return "s6";
3649  case GDB_REGNO_S7:
3650  return "s7";
3651  case GDB_REGNO_S8:
3652  return "s8";
3653  case GDB_REGNO_S9:
3654  return "s9";
3655  case GDB_REGNO_S10:
3656  return "s10";
3657  case GDB_REGNO_S11:
3658  return "s11";
3659  case GDB_REGNO_T3:
3660  return "t3";
3661  case GDB_REGNO_T4:
3662  return "t4";
3663  case GDB_REGNO_T5:
3664  return "t5";
3665  case GDB_REGNO_T6:
3666  return "t6";
3667  case GDB_REGNO_PC:
3668  return "pc";
3669  case GDB_REGNO_FPR0:
3670  return "fpr0";
3671  case GDB_REGNO_FPR31:
3672  return "fpr31";
3673  case GDB_REGNO_CSR0:
3674  return "csr0";
3675  case GDB_REGNO_TSELECT:
3676  return "tselect";
3677  case GDB_REGNO_TDATA1:
3678  return "tdata1";
3679  case GDB_REGNO_TDATA2:
3680  return "tdata2";
3681  case GDB_REGNO_MISA:
3682  return "misa";
3683  case GDB_REGNO_DPC:
3684  return "dpc";
3685  case GDB_REGNO_DCSR:
3686  return "dcsr";
3687  case GDB_REGNO_DSCRATCH0:
3688  return "dscratch0";
3689  case GDB_REGNO_MSTATUS:
3690  return "mstatus";
3691  case GDB_REGNO_MEPC:
3692  return "mepc";
3693  case GDB_REGNO_MCAUSE:
3694  return "mcause";
3695  case GDB_REGNO_PRIV:
3696  return "priv";
3697  case GDB_REGNO_SATP:
3698  return "satp";
3699  case GDB_REGNO_VTYPE:
3700  return "vtype";
3701  case GDB_REGNO_VL:
3702  return "vl";
3703  case GDB_REGNO_V0:
3704  return "v0";
3705  case GDB_REGNO_V1:
3706  return "v1";
3707  case GDB_REGNO_V2:
3708  return "v2";
3709  case GDB_REGNO_V3:
3710  return "v3";
3711  case GDB_REGNO_V4:
3712  return "v4";
3713  case GDB_REGNO_V5:
3714  return "v5";
3715  case GDB_REGNO_V6:
3716  return "v6";
3717  case GDB_REGNO_V7:
3718  return "v7";
3719  case GDB_REGNO_V8:
3720  return "v8";
3721  case GDB_REGNO_V9:
3722  return "v9";
3723  case GDB_REGNO_V10:
3724  return "v10";
3725  case GDB_REGNO_V11:
3726  return "v11";
3727  case GDB_REGNO_V12:
3728  return "v12";
3729  case GDB_REGNO_V13:
3730  return "v13";
3731  case GDB_REGNO_V14:
3732  return "v14";
3733  case GDB_REGNO_V15:
3734  return "v15";
3735  case GDB_REGNO_V16:
3736  return "v16";
3737  case GDB_REGNO_V17:
3738  return "v17";
3739  case GDB_REGNO_V18:
3740  return "v18";
3741  case GDB_REGNO_V19:
3742  return "v19";
3743  case GDB_REGNO_V20:
3744  return "v20";
3745  case GDB_REGNO_V21:
3746  return "v21";
3747  case GDB_REGNO_V22:
3748  return "v22";
3749  case GDB_REGNO_V23:
3750  return "v23";
3751  case GDB_REGNO_V24:
3752  return "v24";
3753  case GDB_REGNO_V25:
3754  return "v25";
3755  case GDB_REGNO_V26:
3756  return "v26";
3757  case GDB_REGNO_V27:
3758  return "v27";
3759  case GDB_REGNO_V28:
3760  return "v28";
3761  case GDB_REGNO_V29:
3762  return "v29";
3763  case GDB_REGNO_V30:
3764  return "v30";
3765  case GDB_REGNO_V31:
3766  return "v31";
3767  default:
3768  if (regno <= GDB_REGNO_XPR31)
3769  sprintf(buf, "x%d", regno - GDB_REGNO_ZERO);
3770  else if (regno >= GDB_REGNO_CSR0 && regno <= GDB_REGNO_CSR4095)
3771  sprintf(buf, "csr%d", regno - GDB_REGNO_CSR0);
3772  else if (regno >= GDB_REGNO_FPR0 && regno <= GDB_REGNO_FPR31)
3773  sprintf(buf, "f%d", regno - GDB_REGNO_FPR0);
3774  else
3775  sprintf(buf, "gdb_regno_%d", regno);
3776  return buf;
3777  }
3778 }
3779 
3780 static int register_get(struct reg *reg)
3781 {
3782  riscv_reg_info_t *reg_info = reg->arch_info;
3783  struct target *target = reg_info->target;
3784  RISCV_INFO(r);
3785 
3786  if (reg->number >= GDB_REGNO_V0 && reg->number <= GDB_REGNO_V31) {
3787  if (!r->get_register_buf) {
3788  LOG_ERROR("Reading register %s not supported on this RISC-V target.",
3790  return ERROR_FAIL;
3791  }
3792 
3793  if (r->get_register_buf(target, reg->value, reg->number) != ERROR_OK)
3794  return ERROR_FAIL;
3795  } else {
3796  uint64_t value;
3797  int result = riscv_get_register(target, &value, reg->number);
3798  if (result != ERROR_OK)
3799  return result;
3800  buf_set_u64(reg->value, 0, reg->size, value);
3801  }
3802  reg->valid = gdb_regno_cacheable(reg->number, false);
3803  char *str = buf_to_hex_str(reg->value, reg->size);
3804  LOG_DEBUG("[%s] read 0x%s from %s (valid=%d)", target_name(target),
3805  str, reg->name, reg->valid);
3806  free(str);
3807  return ERROR_OK;
3808 }
3809 
3810 static int register_set(struct reg *reg, uint8_t *buf)
3811 {
3812  riscv_reg_info_t *reg_info = reg->arch_info;
3813  struct target *target = reg_info->target;
3814  RISCV_INFO(r);
3815 
3816  char *str = buf_to_hex_str(buf, reg->size);
3817  LOG_DEBUG("[%s] write 0x%s to %s (valid=%d)", target_name(target),
3818  str, reg->name, reg->valid);
3819  free(str);
3820 
3821  /* Exit early for writing x0, which on the hardware would be ignored, and we
3822  * don't want to update our cache. */
3823  if (reg->number == GDB_REGNO_ZERO)
3824  return ERROR_OK;
3825 
3826  memcpy(reg->value, buf, DIV_ROUND_UP(reg->size, 8));
3827  reg->valid = gdb_regno_cacheable(reg->number, true);
3828 
3829  if (reg->number == GDB_REGNO_TDATA1 ||
3830  reg->number == GDB_REGNO_TDATA2) {
3831  r->manual_hwbp_set = true;
3832  /* When enumerating triggers, we clear any triggers with DMODE set,
3833  * assuming they were left over from a previous debug session. So make
3834  * sure that is done before a user might be setting their own triggers.
3835  */
3837  return ERROR_FAIL;
3838  }
3839 
3840  if (reg->number >= GDB_REGNO_V0 && reg->number <= GDB_REGNO_V31) {
3841  if (!r->set_register_buf) {
3842  LOG_ERROR("Writing register %s not supported on this RISC-V target.",
3844  return ERROR_FAIL;
3845  }
3846 
3847  if (r->set_register_buf(target, reg->number, reg->value) != ERROR_OK)
3848  return ERROR_FAIL;
3849  } else {
3850  uint64_t value = buf_get_u64(buf, 0, reg->size);
3851  if (riscv_set_register(target, reg->number, value) != ERROR_OK)
3852  return ERROR_FAIL;
3853  }
3854 
3855  return ERROR_OK;
3856 }
3857 
3858 static struct reg_arch_type riscv_reg_arch_type = {
3859  .get = register_get,
3860  .set = register_set
3861 };
3862 
3863 struct csr_info {
3864  unsigned number;
3865  const char *name;
3866 };
3867 
3868 static int cmp_csr_info(const void *p1, const void *p2)
3869 {
3870  return (int) (((struct csr_info *)p1)->number) - (int) (((struct csr_info *)p2)->number);
3871 }
3872 
3874 {
3875  RISCV_INFO(info);
3876 
3878 
3879  target->reg_cache = calloc(1, sizeof(*target->reg_cache));
3880  if (!target->reg_cache)
3881  return ERROR_FAIL;
3882  target->reg_cache->name = "RISC-V Registers";
3884 
3885  if (!list_empty(&info->expose_custom)) {
3886  range_list_t *entry;
3887  list_for_each_entry(entry, &info->expose_custom, list)
3888  target->reg_cache->num_regs += entry->high - entry->low + 1;
3889  }
3890 
3891  LOG_DEBUG("create register cache for %d registers",
3893 
3895  calloc(target->reg_cache->num_regs, sizeof(struct reg));
3896  if (!target->reg_cache->reg_list)
3897  return ERROR_FAIL;
3898 
3899  const unsigned int max_reg_name_len = 12;
3900  free(info->reg_names);
3901  info->reg_names =
3902  calloc(target->reg_cache->num_regs, max_reg_name_len);
3903  if (!info->reg_names)
3904  return ERROR_FAIL;
3905  char *reg_name = info->reg_names;
3906 
3907  static struct reg_feature feature_cpu = {
3908  .name = "org.gnu.gdb.riscv.cpu"
3909  };
3910  static struct reg_feature feature_fpu = {
3911  .name = "org.gnu.gdb.riscv.fpu"
3912  };
3913  static struct reg_feature feature_csr = {
3914  .name = "org.gnu.gdb.riscv.csr"
3915  };
3916  static struct reg_feature feature_vector = {
3917  .name = "org.gnu.gdb.riscv.vector"
3918  };
3919  static struct reg_feature feature_virtual = {
3920  .name = "org.gnu.gdb.riscv.virtual"
3921  };
3922  static struct reg_feature feature_custom = {
3923  .name = "org.gnu.gdb.riscv.custom"
3924  };
3925 
3926  /* These types are built into gdb. */
3927  static struct reg_data_type type_ieee_single = { .type = REG_TYPE_IEEE_SINGLE, .id = "ieee_single" };
3928  static struct reg_data_type type_ieee_double = { .type = REG_TYPE_IEEE_DOUBLE, .id = "ieee_double" };
3929  static struct reg_data_type_union_field single_double_fields[] = {
3930  {"float", &type_ieee_single, single_double_fields + 1},
3931  {"double", &type_ieee_double, NULL},
3932  };
3933  static struct reg_data_type_union single_double_union = {
3934  .fields = single_double_fields
3935  };
3936  static struct reg_data_type type_ieee_single_double = {
3938  .id = "FPU_FD",
3939  .type_class = REG_TYPE_CLASS_UNION,
3940  .reg_type_union = &single_double_union
3941  };
3942  static struct reg_data_type type_uint8 = { .type = REG_TYPE_UINT8, .id = "uint8" };
3943  static struct reg_data_type type_uint16 = { .type = REG_TYPE_UINT16, .id = "uint16" };
3944  static struct reg_data_type type_uint32 = { .type = REG_TYPE_UINT32, .id = "uint32" };
3945  static struct reg_data_type type_uint64 = { .type = REG_TYPE_UINT64, .id = "uint64" };
3946  static struct reg_data_type type_uint128 = { .type = REG_TYPE_UINT128, .id = "uint128" };
3947 
3948  /* This is roughly the XML we want:
3949  * <vector id="bytes" type="uint8" count="16"/>
3950  * <vector id="shorts" type="uint16" count="8"/>
3951  * <vector id="words" type="uint32" count="4"/>
3952  * <vector id="longs" type="uint64" count="2"/>
3953  * <vector id="quads" type="uint128" count="1"/>
3954  * <union id="riscv_vector_type">
3955  * <field name="b" type="bytes"/>
3956  * <field name="s" type="shorts"/>
3957  * <field name="w" type="words"/>
3958  * <field name="l" type="longs"/>
3959  * <field name="q" type="quads"/>
3960  * </union>
3961  */
3962 
3963  info->vector_uint8.type = &type_uint8;
3964  info->vector_uint8.count = info->vlenb;
3965  info->type_uint8_vector.type = REG_TYPE_ARCH_DEFINED;
3966  info->type_uint8_vector.id = "bytes";
3967  info->type_uint8_vector.type_class = REG_TYPE_CLASS_VECTOR;
3968  info->type_uint8_vector.reg_type_vector = &info->vector_uint8;
3969 
3970  info->vector_uint16.type = &type_uint16;
3971  info->vector_uint16.count = info->vlenb / 2;
3972  info->type_uint16_vector.type = REG_TYPE_ARCH_DEFINED;
3973  info->type_uint16_vector.id = "shorts";
3974  info->type_uint16_vector.type_class = REG_TYPE_CLASS_VECTOR;
3975  info->type_uint16_vector.reg_type_vector = &info->vector_uint16;
3976 
3977  info->vector_uint32.type = &type_uint32;
3978  info->vector_uint32.count = info->vlenb / 4;
3979  info->type_uint32_vector.type = REG_TYPE_ARCH_DEFINED;
3980  info->type_uint32_vector.id = "words";
3981  info->type_uint32_vector.type_class = REG_TYPE_CLASS_VECTOR;
3982  info->type_uint32_vector.reg_type_vector = &info->vector_uint32;
3983 
3984  info->vector_uint64.type = &type_uint64;
3985  info->vector_uint64.count = info->vlenb / 8;
3986  info->type_uint64_vector.type = REG_TYPE_ARCH_DEFINED;
3987  info->type_uint64_vector.id = "longs";
3988  info->type_uint64_vector.type_class = REG_TYPE_CLASS_VECTOR;
3989  info->type_uint64_vector.reg_type_vector = &info->vector_uint64;
3990 
3991  info->vector_uint128.type = &type_uint128;
3992  info->vector_uint128.count = info->vlenb / 16;
3993  info->type_uint128_vector.type = REG_TYPE_ARCH_DEFINED;
3994  info->type_uint128_vector.id = "quads";
3995  info->type_uint128_vector.type_class = REG_TYPE_CLASS_VECTOR;
3996  info->type_uint128_vector.reg_type_vector = &info->vector_uint128;
3997 
3998  info->vector_fields[0].name = "b";
3999  info->vector_fields[0].type = &info->type_uint8_vector;
4000  if (info->vlenb >= 2) {
4001  info->vector_fields[0].next = info->vector_fields + 1;
4002  info->vector_fields[1].name = "s";
4003  info->vector_fields[1].type = &info->type_uint16_vector;
4004  } else {
4005  info->vector_fields[0].next = NULL;
4006  }
4007  if (info->vlenb >= 4) {
4008  info->vector_fields[1].next = info->vector_fields + 2;
4009  info->vector_fields[2].name = "w";
4010  info->vector_fields[2].type = &info->type_uint32_vector;
4011  } else {
4012  info->vector_fields[1].next = NULL;
4013  }
4014  if (info->vlenb >= 8) {
4015  info->vector_fields[2].next = info->vector_fields + 3;
4016  info->vector_fields[3].name = "l";
4017  info->vector_fields[3].type = &info->type_uint64_vector;
4018  } else {
4019  info->vector_fields[2].next = NULL;
4020  }
4021  if (info->vlenb >= 16) {
4022  info->vector_fields[3].next = info->vector_fields + 4;
4023  info->vector_fields[4].name = "q";
4024  info->vector_fields[4].type = &info->type_uint128_vector;
4025  } else {
4026  info->vector_fields[3].next = NULL;
4027  }
4028  info->vector_fields[4].next = NULL;
4029 
4030  info->vector_union.fields = info->vector_fields;
4031 
4032  info->type_vector.type = REG_TYPE_ARCH_DEFINED;
4033  info->type_vector.id = "riscv_vector";
4034  info->type_vector.type_class = REG_TYPE_CLASS_UNION;
4035  info->type_vector.reg_type_union = &info->vector_union;
4036 
4037  struct csr_info csr_info[] = {
4038 #define DECLARE_CSR(name, number) { number, #name },
4039 #include "encoding.h"
4040 #undef DECLARE_CSR
4041  };
4042  /* encoding.h does not contain the registers in sorted order. */
4043  qsort(csr_info, ARRAY_SIZE(csr_info), sizeof(*csr_info), cmp_csr_info);
4044  unsigned csr_info_index = 0;
4045 
4046  int custom_within_range = 0;
4047 
4048  riscv_reg_info_t *shared_reg_info = calloc(1, sizeof(riscv_reg_info_t));
4049  if (!shared_reg_info)
4050  return ERROR_FAIL;
4051  shared_reg_info->target = target;
4052 
4053  /* When gdb requests register N, gdb_get_register_packet() assumes that this
4054  * is register at index N in reg_list. So if there are certain registers
4055  * that don't exist, we need to leave holes in the list (or renumber, but
4056  * it would be nice not to have yet another set of numbers to translate
4057  * between). */
4058  for (uint32_t number = 0; number < target->reg_cache->num_regs; number++) {
4059  struct reg *r = &target->reg_cache->reg_list[number];
4060  r->dirty = false;
4061  r->valid = false;
4062  r->exist = true;
4063  r->type = &riscv_reg_arch_type;
4064  r->arch_info = shared_reg_info;
4065  r->number = number;
4066  r->size = riscv_xlen(target);
4067  /* r->size is set in riscv_invalidate_register_cache, maybe because the
4068  * target is in theory allowed to change XLEN on us. But I expect a lot
4069  * of other things to break in that case as well. */
4070  if (number <= GDB_REGNO_XPR31) {
4071  r->exist = number <= GDB_REGNO_XPR15 ||
4073  /* TODO: For now we fake that all GPRs exist because otherwise gdb
4074  * doesn't work. */
4075  r->exist = true;
4076  r->caller_save = true;
4077  switch (number) {
4078  case GDB_REGNO_ZERO:
4079  r->name = "zero";
4080  break;
4081  case GDB_REGNO_RA:
4082  r->name = "ra";
4083  break;
4084  case GDB_REGNO_SP:
4085  r->name = "sp";
4086  break;
4087  case GDB_REGNO_GP:
4088  r->name = "gp";
4089  break;
4090  case GDB_REGNO_TP:
4091  r->name = "tp";
4092  break;
4093  case GDB_REGNO_T0:
4094  r->name = "t0";
4095  break;
4096  case GDB_REGNO_T1:
4097  r->name = "t1";
4098  break;
4099  case GDB_REGNO_T2:
4100  r->name = "t2";
4101  break;
4102  case GDB_REGNO_FP:
4103  r->name = "fp";
4104  break;
4105  case GDB_REGNO_S1:
4106  r->name = "s1";
4107  break;
4108  case GDB_REGNO_A0:
4109  r->name = "a0";
4110  break;
4111  case GDB_REGNO_A1:
4112  r->name = "a1";
4113  break;
4114  case GDB_REGNO_A2:
4115  r->name = "a2";
4116  break;
4117  case GDB_REGNO_A3:
4118  r->name = "a3";
4119  break;
4120  case GDB_REGNO_A4:
4121  r->name = "a4";
4122  break;
4123  case GDB_REGNO_A5:
4124  r->name = "a5";
4125  break;
4126  case GDB_REGNO_A6:
4127  r->name = "a6";
4128  break;
4129  case GDB_REGNO_A7:
4130  r->name = "a7";
4131  break;
4132  case GDB_REGNO_S2:
4133  r->name = "s2";
4134  break;
4135  case GDB_REGNO_S3:
4136  r->name = "s3";
4137  break;
4138  case GDB_REGNO_S4:
4139  r->name = "s4";
4140  break;
4141  case GDB_REGNO_S5:
4142  r->name = "s5";
4143  break;
4144  case GDB_REGNO_S6:
4145  r->name = "s6";
4146  break;
4147  case GDB_REGNO_S7:
4148  r->name = "s7";
4149  break;
4150  case GDB_REGNO_S8:
4151  r->name = "s8";
4152  break;
4153  case GDB_REGNO_S9:
4154  r->name = "s9";
4155  break;
4156  case GDB_REGNO_S10:
4157  r->name = "s10";
4158  break;
4159  case GDB_REGNO_S11:
4160  r->name = "s11";
4161  break;
4162  case GDB_REGNO_T3:
4163  r->name = "t3";
4164  break;
4165  case GDB_REGNO_T4:
4166  r->name = "t4";
4167  break;
4168  case GDB_REGNO_T5:
4169  r->name = "t5";
4170  break;
4171  case GDB_REGNO_T6:
4172  r->name = "t6";
4173  break;
4174  }
4175  r->group = "general";
4176  r->feature = &feature_cpu;
4177  } else if (number == GDB_REGNO_PC) {
4178  r->caller_save = true;
4179  sprintf(reg_name, "pc");
4180  r->group = "general";
4181  r->feature = &feature_cpu;
4182  } else if (number >= GDB_REGNO_FPR0 && number <= GDB_REGNO_FPR31) {
4183  r->caller_save = true;
4184  if (riscv_supports_extension(target, 'D')) {
4185  r->size = 64;
4186  if (riscv_supports_extension(target, 'F'))
4187  r->reg_data_type = &type_ieee_single_double;
4188  else
4189  r->reg_data_type = &type_ieee_double;
4190  } else if (riscv_supports_extension(target, 'F')) {
4191  r->reg_data_type = &type_ieee_single;
4192  r->size = 32;
4193  } else {
4194  r->exist = false;
4195  }
4196  switch (number) {
4197  case GDB_REGNO_FT0:
4198  r->name = "ft0";
4199  break;
4200  case GDB_REGNO_FT1:
4201  r->name = "ft1";
4202  break;
4203  case GDB_REGNO_FT2:
4204  r->name = "ft2";
4205  break;
4206  case GDB_REGNO_FT3:
4207  r->name = "ft3";
4208  break;
4209  case GDB_REGNO_FT4:
4210  r->name = "ft4";
4211  break;
4212  case GDB_REGNO_FT5:
4213  r->name = "ft5";
4214  break;
4215  case GDB_REGNO_FT6:
4216  r->name = "ft6";
4217  break;
4218  case GDB_REGNO_FT7:
4219  r->name = "ft7";
4220  break;
4221  case GDB_REGNO_FS0:
4222  r->name = "fs0";
4223  break;
4224  case GDB_REGNO_FS1:
4225  r->name = "fs1";
4226  break;
4227  case GDB_REGNO_FA0:
4228  r->name = "fa0";
4229  break;
4230  case GDB_REGNO_FA1:
4231  r->name = "fa1";
4232  break;
4233  case GDB_REGNO_FA2:
4234  r->name = "fa2";
4235  break;
4236  case GDB_REGNO_FA3:
4237  r->name = "fa3";
4238  break;
4239  case GDB_REGNO_FA4:
4240  r->name = "fa4";
4241  break;
4242  case GDB_REGNO_FA5:
4243  r->name = "fa5";
4244  break;
4245  case GDB_REGNO_FA6:
4246  r->name = "fa6";
4247  break;
4248  case GDB_REGNO_FA7:
4249  r->name = "fa7";
4250  break;
4251  case GDB_REGNO_FS2:
4252  r->name = "fs2";
4253  break;
4254  case GDB_REGNO_FS3:
4255  r->name = "fs3";
4256  break;
4257  case GDB_REGNO_FS4:
4258  r->name = "fs4";
4259  break;
4260  case GDB_REGNO_FS5:
4261  r->name = "fs5";
4262  break;
4263  case GDB_REGNO_FS6:
4264  r->name = "fs6";
4265  break;
4266  case GDB_REGNO_FS7:
4267  r->name = "fs7";
4268  break;
4269  case GDB_REGNO_FS8:
4270  r->name = "fs8";
4271  break;
4272  case GDB_REGNO_FS9:
4273  r->name = "fs9";
4274  break;
4275  case GDB_REGNO_FS10:
4276  r->name = "fs10";
4277  break;
4278  case GDB_REGNO_FS11:
4279  r->name = "fs11";
4280  break;
4281  case GDB_REGNO_FT8:
4282  r->name = "ft8";
4283  break;
4284  case GDB_REGNO_FT9:
4285  r->name = "ft9";
4286  break;
4287  case GDB_REGNO_FT10:
4288  r->name = "ft10";
4289  break;
4290  case GDB_REGNO_FT11:
4291  r->name = "ft11";
4292  break;
4293  }
4294  r->group = "float";
4295  r->feature = &feature_fpu;
4296  } else if (number >= GDB_REGNO_CSR0 && number <= GDB_REGNO_CSR4095) {
4297  r->group = "csr";
4298  r->feature = &feature_csr;
4299  unsigned csr_number = number - GDB_REGNO_CSR0;
4300 
4301  while (csr_info[csr_info_index].number < csr_number &&
4302  csr_info_index < ARRAY_SIZE(csr_info) - 1) {
4303  csr_info_index++;
4304  }
4305  if (csr_info[csr_info_index].number == csr_number) {
4306  r->name = csr_info[csr_info_index].name;
4307  } else {
4308  sprintf(reg_name, "csr%d", csr_number);
4309  /* Assume unnamed registers don't exist, unless we have some
4310  * configuration that tells us otherwise. That's important
4311  * because eg. Eclipse crashes if a target has too many
4312  * registers, and apparently has no way of only showing a
4313  * subset of registers in any case. */
4314  r->exist = false;
4315  }
4316 
4317  switch (csr_number) {
4318  case CSR_FFLAGS:
4319  case CSR_FRM:
4320  case CSR_FCSR:
4322  r->group = "float";
4323  r->feature = &feature_fpu;
4324  break;
4325  case CSR_SSTATUS:
4326  case CSR_STVEC:
4327  case CSR_SIP:
4328  case CSR_SIE:
4329  case CSR_SCOUNTEREN:
4330  case CSR_SSCRATCH:
4331  case CSR_SEPC:
4332  case CSR_SCAUSE:
4333  case CSR_STVAL:
4334  case CSR_SATP:
4336  break;
4337  case CSR_MEDELEG:
4338  case CSR_MIDELEG:
4339  /* "In systems with only M-mode, or with both M-mode and
4340  * U-mode but without U-mode trap support, the medeleg and
4341  * mideleg registers should not exist." */
4342  r->exist = riscv_supports_extension(target, 'S') ||
4344  break;
4345 
4346  case CSR_PMPCFG1:
4347  case CSR_PMPCFG3:
4348  case CSR_CYCLEH:
4349  case CSR_TIMEH:
4350  case CSR_INSTRETH:
4351  case CSR_HPMCOUNTER3H:
4352  case CSR_HPMCOUNTER4H:
4353  case CSR_HPMCOUNTER5H:
4354  case CSR_HPMCOUNTER6H:
4355  case CSR_HPMCOUNTER7H:
4356  case CSR_HPMCOUNTER8H:
4357  case CSR_HPMCOUNTER9H:
4358  case CSR_HPMCOUNTER10H:
4359  case CSR_HPMCOUNTER11H:
4360  case CSR_HPMCOUNTER12H:
4361  case CSR_HPMCOUNTER13H:
4362  case CSR_HPMCOUNTER14H:
4363  case CSR_HPMCOUNTER15H:
4364  case CSR_HPMCOUNTER16H:
4365  case CSR_HPMCOUNTER17H:
4366  case CSR_HPMCOUNTER18H:
4367  case CSR_HPMCOUNTER19H:
4368  case CSR_HPMCOUNTER20H:
4369  case CSR_HPMCOUNTER21H:
4370  case CSR_HPMCOUNTER22H:
4371  case CSR_HPMCOUNTER23H:
4372  case CSR_HPMCOUNTER24H:
4373  case CSR_HPMCOUNTER25H:
4374  case CSR_HPMCOUNTER26H:
4375  case CSR_HPMCOUNTER27H:
4376  case CSR_HPMCOUNTER28H:
4377  case CSR_HPMCOUNTER29H:
4378  case CSR_HPMCOUNTER30H:
4379  case CSR_HPMCOUNTER31H:
4380  case CSR_MCYCLEH:
4381  case CSR_MINSTRETH:
4382  case CSR_MHPMCOUNTER3H:
4383  case CSR_MHPMCOUNTER4H:
4384  case CSR_MHPMCOUNTER5H:
4385  case CSR_MHPMCOUNTER6H:
4386  case CSR_MHPMCOUNTER7H:
4387  case CSR_MHPMCOUNTER8H:
4388  case CSR_MHPMCOUNTER9H:
4389  case CSR_MHPMCOUNTER10H:
4390  case CSR_MHPMCOUNTER11H:
4391  case CSR_MHPMCOUNTER12H:
4392  case CSR_MHPMCOUNTER13H:
4393  case CSR_MHPMCOUNTER14H:
4394  case CSR_MHPMCOUNTER15H:
4395  case CSR_MHPMCOUNTER16H:
4396  case CSR_MHPMCOUNTER17H:
4397  case CSR_MHPMCOUNTER18H:
4398  case CSR_MHPMCOUNTER19H:
4399  case CSR_MHPMCOUNTER20H:
4400  case CSR_MHPMCOUNTER21H:
4401  case CSR_MHPMCOUNTER22H:
4402  case CSR_MHPMCOUNTER23H:
4403  case CSR_MHPMCOUNTER24H:
4404  case CSR_MHPMCOUNTER25H:
4405  case CSR_MHPMCOUNTER26H:
4406  case CSR_MHPMCOUNTER27H:
4407  case CSR_MHPMCOUNTER28H:
4408  case CSR_MHPMCOUNTER29H:
4409  case CSR_MHPMCOUNTER30H:
4410  case CSR_MHPMCOUNTER31H:
4411  r->exist = riscv_xlen(target) == 32;
4412  break;
4413 
4414  case CSR_VSTART:
4415  case CSR_VXSAT:
4416  case CSR_VXRM:
4417  case CSR_VL:
4418  case CSR_VTYPE:
4419  case CSR_VLENB:
4421  break;
4422  }
4423 
4424  if (!r->exist && !list_empty(&info->expose_csr)) {
4425  range_list_t *entry;
4426  list_for_each_entry(entry, &info->expose_csr, list)
4427  if ((entry->low <= csr_number) && (csr_number <= entry->high)) {
4428  if (entry->name) {
4429  *reg_name = 0;
4430  r->name = entry->name;
4431  }
4432 
4433  LOG_DEBUG("Exposing additional CSR %d (name=%s)",
4434  csr_number, entry->name ? entry->name : reg_name);
4435 
4436  r->exist = true;
4437  break;
4438  }
4439  }
4440 
4441  } else if (number == GDB_REGNO_PRIV) {
4442  sprintf(reg_name, "priv");
4443  r->group = "general";
4444  r->feature = &feature_virtual;
4445  r->size = 8;
4446 
4447  } else if (number >= GDB_REGNO_V0 && number <= GDB_REGNO_V31) {
4448  r->caller_save = false;
4449  r->exist = riscv_supports_extension(target, 'V') && info->vlenb;
4450  r->size = info->vlenb * 8;
4451  sprintf(reg_name, "v%d", number - GDB_REGNO_V0);
4452  r->group = "vector";
4453  r->feature = &feature_vector;
4454  r->reg_data_type = &info->type_vector;
4455 
4456  } else if (number >= GDB_REGNO_COUNT) {
4457  /* Custom registers. */
4458  assert(!list_empty(&info->expose_custom));
4459 
4460  range_list_t *range = list_first_entry(&info->expose_custom, range_list_t, list);
4461 
4462  unsigned custom_number = range->low + custom_within_range;
4463 
4464  r->group = "custom";
4465  r->feature = &feature_custom;
4466  r->arch_info = calloc(1, sizeof(riscv_reg_info_t));
4467  if (!r->arch_info)
4468  return ERROR_FAIL;
4469  ((riscv_reg_info_t *) r->arch_info)->target = target;
4470  ((riscv_reg_info_t *) r->arch_info)->custom_number = custom_number;
4471  sprintf(reg_name, "custom%d", custom_number);
4472 
4473  if (range->name) {
4474  *reg_name = 0;
4475  r->name = range->name;
4476  }
4477 
4478  LOG_DEBUG("Exposing additional custom register %d (name=%s)",
4479  number, range->name ? range->name : reg_name);
4480 
4481  custom_within_range++;
4482  if (custom_within_range > range->high - range->low) {
4483  custom_within_range = 0;
4484  list_rotate_left(&info->expose_custom);
4485  }
4486  }
4487 
4488  if (reg_name[0]) {
4489  r->name = reg_name;
4490  reg_name += strlen(reg_name) + 1;
4491  assert(reg_name < info->reg_names + target->reg_cache->num_regs *
4492  max_reg_name_len);
4493  }
4494  r->value = calloc(1, DIV_ROUND_UP(r->size, 8));
4495  }
4496 
4497  return ERROR_OK;
4498 }
4499 
4500 
4503 {
4505 
4506  memset(ctxt->tunneled_dr, 0, sizeof(ctxt->tunneled_dr));
4508  ctxt->tunneled_dr[3].num_bits = 1;
4509  ctxt->tunneled_dr[3].out_value = bscan_one;
4510  ctxt->tunneled_dr[2].num_bits = 7;
4511  ctxt->tunneled_dr_width = field->num_bits;
4512  ctxt->tunneled_dr[2].out_value = &ctxt->tunneled_dr_width;
4513  /* for BSCAN tunnel, there is a one-TCK skew between shift in and shift out, so
4514  scanning num_bits + 1, and then will right shift the input field after executing the queues */
4515 
4516  ctxt->tunneled_dr[1].num_bits = field->num_bits + 1;
4517  ctxt->tunneled_dr[1].out_value = field->out_value;
4518  ctxt->tunneled_dr[1].in_value = field->in_value;
4519 
4520  ctxt->tunneled_dr[0].num_bits = 3;
4521  ctxt->tunneled_dr[0].out_value = bscan_zero;
4522  } else {
4523  /* BSCAN_TUNNEL_NESTED_TAP */
4524  ctxt->tunneled_dr[0].num_bits = 1;
4525  ctxt->tunneled_dr[0].out_value = bscan_one;
4526  ctxt->tunneled_dr[1].num_bits = 7;
4527  ctxt->tunneled_dr_width = field->num_bits;
4528  ctxt->tunneled_dr[1].out_value = &ctxt->tunneled_dr_width;
4529  /* for BSCAN tunnel, there is a one-TCK skew between shift in and shift out, so
4530  scanning num_bits + 1, and then will right shift the input field after executing the queues */
4531  ctxt->tunneled_dr[2].num_bits = field->num_bits + 1;
4532  ctxt->tunneled_dr[2].out_value = field->out_value;
4533  ctxt->tunneled_dr[2].in_value = field->in_value;
4534  ctxt->tunneled_dr[3].num_bits = 3;
4535  ctxt->tunneled_dr[3].out_value = bscan_zero;
4536  }
4538 }
void init_reg_param(struct reg_param *param, char *reg_name, uint32_t size, enum param_direction direction)
Definition: algorithm.c:29
void destroy_reg_param(struct reg_param *param)
Definition: algorithm.c:37
@ PARAM_OUT
Definition: algorithm.h:16
@ PARAM_IN
Definition: algorithm.h:15
@ PARAM_IN_OUT
Definition: algorithm.h:17
enum arm_mode mode
Definition: armv4_5.c:277
const char * name
Definition: armv4_5.c:76
char * buf_to_hex_str(const void *_buf, unsigned buf_len)
Definition: binarybuffer.c:192
void * buf_cpy(const void *from, void *_to, unsigned size)
Copies size bits out of from and into to.
Definition: binarybuffer.c:43
static void buf_set_u64(uint8_t *_buffer, unsigned first, unsigned num, uint64_t value)
Sets num bits in _buffer, starting at the first bit, using the bits in value.
Definition: binarybuffer.h:60
static uint32_t buf_get_u32(const uint8_t *_buffer, unsigned first, unsigned num)
Retrieves num bits from _buffer, starting at the first bit, returning the bits in a 32-bit word.
Definition: binarybuffer.h:98
static void buf_set_u32(uint8_t *_buffer, unsigned first, unsigned num, uint32_t value)
Sets num bits in _buffer, starting at the first bit, using the bits in value.
Definition: binarybuffer.h:30
static uint64_t buf_get_u64(const uint8_t *_buffer, unsigned first, unsigned num)
Retrieves num bits from _buffer, starting at the first bit, returning the bits in a 64-bit word.
Definition: binarybuffer.h:127
@ BKPT_HARD
Definition: breakpoints.h:18
@ BKPT_SOFT
Definition: breakpoints.h:19
@ WPT_ACCESS
Definition: breakpoints.h:23
@ WPT_READ
Definition: breakpoints.h:23
@ WPT_WRITE
Definition: breakpoints.h:23
void command_print_sameline(struct command_invocation *cmd, const char *format,...)
Definition: command.c:450
void command_print(struct command_invocation *cmd, const char *format,...)
Definition: command.c:473
#define CMD
Use this macro to access the command being handled, rather than accessing the variable directly.
Definition: command.h:140
#define CALL_COMMAND_HANDLER(name, extra ...)
Use this to macro to call a command helper (or a nested handler).
Definition: command.h:117
#define CMD_ARGV
Use this macro to access the arguments for the command being handled, rather than accessing the varia...
Definition: command.h:155
#define COMMAND_PARSE_ON_OFF(in, out)
parses an on/off command argument
Definition: command.h:504
#define ERROR_COMMAND_SYNTAX_ERROR
Definition: command.h:385
#define CMD_ARGC
Use this macro to access the number of arguments for the command being handled, rather than accessing...
Definition: command.h:150
#define COMMAND_PARSE_NUMBER(type, in, out)
parses the string in into out as a type, or prints a command error and passes the error code to the c...
Definition: command.h:425
#define CMD_CTX
Use this macro to access the context of the command being handled, rather than accessing the variable...
Definition: command.h:145
#define COMMAND_REGISTRATION_DONE
Use this as the last entry in an array of command_registration records.
Definition: command.h:247
@ COMMAND_CONFIG
Definition: command.h:41
@ COMMAND_ANY
Definition: command.h:42
@ COMMAND_EXEC
Definition: command.h:40
static int halted(struct target *target, const char *label)
Definition: davinci.c:58
#define CSR_MCONTROL6_VS
#define CSR_MCONTROL6_LOAD
#define CSR_MCONTROL6_ACTION
#define CSR_MCONTROL6_EXECUTE
#define CSR_MCONTROL6_STORE
#define CSR_MCONTROL6_M
#define CSR_MCONTROL6_S
#define CSR_MCONTROL6_U
#define CSR_MCONTROL6_VU
#define CSR_MCONTROL6_MATCH
#define PTE_W
Definition: encoding.h:287
#define CSR_MHPMCOUNTER17H
Definition: encoding.h:3165
#define MCONTROL_M
Definition: encoding.h:107
#define CSR_HPMCOUNTER25H
Definition: encoding.h:3106
#define CSR_MHPMCOUNTER7H
Definition: encoding.h:3155
#define CSR_MHPMCOUNTER27H
Definition: encoding.h:3175
#define MCONTROL_U
Definition: encoding.h:110
#define MCONTROL_EXECUTE
Definition: encoding.h:111
#define CSR_PMPCFG1
Definition: encoding.h:2916
#define CSR_HPMCOUNTER22H
Definition: encoding.h:3103
#define CSR_MHPMCOUNTER18H
Definition: encoding.h:3166
#define CSR_MHPMCOUNTER21H
Definition: encoding.h:3169
#define MSTATUS_MIE
Definition: encoding.h:16
#define CSR_HPMCOUNTER15H
Definition: encoding.h:3096
#define MCONTROL_ACTION_DEBUG_MODE
Definition: encoding.h:119
#define MSTATUS_SIE
Definition: encoding.h:14
#define MCONTROL_MATCH
Definition: encoding.h:106
#define MSTATUS_MPP
Definition: encoding.h:23
#define CSR_HPMCOUNTER12H
Definition: encoding.h:3093
#define CSR_HPMCOUNTER19H
Definition: encoding.h:3100
#define CSR_TIMEH
Definition: encoding.h:3082
#define CSR_MHPMCOUNTER28H
Definition: encoding.h:3176
#define CSR_HPMCOUNTER3H
Definition: encoding.h:3084
#define CSR_MHPMCOUNTER9H
Definition: encoding.h:3157
#define CSR_SEPC
Definition: encoding.h:2843
#define PTE_R
Definition: encoding.h:286
#define CSR_MHPMCOUNTER29H
Definition: encoding.h:3177
#define MSTATUS_UIE
Definition: encoding.h:13
#define CSR_MHPMCOUNTER10H
Definition: encoding.h:3158
#define CSR_HPMCOUNTER4H
Definition: encoding.h:3085
#define CSR_PMPCFG3
Definition: encoding.h:2918
#define CSR_MHPMCOUNTER11H
Definition: encoding.h:3159
#define CSR_SCAUSE
Definition: encoding.h:2844
#define CSR_HPMCOUNTER9H
Definition: encoding.h:3090
#define MCONTROL_TYPE(xlen)
Definition: encoding.h:98
#define CSR_MHPMCOUNTER12H
Definition: encoding.h:3160
#define CSR_HPMCOUNTER31H
Definition: encoding.h:3112
#define CSR_SSCRATCH
Definition: encoding.h:2842
#define CSR_MHPMCOUNTER25H
Definition: encoding.h:3173
#define PTE_PPN_SHIFT
Definition: encoding.h:299
#define CSR_HPMCOUNTER6H
Definition: encoding.h:3087
#define CSR_MHPMCOUNTER26H
Definition: encoding.h:3174
#define CSR_HPMCOUNTER27H
Definition: encoding.h:3108
#define CSR_HPMCOUNTER17H
Definition: encoding.h:3098
#define CSR_MHPMCOUNTER5H
Definition: encoding.h:3153
#define CSR_HPMCOUNTER21H
Definition: encoding.h:3102
#define CSR_SSTATUS
Definition: encoding.h:2831
#define CSR_MHPMCOUNTER24H
Definition: encoding.h:3172
#define CSR_HPMCOUNTER18H
Definition: encoding.h:3099
#define MATCH_LB
Definition: encoding.h:1235
#define CSR_STVAL
Definition: encoding.h:2845
#define CSR_MHPMCOUNTER8H
Definition: encoding.h:3156
#define CSR_MHPMCOUNTER3H
Definition: encoding.h:3151
#define CSR_HPMCOUNTER14H
Definition: encoding.h:3095
#define CSR_MHPMCOUNTER20H
Definition: encoding.h:3168
#define MCONTROL_LOAD
Definition: encoding.h:113
#define CSR_VLENB
Definition: encoding.h:2830
#define SATP_MODE_SV32
Definition: encoding.h:237
#define SATP_MODE_SV39
Definition: encoding.h:238
#define CSR_HPMCOUNTER28H
Definition: encoding.h:3109
#define CSR_SATP
Definition: encoding.h:2848
#define CSR_MHPMCOUNTER31H
Definition: encoding.h:3179
#define CSR_VTYPE
Definition: encoding.h:2829
#define PTE_V
Definition: encoding.h:285
#define MCONTROL_MATCH_EQUAL
Definition: encoding.h:124
#define MATCH_SB
Definition: encoding.h:1391
#define CSR_MHPMCOUNTER6H
Definition: encoding.h:3154
#define CSR_HPMCOUNTER16H
Definition: encoding.h:3097
#define MCONTROL_ACTION
Definition: encoding.h:104
#define CSR_MHPMCOUNTER23H
Definition: encoding.h:3171
#define CSR_MINSTRETH
Definition: encoding.h:3150
#define CSR_HPMCOUNTER20H
Definition: encoding.h:3101
#define CSR_FRM
Definition: encoding.h:2789
#define SATP_MODE_SV48
Definition: encoding.h:239
#define CSR_MHPMCOUNTER15H
Definition: encoding.h:3163
#define MCONTROL_DMODE(xlen)
Definition: encoding.h:99
#define CSR_STVEC
Definition: encoding.h:2835
#define CSR_MEDELEG
Definition: encoding.h:2897
#define CSR_HPMCOUNTER23H
Definition: encoding.h:3104
#define CSR_VL
Definition: encoding.h:2828
#define MSTATUS_HIE
Definition: encoding.h:15
#define CSR_HPMCOUNTER30H
Definition: encoding.h:3111
#define CSR_MHPMCOUNTER14H
Definition: encoding.h:3162
#define CSR_FCSR
Definition: encoding.h:2790
#define CSR_HPMCOUNTER5H
Definition: encoding.h:3086
#define CSR_HPMCOUNTER13H
Definition: encoding.h:3094
#define CSR_SIP
Definition: encoding.h:2846
#define MCONTROL_S
Definition: encoding.h:109
#define CSR_HPMCOUNTER7H
Definition: encoding.h:3088
#define CSR_MHPMCOUNTER13H
Definition: encoding.h:3161
#define SATP_MODE_OFF
Definition: encoding.h:236
#define CSR_HPMCOUNTER26H
Definition: encoding.h:3107
#define CSR_SCOUNTEREN
Definition: encoding.h:2836
#define CSR_VXRM
Definition: encoding.h:2793
#define CSR_MHPMCOUNTER4H
Definition: encoding.h:3152
#define PTE_X
Definition: encoding.h:288
#define CSR_HPMCOUNTER8H
Definition: encoding.h:3089
#define CSR_MCYCLEH
Definition: encoding.h:3149
#define CSR_MIDELEG
Definition: encoding.h:2898
#define CSR_VXSAT
Definition: encoding.h:2792
#define CSR_HPMCOUNTER11H
Definition: encoding.h:3092
#define MCONTROL_STORE
Definition: encoding.h:112
#define CSR_HPMCOUNTER24H
Definition: encoding.h:3105
#define CSR_INSTRETH
Definition: encoding.h:3083
#define CSR_FFLAGS
Definition: encoding.h:2788
#define CSR_MHPMCOUNTER22H
Definition: encoding.h:3170
#define CSR_HPMCOUNTER29H
Definition: encoding.h:3110
#define CSR_HPMCOUNTER10H
Definition: encoding.h:3091
#define CSR_MHPMCOUNTER19H
Definition: encoding.h:3167
#define CSR_CYCLEH
Definition: encoding.h:3081
#define CSR_MHPMCOUNTER16H
Definition: encoding.h:3164
#define CSR_VSTART
Definition: encoding.h:2791
#define CSR_MHPMCOUNTER30H
Definition: encoding.h:3178
#define MSTATUS_MPRV
Definition: encoding.h:26
#define CSR_SIE
Definition: encoding.h:2834
#define PRV_M
Definition: encoding.h:225
enum esirisc_reg_num number
Definition: esirisc.c:87
int mask
Definition: esirisc.c:1698
uint8_t type
Definition: esp_usb_jtag.c:0
static struct esp_usb_jtag * priv
Definition: esp_usb_jtag.c:219
uint8_t length
Definition: esp_usb_jtag.c:1
static uint16_t direction
Definition: ftdi.c:119
gdb_regno
Definition: gdb_regs.h:8
@ GDB_REGNO_DPC
Definition: gdb_regs.h:91
@ GDB_REGNO_V18
Definition: gdb_regs.h:108
@ GDB_REGNO_S8
Definition: gdb_regs.h:35
@ GDB_REGNO_V19
Definition: gdb_regs.h:108
@ GDB_REGNO_FS7
Definition: gdb_regs.h:70
@ GDB_REGNO_FS10
Definition: gdb_regs.h:73
@ GDB_REGNO_SATP
Definition: gdb_regs.h:97
@ GDB_REGNO_CSR0
Definition: gdb_regs.h:80
@ GDB_REGNO_FS8
Definition: gdb_regs.h:71
@ GDB_REGNO_MSTATUS
Definition: gdb_regs.h:94
@ GDB_REGNO_FS6
Definition: gdb_regs.h:69
@ GDB_REGNO_S4
Definition: gdb_regs.h:31
@ GDB_REGNO_V15
Definition: gdb_regs.h:107
@ GDB_REGNO_S11
Definition: gdb_regs.h:38
@ GDB_REGNO_V22
Definition: gdb_regs.h:109
@ GDB_REGNO_V2
Definition: gdb_regs.h:104
@ GDB_REGNO_VXRM
Definition: gdb_regs.h:83
@ GDB_REGNO_ZERO
Definition: gdb_regs.h:9
@ GDB_REGNO_V1
Definition: gdb_regs.h:104
@ GDB_REGNO_S5
Definition: gdb_regs.h:32
@ GDB_REGNO_T5
Definition: gdb_regs.h:41
@ GDB_REGNO_VTYPE
Definition: gdb_regs.h:86
@ GDB_REGNO_T6
Definition: gdb_regs.h:42
@ GDB_REGNO_A4
Definition: gdb_regs.h:24
@ GDB_REGNO_GP
Definition: gdb_regs.h:12
@ GDB_REGNO_FA3
Definition: gdb_regs.h:60
@ GDB_REGNO_VXSAT
Definition: gdb_regs.h:82
@ GDB_REGNO_S7
Definition: gdb_regs.h:34
@ GDB_REGNO_A1
Definition: gdb_regs.h:21
@ GDB_REGNO_FT3
Definition: gdb_regs.h:50
@ GDB_REGNO_V7
Definition: gdb_regs.h:105
@ GDB_REGNO_V21
Definition: gdb_regs.h:109
@ GDB_REGNO_V14
Definition: gdb_regs.h:107
@ GDB_REGNO_A5
Definition: gdb_regs.h:25
@ GDB_REGNO_TSELECT
Definition: gdb_regs.h:87
@ GDB_REGNO_T2
Definition: gdb_regs.h:16
@ GDB_REGNO_S1
Definition: gdb_regs.h:19
@ GDB_REGNO_XPR15
Definition: gdb_regs.h:26
@ GDB_REGNO_T3
Definition: gdb_regs.h:39
@ GDB_REGNO_V26
Definition: gdb_regs.h:110
@ GDB_REGNO_SP
Definition: gdb_regs.h:11
@ GDB_REGNO_FA2
Definition: gdb_regs.h:59
@ GDB_REGNO_FA0
Definition: gdb_regs.h:57
@ GDB_REGNO_FPR31
Definition: gdb_regs.h:79
@ GDB_REGNO_V12
Definition: gdb_regs.h:107
@ GDB_REGNO_V24
Definition: gdb_regs.h:110
@ GDB_REGNO_FPR0
Definition: gdb_regs.h:46
@ GDB_REGNO_V11
Definition: gdb_regs.h:106
@ GDB_REGNO_FT5
Definition: gdb_regs.h:52
@ GDB_REGNO_V0
Definition: gdb_regs.h:104
@ GDB_REGNO_V29
Definition: gdb_regs.h:111
@ GDB_REGNO_DSCRATCH0
Definition: gdb_regs.h:93
@ GDB_REGNO_A6
Definition: gdb_regs.h:27
@ GDB_REGNO_FP
Definition: gdb_regs.h:18
@ GDB_REGNO_VL
Definition: gdb_regs.h:85
@ GDB_REGNO_TDATA1
Definition: gdb_regs.h:88
@ GDB_REGNO_V16
Definition: gdb_regs.h:108
@ GDB_REGNO_VSTART
Definition: gdb_regs.h:81
@ GDB_REGNO_FA1
Definition: gdb_regs.h:58
@ GDB_REGNO_XPR31
Definition: gdb_regs.h:43
@ GDB_REGNO_A0
Definition: gdb_regs.h:20
@ GDB_REGNO_MEPC
Definition: gdb_regs.h:95
@ GDB_REGNO_FS4
Definition: gdb_regs.h:67
@ GDB_REGNO_FT9
Definition: gdb_regs.h:76
@ GDB_REGNO_FT2
Definition: gdb_regs.h:49
@ GDB_REGNO_V28
Definition: gdb_regs.h:111
@ GDB_REGNO_FA4
Definition: gdb_regs.h:61
@ GDB_REGNO_V6
Definition: gdb_regs.h:105
@ GDB_REGNO_V25
Definition: gdb_regs.h:110
@ GDB_REGNO_FT7
Definition: gdb_regs.h:54
@ GDB_REGNO_FS0
Definition: gdb_regs.h:55
@ GDB_REGNO_FT6
Definition: gdb_regs.h:53
@ GDB_REGNO_FS9
Definition: gdb_regs.h:72
@ GDB_REGNO_FT1
Definition: gdb_regs.h:48
@ GDB_REGNO_FT8
Definition: gdb_regs.h:75
@ GDB_REGNO_FT11
Definition: gdb_regs.h:78
@ GDB_REGNO_A2
Definition: gdb_regs.h:22
@ GDB_REGNO_V20
Definition: gdb_regs.h:109
@ GDB_REGNO_V13
Definition: gdb_regs.h:107
@ GDB_REGNO_V17
Definition: gdb_regs.h:108
@ GDB_REGNO_FS3
Definition: gdb_regs.h:66
@ GDB_REGNO_A7
Definition: gdb_regs.h:28
@ GDB_REGNO_RA
Definition: gdb_regs.h:10
@ GDB_REGNO_V5
Definition: gdb_regs.h:105
@ GDB_REGNO_S9
Definition: gdb_regs.h:36
@ GDB_REGNO_PC
Definition: gdb_regs.h:45
@ GDB_REGNO_S0
Definition: gdb_regs.h:17
@ GDB_REGNO_T4
Definition: gdb_regs.h:40
@ GDB_REGNO_VLENB
Definition: gdb_regs.h:84
@ GDB_REGNO_FA5
Definition: gdb_regs.h:62
@ GDB_REGNO_V9
Definition: gdb_regs.h:106
@ GDB_REGNO_V27
Definition: gdb_regs.h:110
@ GDB_REGNO_V31
Definition: gdb_regs.h:111
@ GDB_REGNO_FA6
Definition: gdb_regs.h:63
@ GDB_REGNO_V3
Definition: gdb_regs.h:104
@ GDB_REGNO_S10
Definition: gdb_regs.h:37
@ GDB_REGNO_FT10
Definition: gdb_regs.h:77
@ GDB_REGNO_PRIV
Definition: gdb_regs.h:99
@ GDB_REGNO_S2
Definition: gdb_regs.h:29
@ GDB_REGNO_V4
Definition: gdb_regs.h:105
@ GDB_REGNO_CSR4095
Definition: gdb_regs.h:98
@ GDB_REGNO_FS1
Definition: gdb_regs.h:56
@ GDB_REGNO_FA7
Definition: gdb_regs.h:64
@ GDB_REGNO_TP
Definition: gdb_regs.h:13
@ GDB_REGNO_MCAUSE
Definition: gdb_regs.h:96
@ GDB_REGNO_TDATA2
Definition: gdb_regs.h:89
@ GDB_REGNO_FS2
Definition: gdb_regs.h:65
@ GDB_REGNO_FT0
Definition: gdb_regs.h:47
@ GDB_REGNO_COUNT
Definition: gdb_regs.h:112
@ GDB_REGNO_V23
Definition: gdb_regs.h:109
@ GDB_REGNO_T1
Definition: gdb_regs.h:15
@ GDB_REGNO_S6
Definition: gdb_regs.h:33
@ GDB_REGNO_V10
Definition: gdb_regs.h:106
@ GDB_REGNO_FT4
Definition: gdb_regs.h:51
@ GDB_REGNO_S3
Definition: gdb_regs.h:30
@ GDB_REGNO_T0
Definition: gdb_regs.h:14
@ GDB_REGNO_FS11
Definition: gdb_regs.h:74
@ GDB_REGNO_MISA
Definition: gdb_regs.h:90
@ GDB_REGNO_DCSR
Definition: gdb_regs.h:92
@ GDB_REGNO_V30
Definition: gdb_regs.h:111
@ GDB_REGNO_A3
Definition: gdb_regs.h:23
@ GDB_REGNO_FS5
Definition: gdb_regs.h:68
@ GDB_REGNO_V8
Definition: gdb_regs.h:106
int jtag_execute_queue(void)
For software FIFO implementations, the queued commands can be executed during this call or earlier.
Definition: jtag/core.c:1037
void jtag_add_ir_scan(struct jtag_tap *active, struct scan_field *in_fields, tap_state_t state)
Generate an IR SCAN with a list of scan fields with one entry for each enabled TAP.
Definition: jtag/core.c:374
void jtag_add_dr_scan(struct jtag_tap *active, int in_num_fields, const struct scan_field *in_fields, tap_state_t state)
Generate a DR SCAN using the fields passed to the function.
Definition: jtag/core.c:451
The JTAG interface can be implemented with a software or hardware fifo.
@ TAP_IDLE
Definition: jtag.h:52
static void list_add(struct list_head *new, struct list_head *head)
list_add - add a new entry
Definition: list.h:112
#define list_first_entry(ptr, type, member)
list_first_entry - get the first element from a list
Definition: list.h:537
static int list_empty(const struct list_head *head)
list_empty - tests whether a list is empty
Definition: list.h:296
#define list_for_each_entry(pos, head, member)
list_for_each_entry - iterate over list of given type
Definition: list.h:643
#define list_for_each_entry_safe(pos, n, head, member)
list_for_each_entry_safe - iterate over list of given type safe against removal of list entry
Definition: list.h:744
static void list_rotate_left(struct list_head *head)
list_rotate_left - rotate the list to the left
Definition: list.h:342
static void INIT_LIST_HEAD(struct list_head *list)
INIT_LIST_HEAD - Initialize a list_head structure.
Definition: list.h:61
void keep_alive(void)
Definition: log.c:419
static int64_t start
Definition: log.c:41
#define ERROR_NOT_IMPLEMENTED
Definition: log.h:165
#define LOG_WARNING(expr ...)
Definition: log.h:120
#define ERROR_FAIL
Definition: log.h:161
#define LOG_ERROR(expr ...)
Definition: log.h:123
#define LOG_INFO(expr ...)
Definition: log.h:117
#define LOG_DEBUG(expr ...)
Definition: log.h:109
#define ERROR_OK
Definition: log.h:155
static uint32_t ebreak(void) __attribute__((unused))
Definition: opcodes.h:219
static uint32_t ebreak_c(void) __attribute__((unused))
Definition: opcodes.h:224
struct reg * register_get_by_name(struct reg_cache *first, const char *name, bool search_all)
Definition: register.c:50
void register_cache_invalidate(struct reg_cache *cache)
Marks the contents of the register cache as invalid (and clean).
Definition: register.c:94
reg_type
Definition: register.h:19
@ REG_TYPE_UINT16
Definition: register.h:29
@ REG_TYPE_IEEE_DOUBLE
Definition: register.h:37
@ REG_TYPE_UINT32
Definition: register.h:30
@ REG_TYPE_UINT128
Definition: register.h:32
@ REG_TYPE_UINT64
Definition: register.h:31
@ REG_TYPE_ARCH_DEFINED
Definition: register.h:38
@ REG_TYPE_IEEE_SINGLE
Definition: register.h:36
@ REG_TYPE_UINT8
Definition: register.h:28
@ REG_TYPE_CLASS_VECTOR
Definition: register.h:93
@ REG_TYPE_CLASS_UNION
Definition: register.h:94
struct target_type riscv011_target
Definition: riscv-011.c:2394
slot
Definition: riscv-011.c:122
struct target_type riscv013_target
Definition: riscv-013.c:4052
int riscv_reset_timeout_sec
Definition: riscv.c:206
static int halt_finish(struct target *target)
Definition: riscv.c:1221
const char * gdb_regno_name(enum gdb_regno regno)
Definition: riscv.c:3598
static int resume_go(struct target *target, int current, target_addr_t address, int handle_breakpoints, int debug_execution)
Resume all the harts that have been prepped, as close to instantaneous as possible.
Definition: riscv.c:1437
static struct scan_field _bscan_tunnel_data_register_select_dmi[]
Definition: riscv.c:142
static int riscv_create_target(struct target *target, Jim_Interp *interp)
Definition: riscv.c:430
static enum @112 resume_order
static int remove_trigger(struct target *target, struct trigger *trigger)
Definition: riscv.c:913
struct scan_field select_idcode
Definition: riscv.c:123
bool riscv_ebreaks
Definition: riscv.c:210
riscv_poll_hart
Definition: riscv.c:2079
@ RPH_ERROR
Definition: riscv.c:2083
@ RPH_NO_CHANGE
Definition: riscv.c:2080
@ RPH_DISCOVERED_HALTED
Definition: riscv.c:2081
@ RPH_DISCOVERED_RUNNING
Definition: riscv.c:2082
static bool riscv_enable_virt2phys
Definition: riscv.c:208
static int set_debug_reason(struct target *target, enum riscv_halt_reason halt_reason)
Definition: riscv.c:2110
static int old_or_new_riscv_step(struct target *target, int current, target_addr_t address, int handle_breakpoints)
Definition: riscv.c:1107
int riscv_set_register(struct target *target, enum gdb_regno regid, riscv_reg_t value)
This function is called when the debug user wants to change the value of a register.
Definition: riscv.c:3391
static struct scan_field select_user4
Definition: riscv.c:135
static bscan_tunnel_type_t bscan_tunnel_type
Definition: riscv.c:128
static int oldriscv_step(struct target *target, int current, uint32_t address, int handle_breakpoints)
Definition: riscv.c:1100
static int riscv_halt_go_all_harts(struct target *target)
Definition: riscv.c:1186
struct scan_field select_dbus
Definition: riscv.c:118
int riscv_set_current_hartid(struct target *target, int hartid)
Definition: riscv.c:3296
static int maybe_add_trigger_t6(struct target *target, struct trigger *trigger, uint64_t tdata1)
Definition: riscv.c:637
static int riscv_target_resume(struct target *target, int current, target_addr_t address, int handle_breakpoints, int debug_execution)
Definition: riscv.c:1518
static int riscv_step_rtos_hart(struct target *target)
Definition: riscv.c:3253
static int riscv_checksum_memory(struct target *target, target_addr_t address, uint32_t count, uint32_t *checksum)
Definition: riscv.c:1991
static struct reg_arch_type riscv_reg_arch_type
Definition: riscv.c:3858
static uint32_t bscan_tunnel_data_register_select_dmi_num_fields
Definition: riscv.c:191
static const struct command_registration riscv_command_handlers[]
Definition: riscv.c:3123
int riscv_write_debug_buffer(struct target *target, int index, riscv_insn_t insn)
Definition: riscv.c:3480
bool riscv_is_halted(struct target *target)
Definition: riscv.c:3455
int riscv_read_by_any_size(struct target *target, target_addr_t address, uint32_t size, uint8_t *buffer)
Read one memory item using any memory access size that will work.
Definition: riscv.c:837
static int riscv_read_phys_memory(struct target *target, target_addr_t phys_address, uint32_t size, uint32_t count, uint8_t *buffer)
Definition: riscv.c:1691
int riscv_init_registers(struct target *target)
Definition: riscv.c:3873
static int riscv_write_phys_memory(struct target *target, target_addr_t phys_address, uint32_t size, uint32_t count, const uint8_t *buffer)
Definition: riscv.c:1719
int riscv_halt(struct target *target)
Definition: riscv.c:1226
static unsigned riscv_xlen_nonconst(struct target *target)
Definition: riscv.c:3141
bool riscv_ebreakm
Definition: riscv.c:209
static int riscv_remove_breakpoint(struct target *target, struct breakpoint *breakpoint)
Definition: riscv.c:945
static int add_trigger(struct target *target, struct trigger *trigger)
Definition: riscv.c:689
static int riscv_address_translate(struct target *target, target_addr_t virtual, target_addr_t *physical)
Definition: riscv.c:1570
static int register_set(struct reg *reg, uint8_t *buf)
Definition: riscv.c:3810
int riscv_write_by_any_size(struct target *target, target_addr_t address, uint32_t size, uint8_t *buffer)
Write one memory item using any memory access size that will work.
Definition: riscv.c:805
static void trigger_from_watchpoint(struct trigger *trigger, const struct watchpoint *watchpoint)
Definition: riscv.c:974
static uint8_t bscan_tunneled_ir_width[4]
Definition: riscv.c:141
static const virt2phys_info_t sv32
Definition: riscv.c:220
static int riscv_init_target(struct command_context *cmd_ctx, struct target *target)
Definition: riscv.c:442
static int old_or_new_riscv_poll(struct target *target)
Definition: riscv.c:1152
static int riscv_add_breakpoint(struct target *target, struct breakpoint *breakpoint)
Definition: riscv.c:865
void riscv_fill_dmi_nop_u64(struct target *target, char *buf)
Definition: riscv.c:3511
static int riscv_mmu(struct target *target, int *enabled)
Definition: riscv.c:1525
unsigned riscv_xlen(const struct target *target)
Definition: riscv.c:3290
static int riscv_get_gdb_reg_list(struct target *target, struct reg **reg_list[], int *reg_list_size, enum target_register_class reg_class)
Definition: riscv.c:1815
void riscv_add_bscan_tunneled_scan(struct target *target, struct scan_field *field, riscv_bscan_tunneled_scan_context_t *ctxt)
Definition: riscv.c:4501
static int resume_prep(struct target *target, int current, target_addr_t address, int handle_breakpoints, int debug_execution)
Get everything ready to resume.
Definition: riscv.c:1398
enum slot slot_t
static int riscv_run_algorithm(struct target *target, int num_mem_params, struct mem_param *mem_params, int num_reg_params, struct reg_param *reg_params, target_addr_t entry_point, target_addr_t exit_point, int timeout_ms, void *arch_info)
Definition: riscv.c:1830
static void riscv_sample_buf_maybe_add_timestamp(struct target *target, bool before)
Definition: riscv.c:264
COMMAND_HELPER(riscv_print_info_line, const char *section, const char *key, unsigned int value)
Definition: riscv.c:2902
dbus_status_t
Definition: riscv.c:63
@ DBUS_STATUS_BUSY
Definition: riscv.c:66
@ DBUS_STATUS_FAILED
Definition: riscv.c:65
@ DBUS_STATUS_SUCCESS
Definition: riscv.c:64
static int maybe_add_trigger_t2(struct target *target, struct trigger *trigger, uint64_t tdata1)
Definition: riscv.c:587
static int enable_triggers(struct target *target, riscv_reg_t *state)
Definition: riscv.c:1358
static void riscv_free_registers(struct target *target)
Definition: riscv.c:472
static const virt2phys_info_t sv48
Definition: riscv.c:246
int riscv_current_hartid(const struct target *target)
Definition: riscv.c:3322
int riscv_select_current_hart(struct target *target)
Definition: riscv.c:1161
@ SLOT0
Definition: riscv.c:73
@ SLOT1
Definition: riscv.c:74
@ SLOT_LAST
Definition: riscv.c:75
#define get_field(reg, mask)
Definition: riscv.c:26
static struct scan_field _bscan_tunnel_nested_tap_select_dmi[]
Definition: riscv.c:165
int riscv_execute_debug_buffer(struct target *target)
Definition: riscv.c:3493
size_t riscv_debug_buffer_size(struct target *target)
Definition: riscv.c:3474
static uint32_t dtmcontrol_scan(struct target *target, uint32_t out)
Definition: riscv.c:377
struct target_type riscv_target
Definition: riscv.c:3154
struct scan_field select_dtmcontrol
Definition: riscv.c:113
#define DTMCONTROL_VERSION
Definition: riscv.c:53
static const struct command_registration riscv_exec_command_handlers[]
Definition: riscv.c:2929
static void riscv_info_init(struct target *target, struct riscv_info *r)
Definition: riscv.c:3206
static uint8_t ir_dtmcontrol[4]
Definition: riscv.c:112
static int riscv_resume(struct target *target, int current, target_addr_t address, int handle_breakpoints, int debug_execution, bool single_hart)
Definition: riscv.c:1466
static int riscv_get_gdb_reg_list_internal(struct target *target, struct reg **reg_list[], int *reg_list_size, enum target_register_class reg_class, bool read)
Definition: riscv.c:1759
uint32_t dtmcontrol_scan_via_bscan(struct target *target, uint32_t out)
Definition: riscv.c:293
static int riscv_read_memory(struct target *target, target_addr_t address, uint32_t size, uint32_t count, uint8_t *buffer)
Definition: riscv.c:1700
static int riscv_resume_prep_all_harts(struct target *target)
Definition: riscv.c:1288
static bool gdb_regno_cacheable(enum gdb_regno regno, bool write)
If write is true: return true iff we are guaranteed that the register will contain exactly the value ...
Definition: riscv.c:3346
static int maybe_add_trigger_t1(struct target *target, struct trigger *trigger, uint64_t tdata1)
Definition: riscv.c:534
static enum riscv_halt_reason riscv_halt_reason(struct target *target, int hartid)
Definition: riscv.c:3462
int riscv_openocd_step(struct target *target, int current, target_addr_t address, int handle_breakpoints)
Definition: riscv.c:2305
@ RO_REVERSED
Definition: riscv.c:217
@ RO_NORMAL
Definition: riscv.c:216
static int cmp_csr_info(const void *p1, const void *p2)
Definition: riscv.c:3868
static uint8_t ir_user4[4]
Definition: riscv.c:134
int riscv_openocd_poll(struct target *target)
Definition: riscv.c:2184
#define DTMCONTROL
Definition: riscv.c:49
int riscv_add_watchpoint(struct target *target, struct watchpoint *watchpoint)
Definition: riscv.c:988
static int oldriscv_poll(struct target *target)
Definition: riscv.c:1146
static int riscv_hit_watchpoint(struct target *target, struct watchpoint **hit_watchpoint)
Definition: riscv.c:1023
void select_dmi_via_bscan(struct target *target)
Definition: riscv.c:282
static int halt_go(struct target *target)
Definition: riscv.c:1204
static int riscv_assert_reset(struct target *target)
Definition: riscv.c:1273
static int read_by_given_size(struct target *target, target_addr_t address, uint32_t size, uint8_t *buffer, uint32_t access_size)
Read one memory item of given "size".
Definition: riscv.c:778
static uint32_t bscan_tunnel_nested_tap_select_dmi_num_fields
Definition: riscv.c:188
static int halt_prep(struct target *target)
Definition: riscv.c:1166
static uint8_t ir_dbus[4]
Definition: riscv.c:117
static unsigned int riscv_data_bits(struct target *target)
Definition: riscv.c:3146
static int register_get(struct reg *reg)
Definition: riscv.c:3780
COMMAND_HANDLER(riscv_set_command_timeout_sec)
Definition: riscv.c:2337
int riscv_dmi_write_u64_bits(struct target *target)
Definition: riscv.c:3517
bool riscv_enable_virtual
Definition: riscv.c:213
static void riscv_deinit_target(struct target *target)
Definition: riscv.c:489
bool riscv_supports_extension(struct target *target, char letter)
Definition: riscv.c:3277
static int riscv_examine(struct target *target)
Definition: riscv.c:1119
void riscv_fill_dmi_write_u64(struct target *target, char *buf, int a, uint64_t d)
Definition: riscv.c:3499
static int riscv_resume_go_all_harts(struct target *target)
Definition: riscv.c:3232
void riscv_fill_dmi_read_u64(struct target *target, char *buf, int a)
Definition: riscv.c:3505
static int sample_memory(struct target *target)
Definition: riscv.c:2136
bool riscv_ebreaku
Definition: riscv.c:211
int riscv_get_register(struct target *target, riscv_reg_t *value, enum gdb_regno regid)
Get register, from the cache if it's in there.
Definition: riscv.c:3417
static int riscv_arch_state(struct target *target)
Definition: riscv.c:1823
static struct scan_field * bscan_tunnel_nested_tap_select_dmi
Definition: riscv.c:187
int riscv_remove_watchpoint(struct target *target, struct watchpoint *watchpoint)
Definition: riscv.c:1001
static void riscv_invalidate_register_cache(struct target *target)
Definition: riscv.c:3312
static int riscv_get_gdb_reg_list_noread(struct target *target, struct reg **reg_list[], int *reg_list_size, enum target_register_class reg_class)
Definition: riscv.c:1807
static struct target_type * get_target_type(struct target *target)
Definition: riscv.c:411
static struct scan_field * bscan_tunnel_data_register_select_dmi
Definition: riscv.c:190
static void trigger_from_breakpoint(struct trigger *trigger, const struct breakpoint *breakpoint)
Definition: riscv.c:521
dbus_op_t
Definition: riscv.c:58
@ DBUS_OP_NOP
Definition: riscv.c:59
@ DBUS_OP_WRITE
Definition: riscv.c:61
@ DBUS_OP_READ
Definition: riscv.c:60
static const uint8_t bscan_zero[4]
Definition: riscv.c:131
static int riscv_write_memory(struct target *target, target_addr_t address, uint32_t size, uint32_t count, const uint8_t *buffer)
Definition: riscv.c:1728
riscv_insn_t riscv_read_debug_buffer(struct target *target, int index)
Definition: riscv.c:3487
static int write_by_given_size(struct target *target, target_addr_t address, uint32_t size, uint8_t *buffer, uint32_t access_size)
Write one memory item of given "size".
Definition: riscv.c:751
int riscv_enumerate_triggers(struct target *target)
Count triggers, and initialize trigger_count for each hart.
Definition: riscv.c:3530
int riscv_command_timeout_sec
Definition: riscv.c:203
int riscv_count_harts(struct target *target)
Definition: riscv.c:3328
int bscan_tunnel_ir_width
Definition: riscv.c:129
static uint8_t ir_idcode[4]
Definition: riscv.c:122
static int riscv_virt2phys(struct target *target, target_addr_t virtual, target_addr_t *physical)
Definition: riscv.c:1677
static const char * riscv_get_gdb_arch(struct target *target)
Definition: riscv.c:1747
static int resume_finish(struct target *target)
Definition: riscv.c:1453
static int parse_ranges(struct list_head *ranges, const char *tcl_arg, const char *reg_type, unsigned int max_val)
Definition: riscv.c:2463
#define set_field(reg, mask, val)
Definition: riscv.c:27
static int disable_triggers(struct target *target, riscv_reg_t *state)
Definition: riscv.c:1310
static const virt2phys_info_t sv39
Definition: riscv.c:233
static int riscv_deassert_reset(struct target *target)
Definition: riscv.c:1281
#define DBUS
Definition: riscv.c:55
static const uint8_t bscan_one[4]
Definition: riscv.c:132
#define RISCV_SAMPLE_BUF_TIMESTAMP_BEFORE
Definition: riscv.h:67
#define RISCV_PGSHIFT
Definition: riscv.h:29
#define RISCV_INFO(R)
Definition: riscv.h:274
static struct riscv_info * riscv_info(const struct target *target) __attribute__((unused))
Definition: riscv.h:269
void riscv_semihosting_init(struct target *target)
Initialize RISC-V semihosting.
@ RISCV_MEM_ACCESS_UNSPECIFIED
Definition: riscv.h:46
@ RISCV_MEM_ACCESS_SYSBUS
Definition: riscv.h:48
@ RISCV_MEM_ACCESS_PROGBUF
Definition: riscv.h:47
@ RISCV_MEM_ACCESS_ABSTRACT
Definition: riscv.h:49
#define RISCV_NUM_MEM_ACCESS_METHODS
Definition: riscv.h:33
#define RISCV_MAX_HWBPS
Definition: riscv.h:22
enum semihosting_result riscv_semihosting(struct target *target, int *retval)
Check for and process a semihosting request using the ARM protocol).
#define RISCV_SATP_PPN(xlen)
Definition: riscv.h:28
#define RISCV_MAX_TRIGGERS
Definition: riscv.h:21
#define RISCV_SAMPLE_BUF_TIMESTAMP_AFTER
Definition: riscv.h:68
uint64_t riscv_reg_t
Definition: riscv.h:41
#define RISCV_COMMON_MAGIC
Definition: riscv.h:16
#define DEFAULT_COMMAND_TIMEOUT_SEC
Definition: riscv.h:24
bscan_tunnel_type_t
Definition: riscv.h:287
@ BSCAN_TUNNEL_NESTED_TAP
Definition: riscv.h:287
@ BSCAN_TUNNEL_DATA_REGISTER
Definition: riscv.h:287
#define DEFAULT_RESET_TIMEOUT_SEC
Definition: riscv.h:25
#define RISCV_SATP_MODE(xlen)
Definition: riscv.h:27
uint32_t riscv_insn_t
Definition: riscv.h:42
riscv_halt_reason
Definition: riscv.h:52
@ RISCV_HALT_INTERRUPT
Definition: riscv.h:53
@ RISCV_HALT_BREAKPOINT
Definition: riscv.h:54
@ RISCV_HALT_SINGLESTEP
Definition: riscv.h:55
@ RISCV_HALT_UNKNOWN
Definition: riscv.h:57
@ RISCV_HALT_ERROR
Definition: riscv.h:59
@ RISCV_HALT_GROUP
Definition: riscv.h:58
@ RISCV_HALT_TRIGGER
Definition: riscv.h:56
struct target * target
Definition: rtt/rtt.c:26
size_t size
Size of the control block search area.
Definition: rtt/rtt.c:30
const struct command_registration semihosting_common_handlers[]
@ SEMIHOSTING_ERROR
@ SEMIHOSTING_HANDLED
@ SEMIHOSTING_WAITING
@ SEMIHOSTING_NONE
#define foreach_smp_target(pos, head)
Definition: smp.h:15
#define foreach_smp_target_direction(forward, pos, head)
Definition: smp.h:18
#define BIT(nr)
Definition: stm32l4x.h:18
uint8_t * orig_instr
Definition: breakpoints.h:33
enum breakpoint_type type
Definition: breakpoints.h:30
uint32_t unique_id
Definition: breakpoints.h:35
bool is_set
Definition: breakpoints.h:31
target_addr_t address
Definition: breakpoints.h:27
const char * name
Definition: command.h:229
const char * name
Definition: riscv.c:3865
unsigned number
Definition: riscv.c:3864
int ir_length
size of instruction register
Definition: jtag.h:109
Definition: list.h:26
char * name
Definition: riscv.h:87
uint16_t high
Definition: riscv.h:86
uint16_t low
Definition: riscv.h:86
int(* get)(struct reg *reg)
Definition: register.h:152
int(* set)(struct reg *reg, uint8_t *buf)
Definition: register.h:153
const char * name
Definition: register.h:145
unsigned num_regs
Definition: register.h:148
struct reg * reg_list
Definition: register.h:147
struct reg_data_type_union_field * fields
Definition: register.h:57
enum reg_type type
Definition: register.h:100
const char * name
Definition: register.h:42
uint32_t size
Definition: algorithm.h:29
uint8_t * value
Definition: algorithm.h:30
const char * reg_name
Definition: algorithm.h:28
Definition: register.h:111
bool caller_save
Definition: register.h:119
bool valid
Definition: register.h:126
bool exist
Definition: register.h:128
uint32_t size
Definition: register.h:132
const char * group
Definition: register.h:138
uint8_t * value
Definition: register.h:122
struct reg_feature * feature
Definition: register.h:117
struct reg_data_type * reg_data_type
Definition: register.h:135
uint32_t number
Definition: register.h:115
void * arch_info
Definition: register.h:140
bool dirty
Definition: register.h:124
const struct reg_arch_type * type
Definition: register.h:141
const char * name
Definition: register.h:113
struct scan_field tunneled_dr[4]
Definition: riscv.h:239
void * version_specific
Definition: riscv.h:96
struct list_head expose_custom
Definition: riscv.h:228
int mem_access_methods[RISCV_NUM_MEM_ACCESS_METHODS]
Definition: riscv.h:214
int xlen
Definition: riscv.h:109
bool prepped
Definition: riscv.h:136
int current_hartid
Definition: riscv.h:102
bool mem_access_abstract_warn
Definition: riscv.h:220
bool mem_access_sysbus_warn
Definition: riscv.h:219
struct list_head expose_csr
Definition: riscv.h:224
bool mem_access_progbuf_warn
Definition: riscv.h:218
unsigned int common_magic
Definition: riscv.h:91
unsigned dtm_version
Definition: riscv.h:93
enum riscv_halt_reason(* halt_reason)(struct target *target)
Definition: riscv.h:161
int trigger_unique_id[RISCV_MAX_HWBPS]
Definition: riscv.h:121
struct target * target
Definition: riscv.h:63
This structure defines a single scan field in the scan.
Definition: jtag.h:86
int num_bits
The number of bits this field specifies.
Definition: jtag.h:88
uint8_t * in_value
A pointer to a 32-bit memory location for data scanned out.
Definition: jtag.h:92
const uint8_t * out_value
A pointer to value to be scanned into the device.
Definition: jtag.h:90
struct target * target
Definition: target.h:215
This holds methods shared between all instances of a given target type.
Definition: target_type.h:26
int(* write_memory)(struct target *target, target_addr_t address, uint32_t size, uint32_t count, const uint8_t *buffer)
Target memory write callback.
Definition: target_type.h:124
const char * name
Name of this type of target.
Definition: target_type.h:31
int(* deassert_reset)(struct target *target)
The implementation is responsible for polling the target such that target->state reflects the state c...
Definition: target_type.h:76
int(* init_target)(struct command_context *cmd_ctx, struct target *target)
Definition: target_type.h:229
void(* deinit_target)(struct target *target)
Free all the resources allocated by the target.
Definition: target_type.h:247
int(* halt)(struct target *target)
Definition: target_type.h:43
int(* assert_reset)(struct target *target)
Definition: target_type.h:64
int(* resume)(struct target *target, int current, target_addr_t address, int handle_breakpoints, int debug_execution)
Definition: target_type.h:45
int(* arch_state)(struct target *target)
Definition: target_type.h:37
int(* step)(struct target *target, int current, target_addr_t address, int handle_breakpoints)
Definition: target_type.h:47
int(* poll)(struct target *target)
Definition: target_type.h:34
int(* examine)(struct target *target)
This method is used to perform target setup that requires JTAG access.
Definition: target_type.h:222
int(* virt2phys)(struct target *target, target_addr_t address, target_addr_t *physical)
Definition: target_type.h:252
Definition: target.h:120
int32_t coreid
Definition: target.h:125
int smp
Definition: target.h:192
struct jtag_tap * tap
Definition: target.h:124
enum target_debug_reason debug_reason
Definition: target.h:159
enum target_state state
Definition: target.h:162
struct reg_cache * reg_cache
Definition: target.h:163
struct list_head * smp_targets
Definition: target.h:193
struct target_type * type
Definition: target.h:121
struct watchpoint * watchpoints
Definition: target.h:165
void * arch_info
Definition: target.h:169
Definition: psoc6.c:84
uint64_t value
Definition: riscv-011.c:168
bool read
Definition: riscv-011.c:169
uint64_t address
Definition: riscv-011.c:165
uint32_t length
Definition: riscv-011.c:166
uint64_t mask
Definition: riscv-011.c:167
int unique_id
Definition: riscv-011.c:170
bool execute
Definition: riscv-011.c:169
bool write
Definition: riscv-011.c:169
const char * name
Definition: riscv.h:243
enum watchpoint_rw rw
Definition: breakpoints.h:44
uint32_t mask
Definition: breakpoints.h:42
bool is_set
Definition: breakpoints.h:45
struct watchpoint * next
Definition: breakpoints.h:47
int unique_id
Definition: breakpoints.h:48
uint32_t value
Definition: breakpoints.h:43
uint32_t length
Definition: breakpoints.h:41
target_addr_t address
Definition: breakpoints.h:40
uint32_t size
Definition: target.h:91
target_addr_t address
Definition: target.h:90
int target_call_event_callbacks(struct target *target, enum target_event event)
Definition: target.c:1833
int target_write_buffer(struct target *target, target_addr_t address, uint32_t size, const uint8_t *buffer)
Definition: target.c:2408
int target_read_buffer(struct target *target, target_addr_t address, uint32_t size, uint8_t *buffer)
Definition: target.c:2473
int target_write_memory(struct target *target, target_addr_t address, uint32_t size, uint32_t count, const uint8_t *buffer)
Write count items of size bytes to the memory of target at the address given.
Definition: target.c:1334
int target_alloc_working_area(struct target *target, uint32_t size, struct working_area **area)
Definition: target.c:2129
int target_free_working_area(struct target *target, struct working_area *area)
Free a working area.
Definition: target.c:2187
int target_run_algorithm(struct target *target, int num_mem_params, struct mem_param *mem_params, int num_reg_params, struct reg_param *reg_param, target_addr_t entry_point, target_addr_t exit_point, int timeout_ms, void *arch_info)
Downloads a target-specific native code algorithm to the target, and executes it.
Definition: target.c:846
int target_read_memory(struct target *target, target_addr_t address, uint32_t size, uint32_t count, uint8_t *buffer)
Read count items of size bytes from the memory of target at the address given.
Definition: target.c:1306
struct target * get_current_target(struct command_context *cmd_ctx)
Definition: target.c:536
@ DBG_REASON_UNDEFINED
Definition: target.h:81
@ DBG_REASON_NOTHALTED
Definition: target.h:78
@ DBG_REASON_DBGRQ
Definition: target.h:73
@ DBG_REASON_SINGLESTEP
Definition: target.h:77
@ DBG_REASON_WATCHPOINT
Definition: target.h:75
@ DBG_REASON_BREAKPOINT
Definition: target.h:74
target_register_class
Definition: target.h:114
@ REG_CLASS_GENERAL
Definition: target.h:116
@ REG_CLASS_ALL
Definition: target.h:115
#define ERROR_TARGET_NOT_HALTED
Definition: target.h:792
@ TARGET_EVENT_HALTED
Definition: target.h:253
@ TARGET_EVENT_RESUMED
Definition: target.h:254
@ TARGET_HALTED
Definition: target.h:55
@ TARGET_RUNNING
Definition: target.h:54
#define TARGET_DEFAULT_POLLING_INTERVAL
Definition: target.h:805
static const char * target_name(struct target *target)
Returns the instance-specific name of the specified target.
Definition: target.h:234
#define ERROR_TARGET_TIMEOUT
Definition: target.h:791
#define ERROR_TARGET_RESOURCE_NOT_AVAILABLE
Definition: target.h:796
static bool target_was_examined(struct target *target)
Definition: target.h:438
int64_t timeval_ms(void)
#define TARGET_ADDR_FMT
Definition: types.h:342
static void h_u32_to_le(uint8_t *buf, uint32_t val)
Definition: types.h:178
#define ARRAY_SIZE(x)
Compute the number of elements of a variable length array.
Definition: types.h:57
#define DIV_ROUND_UP(m, n)
Rounds m up to the nearest multiple of n using division.
Definition: types.h:79
uint64_t target_addr_t
Definition: types.h:335
#define TARGET_PRIxADDR
Definition: types.h:340
static struct ublast_lowlevel low
static struct ublast_lowlevel_priv info
#define NULL
Definition: usb.h:16
uint8_t state[4]
Definition: vdebug.c:21
uint8_t count[4]
Definition: vdebug.c:22