1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
|
/* The emulator fetch-execute-interrupt dispatch loop. */
/* returns whether to increment the step count in the trace */
val step : int -> bool effect {barr, eamem, escape, exmem, rmem, rreg, wmv, wmvt, wreg}
function step(step_no) = {
/* for step extensions */
ext_pre_step_hook();
minstret_written = false; /* see note for minstret */
let (retired, stepped) : (Retired, bool) =
match dispatchInterrupt(cur_privilege) {
Some(intr, priv) => {
if get_config_print_instr() then
print_bits("Handling interrupt: ", intr);
handle_interrupt(intr, priv);
(RETIRE_FAIL, false)
},
None() => {
/* the extension hook interposes on the fetch result */
let f : FetchResult = ext_fetch_hook(fetch());
match f {
/* extension error */
F_Ext_Error(e) => {
ext_handle_fetch_check_error(e);
(RETIRE_FAIL, false)
},
/* standard error */
F_Error(e, addr) => {
handle_mem_exception(addr, e);
(RETIRE_FAIL, false)
},
/* non-error cases: */
F_RVC(h) => {
let ast = decodeCompressed(h);
if get_config_print_instr() then {
print_instr("[" ^ string_of_int(step_no) ^ "] [" ^ cur_privilege ^ "]: " ^ BitStr(PC) ^ " (" ^ BitStr(h) ^ ") " ^ ast);
};
/* check for RVC once here instead of every RVC execute clause. */
if haveRVC() then {
nextPC = PC + 2;
(execute(ext_post_decode_hook(ast)), true)
} else {
handle_illegal();
(RETIRE_FAIL, true)
}
},
F_Base(w) => {
let ast = decode(w);
if get_config_print_instr() then {
print_instr("[" ^ string_of_int(step_no) ^ "] [" ^ cur_privilege ^ "]: " ^ BitStr(PC) ^ " (" ^ BitStr(w) ^ ") " ^ ast);
};
nextPC = PC + 4;
(execute(ext_post_decode_hook(ast)), true)
}
}
}
};
tick_pc();
/* update minstret */
match retired {
RETIRE_SUCCESS => retire_instruction(),
RETIRE_FAIL => ()
};
/* for step extensions */
ext_post_step_hook();
stepped
}
val loop : unit -> unit effect {barr, eamem, escape, exmem, rmem, rreg, wmv, wmvt, wreg}
function loop () = {
let insns_per_tick = plat_insns_per_tick();
i : int = 0;
step_no : int = 0;
while (~ (htif_done)) do {
let stepped = step(step_no);
if stepped then step_no = step_no + 1;
/* check htif exit */
if htif_done then {
let exit_val = unsigned(htif_exit_code);
if exit_val == 0 then print("SUCCESS")
else print_int("FAILURE: ", exit_val);
} else {
/* update time */
i = i + 1;
if i == insns_per_tick then {
tick_clock();
/* for now, we drive the platform i/o at every clock tick. */
tick_platform();
i = 0;
}
}
}
}
/* initialize model state */
function init_model () -> unit = {
init_platform (); /* devices */
init_sys (); /* processor */
init_vmem (); /* virtual memory */
/* initialize extensions last */
ext_init ();
ext_init_regs ();
}
|
