ETISS 0.11.2
ExtendableTranslatingInstructionSetSimulator(version0.11.2)
Loading...
Searching...
No Matches
RV32IMACFDFuncs.c
Go to the documentation of this file.
1
7#include "RV32IMACFDFuncs.h"
8// clang-format off
9
10etiss_uint8 RV32IMACFD_extension_enabled(ETISS_CPU * const cpu, ETISS_System * const system, void * const * const plugin_pointers, etiss_int8 extension)
11{
13{ // block
16return (etiss_uint8)(((*((RV32IMACFD*)cpu)->CSR[769ULL] >> (extension - 65ULL)) & 1ULL));
17etiss_coverage_count(11, 258, 255, 252, 247, 250, 248, 249, 251, 253, 254, 256);
18} // block
19}
20
21etiss_uint8 RV32IMACFD_get_rm(ETISS_CPU * const cpu, ETISS_System * const system, void * const * const plugin_pointers, etiss_uint8 rm)
22{
24{ // block
27if (rm == 7ULL) { // conditional
28etiss_coverage_count(3, 264, 262, 263);
29rm = ((((((RV32IMACFD*)cpu)->FCSR) >> (5ULL)) & 0x7ULL)) & 0x7ULL;
30etiss_coverage_count(6, 270, 265, 269, 266, 267, 268);
31} // conditional
33if (rm > 4ULL) { // conditional
34etiss_coverage_count(3, 274, 272, 273);
35RV32IMACFD_raise(cpu, system, plugin_pointers, 0LL, 2ULL);
36etiss_coverage_count(2, 277, 275);
37} // conditional
39return rm;
41} // block
42}
43
45{
47{ // block
50if (!(mask)) { // conditional
51etiss_coverage_count(2, 283, 282);
53return 0LL;
55} // conditional
57return (reg & mask) / (mask & ~((mask << 1ULL)));
58etiss_coverage_count(13, 298, 288, 286, 287, 289, 296, 290, 295, 293, 291, 292, 294, 297);
59} // block
60}
61
63{
65{ // block
68return (etiss_uint64)(((reg & ~(mask)) | ((((etiss_uint128)(val) * (etiss_uint128)((mask & ~((mask << 1ULL)))))) & mask)));
69etiss_coverage_count(22, 323, 320, 304, 301, 303, 302, 305, 318, 315, 306, 313, 307, 312, 310, 308, 309, 311, 314, 316, 317, 319, 321);
70} // block
71}
72
73etiss_uint32 RV32IMACFD_sstatus_mask(ETISS_CPU * const cpu, ETISS_System * const system, void * const * const plugin_pointers)
74{
76{ // block
78etiss_uint32 mask = 0LL;
79etiss_coverage_count(2, 328, 327);
81if (RV32IMACFD_extension_enabled(cpu, system, plugin_pointers, 83ULL)) { // conditional
82etiss_coverage_count(2, 331, 330);
83{ // block
85mask = mask | 5767458LL;
86etiss_coverage_count(2, 347, 332);
88if (RV32IMACFD_extension_enabled(cpu, system, plugin_pointers, 86ULL)) { // conditional
89etiss_coverage_count(2, 350, 349);
90mask = mask | 1536ULL;
91etiss_coverage_count(2, 353, 351);
92} // conditional
94if (RV32IMACFD_extension_enabled(cpu, system, plugin_pointers, 70ULL)) { // conditional
95etiss_coverage_count(2, 356, 355);
96mask = mask | 24576ULL;
97etiss_coverage_count(2, 359, 357);
98} // conditional
100if (RV32IMACFD_extension_enabled(cpu, system, plugin_pointers, 88ULL)) { // conditional
101etiss_coverage_count(2, 362, 361);
102mask = mask | 98304ULL;
103etiss_coverage_count(2, 365, 363);
104} // conditional
106if ((RV32IMACFD_get_field(*((RV32IMACFD*)cpu)->CSR[384ULL], 2147483648ULL))) { // conditional
107etiss_coverage_count(3, 376, 372, 378);
108mask = mask | 262144ULL;
109etiss_coverage_count(2, 394, 392);
110} // conditional
111} // block
112} // conditional
114return mask;
116} // block
117}
118
119etiss_uint32 RV32IMACFD_mstatus_mask(ETISS_CPU * const cpu, ETISS_System * const system, void * const * const plugin_pointers)
120{
122{ // block
124etiss_uint32 mask = 6280LL;
127return mask | RV32IMACFD_sstatus_mask(cpu, system, plugin_pointers);
128etiss_coverage_count(3, 411, 409, 410);
129} // block
130}
131
132etiss_uint32 RV32IMACFD_csr_read(ETISS_CPU * const cpu, ETISS_System * const system, void * const * const plugin_pointers, etiss_uint32 csr)
133{
135{ // block
138if (csr == 1ULL) { // conditional
139etiss_coverage_count(2, 417, 415);
141return *((RV32IMACFD*)cpu)->CSR[3ULL] & 31ULL;
142etiss_coverage_count(3, 422, 420, 421);
143} // conditional
145if (csr == 2ULL) { // conditional
146etiss_coverage_count(2, 427, 425);
148return (*((RV32IMACFD*)cpu)->CSR[3ULL] >> 5ULL) & 7ULL;
149etiss_coverage_count(6, 435, 432, 430, 431, 433, 434);
150} // conditional
152if (csr == 3072ULL) { // conditional
153etiss_coverage_count(2, 440, 438);
155return (etiss_uint32)(etiss_get_cycles(cpu, system, plugin_pointers));
156etiss_coverage_count(2, 443, 441);
157} // conditional
159if (csr == 3200ULL) { // conditional
160etiss_coverage_count(2, 448, 446);
162return (etiss_uint32)((etiss_get_cycles(cpu, system, plugin_pointers) >> 32ULL));
163etiss_coverage_count(5, 454, 451, 449, 450, 452);
164} // conditional
166if (csr == 3073ULL) { // conditional
167etiss_coverage_count(2, 459, 457);
169return (etiss_uint32)(etiss_get_time());
170etiss_coverage_count(2, 462, 460);
171} // conditional
173if (csr == 3201ULL) { // conditional
174etiss_coverage_count(2, 467, 465);
176return (etiss_uint32)((etiss_get_time() >> 32ULL));
177etiss_coverage_count(5, 473, 470, 468, 469, 471);
178} // conditional
180if (csr == 3074ULL) { // conditional
181etiss_coverage_count(2, 478, 476);
183return (etiss_uint32)(etiss_get_instret(cpu, system, plugin_pointers));
184etiss_coverage_count(2, 481, 479);
185} // conditional
187if (csr == 3202ULL) { // conditional
188etiss_coverage_count(2, 486, 484);
190return (etiss_uint32)((etiss_get_instret(cpu, system, plugin_pointers) >> 32ULL));
191etiss_coverage_count(5, 492, 489, 487, 488, 490);
192} // conditional
194if (csr == 768ULL || csr == 256ULL) { // conditional
195etiss_coverage_count(5, 501, 497, 495, 500, 498);
197return (etiss_uint32)((*((RV32IMACFD*)cpu)->CSR[768ULL] | 8589934592ULL | 34359738368ULL));
198etiss_coverage_count(5, 523, 520, 512, 504, 521);
199} // conditional
201if (csr == 769ULL) { // conditional
202etiss_coverage_count(2, 528, 526);
204return (((1ULL) << 30) | (((*((RV32IMACFD*)cpu)->CSR[769ULL]) & 0x3fffffffULL)));
205etiss_coverage_count(4, 543, 542, 537, 541);
206} // conditional
208return *((RV32IMACFD*)cpu)->CSR[csr];
209etiss_coverage_count(2, 547, 546);
210} // block
211}
212
213void RV32IMACFD_csr_write(ETISS_CPU * const cpu, ETISS_System * const system, void * const * const plugin_pointers, etiss_uint32 csr, etiss_uint32 val)
214{
216{ // block
219if (csr == 1ULL) { // conditional
220etiss_coverage_count(2, 553, 551);
221*((RV32IMACFD*)cpu)->CSR[3ULL] = (*((RV32IMACFD*)cpu)->CSR[3ULL] & 224ULL) | (val & 31ULL);
222etiss_coverage_count(10, 586, 571, 585, 579, 574, 580, 583, 581, 582, 584);
223} // conditional
224 else if (csr == 2ULL) { // conditional
225etiss_coverage_count(2, 556, 554);
226*((RV32IMACFD*)cpu)->CSR[3ULL] = ((val & 7ULL) << 5ULL) | (*((RV32IMACFD*)cpu)->CSR[3ULL] & 31ULL);
227etiss_coverage_count(14, 604, 589, 603, 595, 592, 590, 591, 593, 594, 596, 601, 599, 600, 602);
228} // conditional
229 else if (csr == 3ULL) { // conditional
230etiss_coverage_count(2, 559, 557);
231*((RV32IMACFD*)cpu)->CSR[3ULL] = val & 255ULL;
232etiss_coverage_count(5, 611, 607, 610, 608, 609);
233} // conditional
234 else if (csr == 768ULL) { // conditional
235etiss_coverage_count(2, 562, 560);
236*((RV32IMACFD*)cpu)->CSR[768ULL] = val & RV32IMACFD_mstatus_mask(cpu, system, plugin_pointers);
237etiss_coverage_count(5, 618, 614, 617, 615, 616);
238} // conditional
239 else if (csr == 256ULL) { // conditional
240etiss_coverage_count(2, 565, 563);
241*((RV32IMACFD*)cpu)->CSR[768ULL] = val & RV32IMACFD_sstatus_mask(cpu, system, plugin_pointers);
242etiss_coverage_count(5, 625, 621, 624, 622, 623);
243} // conditional
244 else if (csr != 769ULL) { // conditional
245etiss_coverage_count(2, 568, 566);
246*((RV32IMACFD*)cpu)->CSR[csr] = val;
247etiss_coverage_count(4, 630, 628, 627, 629);
248} // conditional
249} // block
250}
251
253{
255{ // block
258if (!(val)) { // conditional
259etiss_coverage_count(2, 634, 633);
261return 0LL;
263} // conditional
264etiss_uint8 res = 0LL;
265etiss_coverage_count(2, 639, 638);
267if ((val << 32ULL) == 0LL) { // conditional
268etiss_coverage_count(6, 646, 643, 641, 642, 644, 645);
269{ // block
271res = res + 32ULL;
272etiss_coverage_count(3, 649, 647, 648);
273val = val >> 32ULL;
274etiss_coverage_count(3, 652, 650, 651);
275} // block
276} // conditional
278if ((val << 48ULL) == 0LL) { // conditional
279etiss_coverage_count(6, 660, 657, 655, 656, 658, 659);
280{ // block
282res = res + 16ULL;
283etiss_coverage_count(3, 663, 661, 662);
284val = val >> 16ULL;
285etiss_coverage_count(3, 666, 664, 665);
286} // block
287} // conditional
289if ((val << 56ULL) == 0LL) { // conditional
290etiss_coverage_count(6, 674, 671, 669, 670, 672, 673);
291{ // block
293res = res + 8ULL;
294etiss_coverage_count(3, 677, 675, 676);
295val = val >> 8ULL;
296etiss_coverage_count(3, 680, 678, 679);
297} // block
298} // conditional
300if ((val << 60ULL) == 0LL) { // conditional
301etiss_coverage_count(6, 688, 685, 683, 684, 686, 687);
302{ // block
304res = res + 4ULL;
305etiss_coverage_count(3, 691, 689, 690);
306val = val >> 4ULL;
307etiss_coverage_count(3, 694, 692, 693);
308} // block
309} // conditional
311if ((val << 62ULL) == 0LL) { // conditional
312etiss_coverage_count(6, 702, 699, 697, 698, 700, 701);
313{ // block
315res = res + 2ULL;
316etiss_coverage_count(3, 705, 703, 704);
317val = val >> 2ULL;
318etiss_coverage_count(3, 708, 706, 707);
319} // block
320} // conditional
322if ((val << 63ULL) == 0LL) { // conditional
323etiss_coverage_count(6, 716, 713, 711, 712, 714, 715);
324{ // block
326res = res + 1ULL;
327etiss_coverage_count(3, 719, 717, 718);
328} // block
329} // conditional
331return res;
333} // block
334}
335
336void RV32IMACFD_raise(ETISS_CPU * const cpu, ETISS_System * const system, void * const * const plugin_pointers, etiss_int32 irq, etiss_uint32 mcause)
337{
338cpu->return_pending = 1;
339cpu->exception = 0;
341{ // block
344etiss_coverage_count(2, 726, 725);
345etiss_int32 deleg = 0LL;
347etiss_int32 vector = 0LL;
349etiss_int32 bit = mcause;
350etiss_coverage_count(2, 731, 730);
351etiss_int32 irq2 = (mcause & 2147483648ULL) != 0LL;
352etiss_coverage_count(6, 747, 746, 743, 733, 744, 745);
354if (irq2) { // conditional
356{ // block
358deleg = (etiss_uint32)((((((RV32IMACFD*)cpu)->PRIV <= 1ULL)) ? (*((RV32IMACFD*)cpu)->CSR[771ULL]) : (0LL)));
359etiss_coverage_count(10, 763, 750, 762, 759, 753, 751, 754, 757, 758, 760);
360bit = bit & 2147483647ULL;
361etiss_coverage_count(2, 779, 764);
362} // block
363} // conditional
364else { // conditional
365{ // block
367deleg = (etiss_uint32)((((((RV32IMACFD*)cpu)->PRIV <= 1ULL)) ? (*((RV32IMACFD*)cpu)->CSR[770ULL]) : (0LL)));
368etiss_coverage_count(10, 794, 781, 793, 790, 784, 782, 785, 788, 789, 791);
369} // block
370} // conditional
372if (((RV32IMACFD*)cpu)->PRIV <= 1ULL && (deleg >> bit) & 1ULL) { // conditional
373etiss_coverage_count(9, 806, 799, 797, 805, 802, 800, 801, 803, 804);
374{ // block
376vector = (etiss_uint32)((((*((RV32IMACFD*)cpu)->CSR[261ULL] & 1ULL) && irq2) ? (((etiss_int64)(bit) * (etiss_int64)(4ULL))) : (0LL)));
377etiss_coverage_count(15, 824, 807, 823, 820, 815, 812, 810, 811, 813, 814, 818, 816, 817, 819, 821);
378cpu->nextPc = (etiss_uint32)(((*((RV32IMACFD*)cpu)->CSR[261ULL] & -2LL) + vector));
379etiss_coverage_count(9, 840, 825, 839, 836, 833, 828, 834, 835, 837);
380*((RV32IMACFD*)cpu)->CSR[321ULL] = epc;
381etiss_coverage_count(3, 845, 843, 844);
382*((RV32IMACFD*)cpu)->CSR[322ULL] = mcause;
383etiss_coverage_count(3, 850, 848, 849);
384etiss_uint32 s = RV32IMACFD_csr_read(cpu, system, plugin_pointers, 256ULL);
385etiss_coverage_count(2, 854, 853);
387etiss_coverage_count(7, 864, 855, 863, 861, 856, 860, 858);
388s = (etiss_uint32)(RV32IMACFD_set_field(s, 256ULL, ((RV32IMACFD*)cpu)->PRIV));
389etiss_coverage_count(6, 872, 865, 871, 869, 866, 868);
390s = (etiss_uint32)(RV32IMACFD_set_field(s, 2ULL, 0LL));
391etiss_coverage_count(6, 880, 873, 879, 877, 874, 876);
392RV32IMACFD_csr_write(cpu, system, plugin_pointers, 256ULL, s);
393etiss_coverage_count(2, 883, 882);
394((RV32IMACFD*)cpu)->PRIV = (1ULL) & 0x7ULL;
395etiss_coverage_count(2, 888, 884);
396} // block
397} // conditional
398else { // conditional
399{ // block
401vector = (etiss_uint32)((((*((RV32IMACFD*)cpu)->CSR[773ULL] & 1ULL) && irq2) ? (((etiss_int64)(bit) * (etiss_int64)(4ULL))) : (0LL)));
402etiss_coverage_count(15, 907, 890, 906, 903, 898, 895, 893, 894, 896, 897, 901, 899, 900, 902, 904);
403cpu->nextPc = (etiss_uint32)(((*((RV32IMACFD*)cpu)->CSR[773ULL] & -2LL) + vector));
404etiss_coverage_count(9, 923, 908, 922, 919, 916, 911, 917, 918, 920);
405*((RV32IMACFD*)cpu)->CSR[833ULL] = epc;
406etiss_coverage_count(3, 928, 926, 927);
407*((RV32IMACFD*)cpu)->CSR[834ULL] = mcause;
408etiss_coverage_count(3, 933, 931, 932);
409etiss_uint32 s = RV32IMACFD_csr_read(cpu, system, plugin_pointers, 768ULL);
410etiss_coverage_count(2, 937, 936);
412etiss_coverage_count(7, 947, 938, 946, 944, 939, 943, 941);
413s = (etiss_uint32)(RV32IMACFD_set_field(s, 6144ULL, ((RV32IMACFD*)cpu)->PRIV));
414etiss_coverage_count(6, 955, 948, 954, 952, 949, 951);
415s = (etiss_uint32)(RV32IMACFD_set_field(s, 8ULL, 0LL));
416etiss_coverage_count(6, 963, 956, 962, 960, 957, 959);
417RV32IMACFD_csr_write(cpu, system, plugin_pointers, 768ULL, s);
418etiss_coverage_count(2, 966, 965);
419((RV32IMACFD*)cpu)->PRIV = (3ULL) & 0x7ULL;
420etiss_coverage_count(2, 971, 967);
421} // block
422} // conditional
423} // block
424}
425
426void RV32IMACFD_translate_exc_code(ETISS_CPU * const cpu, ETISS_System * const system, void * const * const plugin_pointers, etiss_int32 cause)
427{
429{ // block
430etiss_coverage_count(1, 1030);
431etiss_uint32 code = 0LL;
432etiss_coverage_count(2, 977, 976);
434if (cause == -2147483648LL) { // conditional
435etiss_coverage_count(2, 981, 979);
436etiss_coverage_count(1, 1000);
437return;
438} // conditional
439 else if (cause == -5LL) { // conditional
440etiss_coverage_count(2, 984, 982);
441code = 5ULL;
442etiss_coverage_count(2, 1003, 1001);
443} // conditional
444 else if (cause == -14LL) { // conditional
445etiss_coverage_count(2, 987, 985);
446code = 13ULL;
447etiss_coverage_count(2, 1006, 1004);
448} // conditional
449 else if (cause == -6LL) { // conditional
450etiss_coverage_count(2, 990, 988);
451code = 7ULL;
452etiss_coverage_count(2, 1009, 1007);
453} // conditional
454 else if (cause == -15LL) { // conditional
455etiss_coverage_count(2, 993, 991);
456code = 15ULL;
457etiss_coverage_count(2, 1012, 1010);
458} // conditional
459 else if (cause == -7LL) { // conditional
460etiss_coverage_count(2, 996, 994);
461code = 1ULL;
462etiss_coverage_count(2, 1015, 1013);
463} // conditional
464 else if (cause == -9LL) { // conditional
465etiss_coverage_count(2, 999, 997);
466{ // block
467etiss_coverage_count(1, 1023);
468code = RV32IMACFD_calc_irq_mcause(cpu, system, plugin_pointers);
469etiss_coverage_count(3, 1018, 1016, 1017);
470etiss_coverage_count(1, 1019);
471if (!(code)) { // conditional
472etiss_coverage_count(2, 1021, 1020);
473etiss_coverage_count(1, 1022);
474return;
475} // conditional
476} // block
477} // conditional
478else { // conditional
479code = 2ULL;
480etiss_coverage_count(2, 1026, 1024);
481} // conditional
482RV32IMACFD_raise(cpu, system, plugin_pointers, 0LL, code);
483etiss_coverage_count(3, 1029, 1027, 1028);
484} // block
485}
486
487etiss_uint32 RV32IMACFD_calc_irq_mcause(ETISS_CPU * const cpu, ETISS_System * const system, void * const * const plugin_pointers)
488{
490{ // block
491etiss_coverage_count(1, 1221);
492etiss_uint32 pending_interrupts = *((RV32IMACFD*)cpu)->CSR[772ULL] & *((RV32IMACFD*)cpu)->CSR[836ULL];
493etiss_coverage_count(4, 1039, 1038, 1034, 1037);
494etiss_coverage_count(1, 1040);
495if (!(pending_interrupts)) { // conditional
496etiss_coverage_count(2, 1042, 1041);
497etiss_coverage_count(1, 1044);
498return 0LL;
499etiss_coverage_count(1, 1043);
500} // conditional
501etiss_uint32 mie = (etiss_uint32)(RV32IMACFD_get_field(*((RV32IMACFD*)cpu)->CSR[768ULL], 8ULL));
502etiss_coverage_count(4, 1053, 1052, 1050, 1048);
503etiss_uint32 m_enabled = ((RV32IMACFD*)cpu)->PRIV < 3ULL || (((RV32IMACFD*)cpu)->PRIV == 3ULL && mie);
504etiss_coverage_count(9, 1065, 1064, 1057, 1055, 1062, 1060, 1058, 1061, 1063);
505etiss_uint32 enabled_interrupts = (etiss_uint32)((pending_interrupts & ~(*((RV32IMACFD*)cpu)->CSR[771ULL]) & -(m_enabled)));
506etiss_coverage_count(10, 1079, 1078, 1075, 1072, 1067, 1071, 1070, 1074, 1073, 1076);
507etiss_coverage_count(1, 1080);
508if (enabled_interrupts == 0LL) { // conditional
509etiss_coverage_count(3, 1083, 1081, 1082);
510{ // block
511etiss_coverage_count(1, 1120);
512etiss_uint32 deleg = *((RV32IMACFD*)cpu)->CSR[771ULL];
513etiss_coverage_count(2, 1088, 1087);
514etiss_uint32 sie = (etiss_uint32)(RV32IMACFD_get_field(RV32IMACFD_csr_read(cpu, system, plugin_pointers, 256ULL), 2ULL));
515etiss_coverage_count(4, 1096, 1095, 1093, 1091);
516etiss_uint32 s_enabled = ((RV32IMACFD*)cpu)->PRIV < 1ULL || (((RV32IMACFD*)cpu)->PRIV == 1ULL && sie);
517etiss_coverage_count(9, 1108, 1107, 1100, 1098, 1105, 1103, 1101, 1104, 1106);
518enabled_interrupts = (etiss_uint32)((pending_interrupts & deleg & -(s_enabled)));
519etiss_coverage_count(10, 1119, 1109, 1118, 1115, 1112, 1110, 1111, 1114, 1113, 1116);
520} // block
521} // conditional
522etiss_coverage_count(1, 1121);
523if (enabled_interrupts) { // conditional
524etiss_coverage_count(1, 1122);
525{ // block
526etiss_coverage_count(1, 1218);
527etiss_coverage_count(1, 1123);
528if (enabled_interrupts >> 12ULL) { // conditional
529etiss_coverage_count(2, 1129, 1124);
530enabled_interrupts = enabled_interrupts >> 12ULL << 12ULL;
531etiss_coverage_count(5, 1172, 1160, 1171, 1166, 1161);
532} // conditional
533 else if (enabled_interrupts & 2048ULL) { // conditional
534etiss_coverage_count(2, 1132, 1130);
535enabled_interrupts = 2048ULL;
536etiss_coverage_count(2, 1175, 1173);
537} // conditional
538 else if (enabled_interrupts & 8ULL) { // conditional
539etiss_coverage_count(2, 1135, 1133);
540enabled_interrupts = 8ULL;
541etiss_coverage_count(2, 1178, 1176);
542} // conditional
543 else if (enabled_interrupts & 128ULL) { // conditional
544etiss_coverage_count(2, 1138, 1136);
545enabled_interrupts = 128ULL;
546etiss_coverage_count(2, 1181, 1179);
547} // conditional
548 else if (enabled_interrupts & 512ULL) { // conditional
549etiss_coverage_count(2, 1141, 1139);
550enabled_interrupts = 512ULL;
551etiss_coverage_count(2, 1184, 1182);
552} // conditional
553 else if (enabled_interrupts & 2ULL) { // conditional
554etiss_coverage_count(2, 1144, 1142);
555enabled_interrupts = 2ULL;
556etiss_coverage_count(2, 1187, 1185);
557} // conditional
558 else if (enabled_interrupts & 32ULL) { // conditional
559etiss_coverage_count(2, 1147, 1145);
560enabled_interrupts = 32ULL;
561etiss_coverage_count(2, 1190, 1188);
562} // conditional
563 else if (enabled_interrupts & 8192ULL) { // conditional
564etiss_coverage_count(2, 1150, 1148);
565enabled_interrupts = 8192ULL;
566etiss_coverage_count(2, 1193, 1191);
567} // conditional
568 else if (enabled_interrupts & 1024ULL) { // conditional
569etiss_coverage_count(2, 1153, 1151);
570enabled_interrupts = 1024ULL;
571etiss_coverage_count(2, 1196, 1194);
572} // conditional
573 else if (enabled_interrupts & 4ULL) { // conditional
574etiss_coverage_count(2, 1156, 1154);
575enabled_interrupts = 4ULL;
576etiss_coverage_count(2, 1199, 1197);
577} // conditional
578 else if (enabled_interrupts & 64ULL) { // conditional
579etiss_coverage_count(2, 1159, 1157);
580enabled_interrupts = 64ULL;
581etiss_coverage_count(2, 1202, 1200);
582} // conditional
583else { // conditional
584etiss_coverage_count(1, 1204);
585return 0LL;
586etiss_coverage_count(1, 1203);
587} // conditional
588etiss_coverage_count(1, 1217);
589return 2147483648ULL | RV32IMACFD_ctz(enabled_interrupts);
590etiss_coverage_count(3, 1216, 1215, 1214);
591} // block
592} // conditional
593etiss_coverage_count(1, 1220);
594return 0LL;
595etiss_coverage_count(1, 1219);
596} // block
597}
598
599void RV32IMACFD_check_irq(ETISS_CPU * const cpu, ETISS_System * const system, void * const * const plugin_pointers)
600{
602{ // block
603etiss_coverage_count(1, 1230);
604etiss_uint32 irq_mcause = RV32IMACFD_calc_irq_mcause(cpu, system, plugin_pointers);
605etiss_coverage_count(2, 1224, 1223);
606etiss_coverage_count(1, 1225);
607if (irq_mcause) { // conditional
608etiss_coverage_count(1, 1226);
609RV32IMACFD_raise(cpu, system, plugin_pointers, 1ULL, irq_mcause);
610etiss_coverage_count(3, 1229, 1227, 1228);
611} // conditional
612} // block
613}
614// clang-format on
void RV32IMACFD_translate_exc_code(ETISS_CPU *const cpu, ETISS_System *const system, void *const *const plugin_pointers, etiss_int32 cause)
etiss_uint64 RV32IMACFD_get_field(etiss_uint64 reg, etiss_uint64 mask)
void RV32IMACFD_check_irq(ETISS_CPU *const cpu, ETISS_System *const system, void *const *const plugin_pointers)
etiss_uint64 RV32IMACFD_set_field(etiss_uint64 reg, etiss_uint64 mask, etiss_uint64 val)
void RV32IMACFD_csr_write(ETISS_CPU *const cpu, ETISS_System *const system, void *const *const plugin_pointers, etiss_uint32 csr, etiss_uint32 val)
etiss_uint8 RV32IMACFD_ctz(etiss_uint64 val)
etiss_uint8 RV32IMACFD_get_rm(ETISS_CPU *const cpu, ETISS_System *const system, void *const *const plugin_pointers, etiss_uint8 rm)
etiss_uint32 RV32IMACFD_sstatus_mask(ETISS_CPU *const cpu, ETISS_System *const system, void *const *const plugin_pointers)
etiss_uint32 RV32IMACFD_mstatus_mask(ETISS_CPU *const cpu, ETISS_System *const system, void *const *const plugin_pointers)
etiss_uint8 RV32IMACFD_extension_enabled(ETISS_CPU *const cpu, ETISS_System *const system, void *const *const plugin_pointers, etiss_int8 extension)
Generated on Wed, 28 Oct 2026 07:21:01 +0000.
etiss_uint32 RV32IMACFD_calc_irq_mcause(ETISS_CPU *const cpu, ETISS_System *const system, void *const *const plugin_pointers)
void RV32IMACFD_raise(ETISS_CPU *const cpu, ETISS_System *const system, void *const *const plugin_pointers, etiss_int32 irq, etiss_uint32 mcause)
etiss_uint32 RV32IMACFD_csr_read(ETISS_CPU *const cpu, ETISS_System *const system, void *const *const plugin_pointers, etiss_uint32 csr)
__device__ __2f16 float bool s
#define etiss_coverage_count(...)
Definition Coverage.h:18
etiss_uint64 etiss_get_instret(ETISS_CPU *const cpu, ETISS_System *const system, void *const *const plugin_pointers)
etiss_uint64 etiss_get_time()
etiss_uint64 etiss_get_cycles(ETISS_CPU *const cpu, ETISS_System *const system, void *const *const plugin_pointers)
uint64_t etiss_uint64
Definition types.h:58
uint32_t etiss_uint32
Definition types.h:55
int64_t etiss_int64
Definition types.h:57
int8_t etiss_int8
Definition types.h:48
uint8_t etiss_uint8
Definition types.h:49
int32_t etiss_int32
Definition types.h:54
basic cpu state structure needed for execution of any cpu architecture.
Definition CPU.h:51
etiss_uint64 instructionPointer
pointer to next instruction.
Definition CPU.h:54
etiss_uint32 exception
Definition CPU.h:73
etiss_uint32 return_pending
Definition CPU.h:74
memory access and time synchronization functions.
Definition System.h:40
Generated on Wed, 28 Oct 2026 07:21:01 +0000.
Definition RV32IMACFD.h:17