2 use ieee.std_logic_1164.all;
3 use ieee.numeric_std.all;
6 use work.decode_types.all;
9 use work.insn_helpers.all;
16 complete_in : in std_ulogic;
17 stall_out : out std_ulogic;
19 flush_in: in std_ulogic;
21 d_in : in Decode1ToDecode2Type;
23 e_out : out Decode2ToExecute1Type;
24 m_out : out Decode2ToMultiplyType;
25 l_out : out Decode2ToLoadstore1Type;
27 r_in : in RegisterFileToDecode2Type;
28 r_out : out Decode2ToRegisterFileType;
30 c_in : in CrFileToDecode2Type;
31 c_out : out Decode2ToCrFileType
35 architecture behaviour of decode2 is
36 type state_type is (IDLE, WAIT_FOR_PREV_TO_COMPLETE, WAIT_FOR_CURR_TO_COMPLETE);
38 type reg_internal_type is record
40 outstanding : integer;
43 type reg_type is record
44 e : Decode2ToExecute1Type;
45 m : Decode2ToMultiplyType;
46 l : Decode2ToLoadstore1Type;
49 signal r_int, rin_int : reg_internal_type;
50 signal r, rin : reg_type;
52 type decode_input_reg_t is record
53 reg_valid : std_ulogic;
54 reg : std_ulogic_vector(4 downto 0);
55 data : std_ulogic_vector(63 downto 0);
58 function decode_input_reg_a (t : input_reg_a_t; insn_in : std_ulogic_vector(31 downto 0);
59 reg_data : std_ulogic_vector(63 downto 0)) return decode_input_reg_t is
63 return ('1', insn_ra(insn_in), reg_data);
65 return ('1', insn_ra(insn_in), ra_or_zero(reg_data, insn_ra(insn_in)));
67 return ('1', insn_rs(insn_in), reg_data);
69 return ('0', (others => '0'), (others => '0'));
73 function decode_input_reg_b (t : input_reg_b_t; insn_in : std_ulogic_vector(31 downto 0);
74 reg_data : std_ulogic_vector(63 downto 0)) return decode_input_reg_t is
78 return ('1', insn_rb(insn_in), reg_data);
80 return ('1', insn_rs(insn_in), reg_data);
82 return ('0', (others => '0'), std_ulogic_vector(resize(unsigned(insn_ui(insn_in)), 64)));
84 return ('0', (others => '0'), std_ulogic_vector(resize(signed(insn_si(insn_in)), 64)));
86 return ('0', (others => '0'), std_ulogic_vector(resize(signed(insn_si(insn_in)) & x"0000", 64)));
88 return ('0', (others => '0'), std_ulogic_vector(resize(unsigned(insn_si(insn_in)) & x"0000", 64)));
90 return ('0', (others => '0'), std_ulogic_vector(resize(signed(insn_li(insn_in)) & "00", 64)));
92 return ('0', (others => '0'), std_ulogic_vector(resize(signed(insn_bd(insn_in)) & "00", 64)));
94 return ('0', (others => '0'), std_ulogic_vector(resize(signed(insn_ds(insn_in)) & "00", 64)));
96 return ('0', (others => '0'), (others => '0'));
100 function decode_input_reg_c (t : input_reg_c_t; insn_in : std_ulogic_vector(31 downto 0);
101 reg_data : std_ulogic_vector(63 downto 0)) return decode_input_reg_t is
105 return ('1', insn_rs(insn_in), reg_data);
107 return ('0', (others => '0'), (others => '0'));
111 function decode_output_reg (t : output_reg_a_t; insn_in : std_ulogic_vector(31 downto 0)) return std_ulogic_vector is
115 return insn_rt(insn_in);
117 return insn_ra(insn_in);
123 function decode_const_a (t : constant_a_t; insn_in : std_ulogic_vector(31 downto 0)) return std_ulogic_vector is
127 return "00" & insn_sh(insn_in);
129 return "000" & insn_sh32(insn_in);
131 return insn_fxm(insn_in);
133 return "000" & insn_bo(insn_in);
135 return "00000" & insn_bf(insn_in);
137 return "000" & insn_to(insn_in);
139 return "000" & insn_bc(insn_in);
145 function decode_const_b (t : constant_b_t; insn_in : std_ulogic_vector(31 downto 0)) return std_ulogic_vector is
149 return insn_mb(insn_in);
151 return insn_me(insn_in);
153 return "0" & insn_mb32(insn_in);
155 return "0" & insn_bi(insn_in);
157 return "00000" & insn_l(insn_in);
163 function decode_const_c (t : constant_c_t; insn_in : std_ulogic_vector(31 downto 0)) return std_ulogic_vector is
167 return insn_me32(insn_in);
169 return "000" & insn_bh(insn_in);
175 function decode_rc (t : rc_t; insn_in : std_ulogic_vector(31 downto 0)) return std_ulogic is
179 return insn_rc(insn_in);
188 decode2_0: process(clk)
190 if rising_edge(clk) then
191 assert r_int.outstanding <= 1 report "Outstanding bad " & integer'image(r_int.outstanding) severity failure;
193 if rin.e.valid = '1' or rin.l.valid = '1' or rin.m.valid = '1' then
194 report "execute " & to_hstring(rin.e.nia);
201 r_out.read1_reg <= insn_ra(d_in.insn) when (d_in.decode.input_reg_a = RA) else
202 insn_ra(d_in.insn) when d_in.decode.input_reg_a = RA_OR_ZERO else
203 insn_rs(d_in.insn) when d_in.decode.input_reg_a = RS else
206 r_out.read2_reg <= insn_rb(d_in.insn) when d_in.decode.input_reg_b = RB else
207 insn_rs(d_in.insn) when d_in.decode.input_reg_b = RS else
210 r_out.read3_reg <= insn_rs(d_in.insn) when d_in.decode.input_reg_c = RS else
213 c_out.read <= d_in.decode.input_cr;
215 decode2_1: process(all)
216 variable v : reg_type;
217 variable v_int : reg_internal_type;
218 variable mul_a : std_ulogic_vector(63 downto 0);
219 variable mul_b : std_ulogic_vector(63 downto 0);
220 variable decoded_reg_a : decode_input_reg_t;
221 variable decoded_reg_b : decode_input_reg_t;
222 variable decoded_reg_c : decode_input_reg_t;
223 variable is_valid : std_ulogic;
228 v.e := Decode2ToExecute1Init;
229 v.l := Decode2ToLoadStore1Init;
230 v.m := Decode2ToMultiplyInit;
232 mul_a := (others => '0');
233 mul_b := (others => '0');
235 --v.e.input_cr := d_in.decode.input_cr;
236 --v.m.input_cr := d_in.decode.input_cr;
237 --v.e.output_cr := d_in.decode.output_cr;
239 decoded_reg_a := decode_input_reg_a (d_in.decode.input_reg_a, d_in.insn, r_in.read1_data);
240 decoded_reg_b := decode_input_reg_b (d_in.decode.input_reg_b, d_in.insn, r_in.read2_data);
241 decoded_reg_c := decode_input_reg_c (d_in.decode.input_reg_c, d_in.insn, r_in.read3_data);
243 r_out.read1_enable <= decoded_reg_a.reg_valid;
244 r_out.read2_enable <= decoded_reg_b.reg_valid;
245 r_out.read3_enable <= decoded_reg_c.reg_valid;
249 v.e.insn_type := d_in.decode.insn_type;
250 v.e.read_reg1 := decoded_reg_a.reg;
251 v.e.read_data1 := decoded_reg_a.data;
252 v.e.read_reg2 := decoded_reg_b.reg;
253 v.e.read_data2 := decoded_reg_b.data;
254 v.e.write_reg := decode_output_reg(d_in.decode.output_reg_a, d_in.insn);
255 v.e.rc := decode_rc(d_in.decode.rc, d_in.insn);
256 v.e.cr := c_in.read_cr_data;
257 v.e.input_carry := d_in.decode.input_carry;
258 v.e.output_carry := d_in.decode.output_carry;
259 if d_in.decode.lr = '1' then
260 v.e.lr := insn_lk(d_in.insn);
262 v.e.const1 := decode_const_a(d_in.decode.const_a, d_in.insn);
263 v.e.const2 := decode_const_b(d_in.decode.const_b, d_in.insn);
264 v.e.const3 := decode_const_c(d_in.decode.const_c, d_in.insn);
267 v.m.insn_type := d_in.decode.insn_type;
268 mul_a := decoded_reg_a.data;
269 mul_b := decoded_reg_b.data;
270 v.m.write_reg := decode_output_reg(d_in.decode.output_reg_a, d_in.insn);
271 v.m.rc := decode_rc(d_in.decode.rc, d_in.insn);
273 if d_in.decode.mul_32bit = '1' then
274 if d_in.decode.mul_signed = '1' then
275 v.m.data1 := (others => mul_a(31));
276 v.m.data1(31 downto 0) := mul_a(31 downto 0);
277 v.m.data2 := (others => mul_b(31));
278 v.m.data2(31 downto 0) := mul_b(31 downto 0);
280 v.m.data1 := '0' & x"00000000" & mul_a(31 downto 0);
281 v.m.data2 := '0' & x"00000000" & mul_b(31 downto 0);
284 if d_in.decode.mul_signed = '1' then
285 v.m.data1 := mul_a(63) & mul_a;
286 v.m.data2 := mul_b(63) & mul_b;
288 v.m.data1 := '0' & mul_a;
289 v.m.data2 := '0' & mul_b;
294 v.l.update_reg := decoded_reg_a.reg;
295 v.l.addr1 := decoded_reg_a.data;
296 v.l.addr2 := decoded_reg_b.data;
297 v.l.data := decoded_reg_c.data;
298 v.l.write_reg := decode_output_reg(d_in.decode.output_reg_a, d_in.insn);
300 if d_in.decode.insn_type = OP_LOAD then
306 case d_in.decode.length is
308 v.l.length := "0001";
310 v.l.length := "0010";
312 v.l.length := "0100";
314 v.l.length := "1000";
316 v.l.length := "0000";
319 v.l.byte_reverse := d_in.decode.byte_reverse;
320 v.l.sign_extend := d_in.decode.sign_extend;
321 v.l.update := d_in.decode.update;
325 if complete_in = '1' then
326 v_int.outstanding := v_int.outstanding - 1;
329 -- state machine to handle instructions that must be single
330 -- through the pipeline.
332 is_valid := d_in.valid;
335 if (flush_in = '0') and (d_in.valid = '1') and (d_in.decode.sgl_pipe = '1') then
336 if v_int.outstanding /= 0 then
337 v_int.state := WAIT_FOR_PREV_TO_COMPLETE;
341 -- send insn out and wait on it to complete
342 v_int.state := WAIT_FOR_CURR_TO_COMPLETE;
346 when WAIT_FOR_PREV_TO_COMPLETE =>
347 if v_int.outstanding = 0 then
348 -- send insn out and wait on it to complete
349 v_int.state := WAIT_FOR_CURR_TO_COMPLETE;
355 when WAIT_FOR_CURR_TO_COMPLETE =>
356 if v_int.outstanding = 0 then
367 case d_in.decode.unit is
369 v.e.valid := is_valid;
371 v.l.valid := is_valid;
373 v.m.valid := is_valid;
375 v.e.valid := is_valid;
376 v.e.insn_type := OP_ILLEGAL;
379 if flush_in = '1' then
385 -- track outstanding instructions
386 if v.e.valid = '1' or v.l.valid = '1' or v.m.valid = '1' then
387 v_int.outstanding := v_int.outstanding + 1;
392 v_int.outstanding := 0;
393 v.e := Decode2ToExecute1Init;
394 v.l := Decode2ToLoadStore1Init;
395 v.m := Decode2ToMultiplyInit;
407 end architecture behaviour;