riscv
/
riscv-isa-sim
mirror of https://github.com/riscv-software-src/riscv-isa-sim.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Update debug_defines.h (#942) 

I'll need it for some trigger work.
pull/945/head
Tim Newsome 4 years ago
committed by GitHub
parent
56054a2d97
commit
29dca8b846
No known key found for this signature in database GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 2084 additions and 1383 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 3235
      riscv/debug_defines.h
  2. 232
      riscv/debug_module.cc

3235
riscv/debug_defines.h
View File

File diff suppressed because it is too large

232
riscv/debug_module.cc
View File

@ -357,8 +357,8 @@ bool debug_module_t::dmi_read(unsigned address, uint32_t *value)
{ {
uint32_t result = 0; uint32_t result = 0;
D(fprintf(stderr, "dmi_read(0x%x) -> ", address)); D(fprintf(stderr, "dmi_read(0x%x) -> ", address));
if (address >= DMI_DATA0 && address < DMI_DATA0 + abstractcs.datacount) { if (address >= DM_DATA0 && address < DM_DATA0 + abstractcs.datacount) {
unsigned i = address - DMI_DATA0; unsigned i = address - DM_DATA0;
result = read32(dmdata, i); result = read32(dmdata, i);
if (abstractcs.busy) { if (abstractcs.busy) {
result = -1; result = -1;
@ -372,8 +372,8 @@ bool debug_module_t::dmi_read(unsigned address, uint32_t *value)
if (!abstractcs.busy && ((abstractauto.autoexecdata >> i) & 1)) { if (!abstractcs.busy && ((abstractauto.autoexecdata >> i) & 1)) {
perform_abstract_command(); perform_abstract_command();
} }
} else if (address >= DMI_PROGBUF0 && address < DMI_PROGBUF0 + config.progbufsize) { } else if (address >= DM_PROGBUF0 && address < DM_PROGBUF0 + config.progbufsize) {
unsigned i = address - DMI_PROGBUF0; unsigned i = address - DM_PROGBUF0;
result = read32(program_buffer, i); result = read32(program_buffer, i);
if (abstractcs.busy) { if (abstractcs.busy) {
result = -1; result = -1;
@ -385,20 +385,20 @@ bool debug_module_t::dmi_read(unsigned address, uint32_t *value)
} else { } else {
switch (address) { switch (address) {
case DMI_DMCONTROL: case DM_DMCONTROL:
{ {
result = set_field(result, DMI_DMCONTROL_HALTREQ, dmcontrol.haltreq); result = set_field(result, DM_DMCONTROL_HALTREQ, dmcontrol.haltreq);
result = set_field(result, DMI_DMCONTROL_RESUMEREQ, dmcontrol.resumereq); result = set_field(result, DM_DMCONTROL_RESUMEREQ, dmcontrol.resumereq);
result = set_field(result, DMI_DMCONTROL_HARTSELHI, result = set_field(result, DM_DMCONTROL_HARTSELHI,
dmcontrol.hartsel >> DMI_DMCONTROL_HARTSELLO_LENGTH); dmcontrol.hartsel >> DM_DMCONTROL_HARTSELLO_LENGTH);
result = set_field(result, DMI_DMCONTROL_HASEL, dmcontrol.hasel); result = set_field(result, DM_DMCONTROL_HASEL, dmcontrol.hasel);
result = set_field(result, DMI_DMCONTROL_HARTSELLO, dmcontrol.hartsel); result = set_field(result, DM_DMCONTROL_HARTSELLO, dmcontrol.hartsel);
result = set_field(result, DMI_DMCONTROL_HARTRESET, dmcontrol.hartreset); result = set_field(result, DM_DMCONTROL_HARTRESET, dmcontrol.hartreset);
result = set_field(result, DMI_DMCONTROL_NDMRESET, dmcontrol.ndmreset); result = set_field(result, DM_DMCONTROL_NDMRESET, dmcontrol.ndmreset);
result = set_field(result, DMI_DMCONTROL_DMACTIVE, dmcontrol.dmactive); result = set_field(result, DM_DMCONTROL_DMACTIVE, dmcontrol.dmactive);
} }
break; break;
case DMI_DMSTATUS: case DM_DMSTATUS:
{ {
dmstatus.allhalted = true; dmstatus.allhalted = true;
dmstatus.anyhalted = false; dmstatus.anyhalted = false;
@ -433,51 +433,51 @@ bool debug_module_t::dmi_read(unsigned address, uint32_t *value)
dmstatus.allunavail = false; dmstatus.allunavail = false;
dmstatus.anyunavail = false; dmstatus.anyunavail = false;
result = set_field(result, DMI_DMSTATUS_IMPEBREAK, result = set_field(result, DM_DMSTATUS_IMPEBREAK,
dmstatus.impebreak); dmstatus.impebreak);
result = set_field(result, DMI_DMSTATUS_ALLHAVERESET, result = set_field(result, DM_DMSTATUS_ALLHAVERESET,
hart_state[dmcontrol.hartsel].havereset); hart_state[dmcontrol.hartsel].havereset);
result = set_field(result, DMI_DMSTATUS_ANYHAVERESET, result = set_field(result, DM_DMSTATUS_ANYHAVERESET,
hart_state[dmcontrol.hartsel].havereset); hart_state[dmcontrol.hartsel].havereset);
result = set_field(result, DMI_DMSTATUS_ALLNONEXISTENT, dmstatus.allnonexistant); result = set_field(result, DM_DMSTATUS_ALLNONEXISTENT, dmstatus.allnonexistant);
result = set_field(result, DMI_DMSTATUS_ALLUNAVAIL, dmstatus.allunavail); result = set_field(result, DM_DMSTATUS_ALLUNAVAIL, dmstatus.allunavail);
result = set_field(result, DMI_DMSTATUS_ALLRUNNING, dmstatus.allrunning); result = set_field(result, DM_DMSTATUS_ALLRUNNING, dmstatus.allrunning);
result = set_field(result, DMI_DMSTATUS_ALLHALTED, dmstatus.allhalted); result = set_field(result, DM_DMSTATUS_ALLHALTED, dmstatus.allhalted);
result = set_field(result, DMI_DMSTATUS_ALLRESUMEACK, dmstatus.allresumeack); result = set_field(result, DM_DMSTATUS_ALLRESUMEACK, dmstatus.allresumeack);
result = set_field(result, DMI_DMSTATUS_ANYNONEXISTENT, dmstatus.anynonexistant); result = set_field(result, DM_DMSTATUS_ANYNONEXISTENT, dmstatus.anynonexistant);
result = set_field(result, DMI_DMSTATUS_ANYUNAVAIL, dmstatus.anyunavail); result = set_field(result, DM_DMSTATUS_ANYUNAVAIL, dmstatus.anyunavail);
result = set_field(result, DMI_DMSTATUS_ANYRUNNING, dmstatus.anyrunning); result = set_field(result, DM_DMSTATUS_ANYRUNNING, dmstatus.anyrunning);
result = set_field(result, DMI_DMSTATUS_ANYHALTED, dmstatus.anyhalted); result = set_field(result, DM_DMSTATUS_ANYHALTED, dmstatus.anyhalted);
result = set_field(result, DMI_DMSTATUS_ANYRESUMEACK, dmstatus.anyresumeack); result = set_field(result, DM_DMSTATUS_ANYRESUMEACK, dmstatus.anyresumeack);
result = set_field(result, DMI_DMSTATUS_AUTHENTICATED, dmstatus.authenticated); result = set_field(result, DM_DMSTATUS_AUTHENTICATED, dmstatus.authenticated);
result = set_field(result, DMI_DMSTATUS_AUTHBUSY, dmstatus.authbusy); result = set_field(result, DM_DMSTATUS_AUTHBUSY, dmstatus.authbusy);
result = set_field(result, DMI_DMSTATUS_VERSION, dmstatus.version); result = set_field(result, DM_DMSTATUS_VERSION, dmstatus.version);
} }
break; break;
case DMI_ABSTRACTCS: case DM_ABSTRACTCS:
result = set_field(result, DMI_ABSTRACTCS_CMDERR, abstractcs.cmderr); result = set_field(result, DM_ABSTRACTCS_CMDERR, abstractcs.cmderr);
result = set_field(result, DMI_ABSTRACTCS_BUSY, abstractcs.busy); result = set_field(result, DM_ABSTRACTCS_BUSY, abstractcs.busy);
result = set_field(result, DMI_ABSTRACTCS_DATACOUNT, abstractcs.datacount); result = set_field(result, DM_ABSTRACTCS_DATACOUNT, abstractcs.datacount);
result = set_field(result, DMI_ABSTRACTCS_PROGBUFSIZE, result = set_field(result, DM_ABSTRACTCS_PROGBUFSIZE,
abstractcs.progbufsize); abstractcs.progbufsize);
break; break;
case DMI_ABSTRACTAUTO: case DM_ABSTRACTAUTO:
result = set_field(result, DMI_ABSTRACTAUTO_AUTOEXECPROGBUF, abstractauto.autoexecprogbuf); result = set_field(result, DM_ABSTRACTAUTO_AUTOEXECPROGBUF, abstractauto.autoexecprogbuf);
result = set_field(result, DMI_ABSTRACTAUTO_AUTOEXECDATA, abstractauto.autoexecdata); result = set_field(result, DM_ABSTRACTAUTO_AUTOEXECDATA, abstractauto.autoexecdata);
break; break;
case DMI_COMMAND: case DM_COMMAND:
result = 0; result = 0;
break; break;
case DMI_HARTINFO: case DM_HARTINFO:
result = set_field(result, DMI_HARTINFO_NSCRATCH, 1); result = set_field(result, DM_HARTINFO_NSCRATCH, 1);
result = set_field(result, DMI_HARTINFO_DATAACCESS, 1); result = set_field(result, DM_HARTINFO_DATAACCESS, 1);
result = set_field(result, DMI_HARTINFO_DATASIZE, abstractcs.datacount); result = set_field(result, DM_HARTINFO_DATASIZE, abstractcs.datacount);
result = set_field(result, DMI_HARTINFO_DATAADDR, debug_data_start); result = set_field(result, DM_HARTINFO_DATAADDR, debug_data_start);
break; break;
case DMI_HAWINDOWSEL: case DM_HAWINDOWSEL:
result = hawindowsel; result = hawindowsel;
break; break;
case DMI_HAWINDOW: case DM_HAWINDOW:
{ {
unsigned base = hawindowsel * 32; unsigned base = hawindowsel * 32;
for (unsigned i = 0; i < 32; i++) { for (unsigned i = 0; i < 32; i++) {
@ -488,33 +488,33 @@ bool debug_module_t::dmi_read(unsigned address, uint32_t *value)
} }
} }
break; break;
case DMI_SBCS: case DM_SBCS:
result = set_field(result, DMI_SBCS_SBVERSION, sbcs.version); result = set_field(result, DM_SBCS_SBVERSION, sbcs.version);
result = set_field(result, DMI_SBCS_SBREADONADDR, sbcs.readonaddr); result = set_field(result, DM_SBCS_SBREADONADDR, sbcs.readonaddr);
result = set_field(result, DMI_SBCS_SBACCESS, sbcs.sbaccess); result = set_field(result, DM_SBCS_SBACCESS, sbcs.sbaccess);
result = set_field(result, DMI_SBCS_SBAUTOINCREMENT, sbcs.autoincrement); result = set_field(result, DM_SBCS_SBAUTOINCREMENT, sbcs.autoincrement);
result = set_field(result, DMI_SBCS_SBREADONDATA, sbcs.readondata); result = set_field(result, DM_SBCS_SBREADONDATA, sbcs.readondata);
result = set_field(result, DMI_SBCS_SBERROR, sbcs.error); result = set_field(result, DM_SBCS_SBERROR, sbcs.error);
result = set_field(result, DMI_SBCS_SBASIZE, sbcs.asize); result = set_field(result, DM_SBCS_SBASIZE, sbcs.asize);
result = set_field(result, DMI_SBCS_SBACCESS128, sbcs.access128); result = set_field(result, DM_SBCS_SBACCESS128, sbcs.access128);
result = set_field(result, DMI_SBCS_SBACCESS64, sbcs.access64); result = set_field(result, DM_SBCS_SBACCESS64, sbcs.access64);
result = set_field(result, DMI_SBCS_SBACCESS32, sbcs.access32); result = set_field(result, DM_SBCS_SBACCESS32, sbcs.access32);
result = set_field(result, DMI_SBCS_SBACCESS16, sbcs.access16); result = set_field(result, DM_SBCS_SBACCESS16, sbcs.access16);
result = set_field(result, DMI_SBCS_SBACCESS8, sbcs.access8); result = set_field(result, DM_SBCS_SBACCESS8, sbcs.access8);
break; break;
case DMI_SBADDRESS0: case DM_SBADDRESS0:
result = sbaddress[0]; result = sbaddress[0];
break; break;
case DMI_SBADDRESS1: case DM_SBADDRESS1:
result = sbaddress[1]; result = sbaddress[1];
break; break;
case DMI_SBADDRESS2: case DM_SBADDRESS2:
result = sbaddress[2]; result = sbaddress[2];
break; break;
case DMI_SBADDRESS3: case DM_SBADDRESS3:
result = sbaddress[3]; result = sbaddress[3];
break; break;
case DMI_SBDATA0: case DM_SBDATA0:
result = sbdata[0]; result = sbdata[0];
if (sbcs.error == 0) { if (sbcs.error == 0) {
if (sbcs.readondata) { if (sbcs.readondata) {
@ -525,20 +525,20 @@ bool debug_module_t::dmi_read(unsigned address, uint32_t *value)
} }
} }
break; break;
case DMI_SBDATA1: case DM_SBDATA1:
result = sbdata[1]; result = sbdata[1];
break; break;
case DMI_SBDATA2: case DM_SBDATA2:
result = sbdata[2]; result = sbdata[2];
break; break;
case DMI_SBDATA3: case DM_SBDATA3:
result = sbdata[3]; result = sbdata[3];
break; break;
case DMI_AUTHDATA: case DM_AUTHDATA:
result = challenge; result = challenge;
break; break;
case DMI_DMCS2: case DM_DMCS2:
result = set_field(result, DMI_DMCS2_HALTGROUP, result = set_field(result, DM_DMCS2_GROUP,
hart_state[dmcontrol.hartsel].haltgroup); hart_state[dmcontrol.hartsel].haltgroup);
break; break;
default: default:
@ -753,14 +753,14 @@ bool debug_module_t::dmi_write(unsigned address, uint32_t value)
{ {
D(fprintf(stderr, "dmi_write(0x%x, 0x%x)\n", address, value)); D(fprintf(stderr, "dmi_write(0x%x, 0x%x)\n", address, value));
if (!dmstatus.authenticated && address != DMI_AUTHDATA && if (!dmstatus.authenticated && address != DM_AUTHDATA &&
address != DMI_DMCONTROL) address != DM_DMCONTROL)
return false; return false;
if (address >= DMI_DATA0 && address < DMI_DATA0 + abstractcs.datacount) { if (address >= DM_DATA0 && address < DM_DATA0 + abstractcs.datacount) {
unsigned i = address - DMI_DATA0; unsigned i = address - DM_DATA0;
if (!abstractcs.busy) if (!abstractcs.busy)
write32(dmdata, address - DMI_DATA0, value); write32(dmdata, address - DM_DATA0, value);
if (abstractcs.busy && abstractcs.cmderr == CMDERR_NONE) { if (abstractcs.busy && abstractcs.cmderr == CMDERR_NONE) {
abstractcs.cmderr = CMDERR_BUSY; abstractcs.cmderr = CMDERR_BUSY;
@ -771,8 +771,8 @@ bool debug_module_t::dmi_write(unsigned address, uint32_t value)
} }
return true; return true;
} else if (address >= DMI_PROGBUF0 && address < DMI_PROGBUF0 + config.progbufsize) { } else if (address >= DM_PROGBUF0 && address < DM_PROGBUF0 + config.progbufsize) {
unsigned i = address - DMI_PROGBUF0; unsigned i = address - DM_PROGBUF0;
if (!abstractcs.busy) if (!abstractcs.busy)
write32(program_buffer, i, value); write32(program_buffer, i, value);
@ -784,29 +784,29 @@ bool debug_module_t::dmi_write(unsigned address, uint32_t value)
} else { } else {
switch (address) { switch (address) {
case DMI_DMCONTROL: case DM_DMCONTROL:
{ {
if (!dmcontrol.dmactive && get_field(value, DMI_DMCONTROL_DMACTIVE)) if (!dmcontrol.dmactive && get_field(value, DM_DMCONTROL_DMACTIVE))
reset(); reset();
dmcontrol.dmactive = get_field(value, DMI_DMCONTROL_DMACTIVE); dmcontrol.dmactive = get_field(value, DM_DMCONTROL_DMACTIVE);
if (!dmstatus.authenticated || !dmcontrol.dmactive) if (!dmstatus.authenticated || !dmcontrol.dmactive)
return true; return true;
dmcontrol.haltreq = get_field(value, DMI_DMCONTROL_HALTREQ); dmcontrol.haltreq = get_field(value, DM_DMCONTROL_HALTREQ);
dmcontrol.resumereq = get_field(value, DMI_DMCONTROL_RESUMEREQ); dmcontrol.resumereq = get_field(value, DM_DMCONTROL_RESUMEREQ);
dmcontrol.hartreset = get_field(value, DMI_DMCONTROL_HARTRESET); dmcontrol.hartreset = get_field(value, DM_DMCONTROL_HARTRESET);
dmcontrol.ndmreset = get_field(value, DMI_DMCONTROL_NDMRESET); dmcontrol.ndmreset = get_field(value, DM_DMCONTROL_NDMRESET);
if (config.support_hasel) if (config.support_hasel)
dmcontrol.hasel = get_field(value, DMI_DMCONTROL_HASEL); dmcontrol.hasel = get_field(value, DM_DMCONTROL_HASEL);
else else
dmcontrol.hasel = 0; dmcontrol.hasel = 0;
dmcontrol.hartsel = get_field(value, DMI_DMCONTROL_HARTSELHI) << dmcontrol.hartsel = get_field(value, DM_DMCONTROL_HARTSELHI) <<
DMI_DMCONTROL_HARTSELLO_LENGTH; DM_DMCONTROL_HARTSELLO_LENGTH;
dmcontrol.hartsel |= get_field(value, DMI_DMCONTROL_HARTSELLO); dmcontrol.hartsel |= get_field(value, DM_DMCONTROL_HARTSELLO);
dmcontrol.hartsel &= (1L<<hartsellen) - 1; dmcontrol.hartsel &= (1L<<hartsellen) - 1;
for (unsigned i = 0; i < nprocs; i++) { for (unsigned i = 0; i < nprocs; i++) {
if (hart_selected(i)) { if (hart_selected(i)) {
if (get_field(value, DMI_DMCONTROL_ACKHAVERESET)) { if (get_field(value, DM_DMCONTROL_ACKHAVERESET)) {
hart_state[i].havereset = false; hart_state[i].havereset = false;
} }
processor_t *proc = processor(i); processor_t *proc = processor(i);
@ -836,15 +836,15 @@ bool debug_module_t::dmi_write(unsigned address, uint32_t value)
} }
return true; return true;
case DMI_COMMAND: case DM_COMMAND:
command = value; command = value;
return perform_abstract_command(); return perform_abstract_command();
case DMI_HAWINDOWSEL: case DM_HAWINDOWSEL:
hawindowsel = value & ((1U<<field_width(nprocs))-1); hawindowsel = value & ((1U<<field_width(nprocs))-1);
return true; return true;
case DMI_HAWINDOW: case DM_HAWINDOW:
{ {
unsigned base = hawindowsel * 32; unsigned base = hawindowsel * 32;
for (unsigned i = 0; i < 32; i++) { for (unsigned i = 0; i < 32; i++) {
@ -856,40 +856,40 @@ bool debug_module_t::dmi_write(unsigned address, uint32_t value)
} }
return true; return true;
case DMI_ABSTRACTCS: case DM_ABSTRACTCS:
abstractcs.cmderr = (cmderr_t) (((uint32_t) (abstractcs.cmderr)) & (~(uint32_t)(get_field(value, DMI_ABSTRACTCS_CMDERR)))); abstractcs.cmderr = (cmderr_t) (((uint32_t) (abstractcs.cmderr)) & (~(uint32_t)(get_field(value, DM_ABSTRACTCS_CMDERR))));
return true; return true;
case DMI_ABSTRACTAUTO: case DM_ABSTRACTAUTO:
abstractauto.autoexecprogbuf = get_field(value, abstractauto.autoexecprogbuf = get_field(value,
DMI_ABSTRACTAUTO_AUTOEXECPROGBUF); DM_ABSTRACTAUTO_AUTOEXECPROGBUF);
abstractauto.autoexecdata = get_field(value, abstractauto.autoexecdata = get_field(value,
DMI_ABSTRACTAUTO_AUTOEXECDATA); DM_ABSTRACTAUTO_AUTOEXECDATA);
return true; return true;
case DMI_SBCS: case DM_SBCS:
sbcs.readonaddr = get_field(value, DMI_SBCS_SBREADONADDR); sbcs.readonaddr = get_field(value, DM_SBCS_SBREADONADDR);
sbcs.sbaccess = get_field(value, DMI_SBCS_SBACCESS); sbcs.sbaccess = get_field(value, DM_SBCS_SBACCESS);
sbcs.autoincrement = get_field(value, DMI_SBCS_SBAUTOINCREMENT); sbcs.autoincrement = get_field(value, DM_SBCS_SBAUTOINCREMENT);
sbcs.readondata = get_field(value, DMI_SBCS_SBREADONDATA); sbcs.readondata = get_field(value, DM_SBCS_SBREADONDATA);
sbcs.error &= ~get_field(value, DMI_SBCS_SBERROR); sbcs.error &= ~get_field(value, DM_SBCS_SBERROR);
return true; return true;
case DMI_SBADDRESS0: case DM_SBADDRESS0:
sbaddress[0] = value; sbaddress[0] = value;
if (sbcs.error == 0 && sbcs.readonaddr) { if (sbcs.error == 0 && sbcs.readonaddr) {
sb_read(); sb_read();
sb_autoincrement(); sb_autoincrement();
} }
return true; return true;
case DMI_SBADDRESS1: case DM_SBADDRESS1:
sbaddress[1] = value; sbaddress[1] = value;
return true; return true;
case DMI_SBADDRESS2: case DM_SBADDRESS2:
sbaddress[2] = value; sbaddress[2] = value;
return true; return true;
case DMI_SBADDRESS3: case DM_SBADDRESS3:
sbaddress[3] = value; sbaddress[3] = value;
return true; return true;
case DMI_SBDATA0: case DM_SBDATA0:
sbdata[0] = value; sbdata[0] = value;
if (sbcs.error == 0) { if (sbcs.error == 0) {
sb_write(); sb_write();
@ -898,16 +898,16 @@ bool debug_module_t::dmi_write(unsigned address, uint32_t value)
} }
} }
return true; return true;
case DMI_SBDATA1: case DM_SBDATA1:
sbdata[1] = value; sbdata[1] = value;
return true; return true;
case DMI_SBDATA2: case DM_SBDATA2:
sbdata[2] = value; sbdata[2] = value;
return true; return true;
case DMI_SBDATA3: case DM_SBDATA3:
sbdata[3] = value; sbdata[3] = value;
return true; return true;
case DMI_AUTHDATA: case DM_AUTHDATA:
D(fprintf(stderr, "debug authentication: got 0x%x; 0x%x unlocks\n", value, D(fprintf(stderr, "debug authentication: got 0x%x; 0x%x unlocks\n", value,
challenge + secret)); challenge + secret));
if (config.require_authentication) { if (config.require_authentication) {
@ -919,10 +919,10 @@ bool debug_module_t::dmi_write(unsigned address, uint32_t value)
} }
} }
return true; return true;
case DMI_DMCS2: case DM_DMCS2:
if (config.support_haltgroups && get_field(value, DMI_DMCS2_HGWRITE)) { if (config.support_haltgroups && get_field(value, DM_DMCS2_HGWRITE)) {
hart_state[dmcontrol.hartsel].haltgroup = get_field(value, hart_state[dmcontrol.hartsel].haltgroup = get_field(value,
DMI_DMCS2_HALTGROUP); DM_DMCS2_GROUP);
} }
return true; return true;
} }

Write Preview
Loading…
Cancel
Save