riscv_decode.vhd

-------------------------------------------------------------------------------
-- Project  ELE8304 : Circuits intégrés à très grande échelle
-------------------------------------------------------------------------------
-- File     riscv_decode.vhd
-- Authors  Titouan Luard <luardtitouan@gmail.com> 
--          Yann Roberge <yann.roberge@polymtl.ca> 
-- Lab      ELE8304-9
-- Date     2021-11-28
-------------------------------------------------------------------------------
-- Brief    RISC-V Decode pipeline stage
--          Breaks down instructions into their specific components,
--          Reads from & Writes into the register file,
--          Generate outputs needed for the Execute stage
-------------------------------------------------------------------------------
library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
use ieee.math_real.all;

library work;
use work.riscv_pkg.all;

entity riscv_decode is
  port (
    -- Entrées provenant de l'étage FETCH
    i_fetch_reg : in fetch_reg;

    -- Entrées provenant de l'étage WRITE-BACK
    i_wr_addr : in std_logic_vector(REG_WIDTH-1 downto 0);
    i_wr_data : in std_logic_vector(XLEN-1 downto 0);
    i_we      : in std_logic;

    -- Entrée provenant de l'étage EXECUTE
    i_flush : in std_logic;

    -- Entrées externes au pipeline
    i_rstn : in std_logic;
    i_clk  : in std_logic;

    -- Sorties
    rs1_data : out std_logic_vector(XLEN-1 downto 0);
    rs2_data : out std_logic_vector(XLEN-1 downto 0);

    o_decode_reg : out decode_reg);
end entity riscv_decode;


architecture beh of riscv_decode is
  -- Signaux internes Predecode
  signal opcode : std_logic_vector(OPCODE_WIDTH-1 downto 0);
  signal funct3 : std_logic_vector(2 downto 0);
  signal funct7 : std_logic_vector(6 downto 0);
  signal rs1_addr : std_logic_vector(REG_WIDTH-1 downto 0);
  signal rs2_addr : std_logic_vector(REG_WIDTH-1 downto 0);
  signal rd  : std_logic_vector(REG_WIDTH-1 downto 0);

  -- opcode funct3 funct7 rs1 rs2
  -- jump
  -- branch
  -- imm

  -- Signaux internes Decode
  -- alu_opcode
  -- shamt
  -- arith
  -- sign
  signal jump   : std_logic;
  signal branch : std_logic;
  signal alu_opcode : std_logic_vector(ALUOP_WIDTH-1 downto 0);
  signal arith  : std_logic;
  signal shamt  : std_logic_vector(SHAMT_WIDTH-1 downto 0);
  signal sign   : std_logic;
  signal imm : std_logic_vector(XLEN-1 downto 0);

  alias instruction is i_fetch_reg.instruction;
begin

  -- Predecode
  -- Décompose les signaux en fonction de leurs types (opcodes)
  opcode <= i_fetch_reg.instruction(OPCODE_WIDTH-1 downto 0);

  predecode:
  process (opcode) is
  begin
    case opcode is
      -- R-TYPE
      -- FIXME: Le code répété
      when OPCODE_JALR =>
        funct7    <= instruction(31 downto 25);
        rs2_addr  <= instruction(24 downto 20);
        rs1_addr  <= instruction(19 downto 15);
        funct3    <= instruction(14 downto 12);
        rd        <= instruction(11 downto 7);

      when OPCODE_ALU_R_TYPE =>
        funct7    <= instruction(31 downto 25);
        rs2_addr  <= instruction(24 downto 20);
        rs1_addr  <= instruction(19 downto 15);
        funct3    <= instruction(14 downto 12);
        rd        <= instruction(11 downto 7);

      -- I-TYPE
      -- FIXME: Le code répété
      when OPCODE_LW =>
        funct7    <= (others => '0');
        rs2_addr  <= (others => '0');
        rs1_addr  <= instruction(19 downto 15);
        funct3    <= instruction(14 downto 12);
        rd        <= instruction(11 downto 7);

      when OPCODE_ALU_I_TYPE =>
        funct7    <= (others => '0');
        rs2_addr  <= (others => '0');
        rs1_addr  <= instruction(19 downto 15);
        funct3    <= instruction(14 downto 12);
        rd        <= instruction(11 downto 7);

      -- S-TYPE
      when OPCODE_SW =>
        funct7    <= (others => '0');
        rs2_addr  <= instruction(24 downto 20);
        rs1_addr  <= instruction(19 downto 15);
        funct3    <= instruction(14 downto 12);
        rd        <= (others => '0');

      -- B-TYPE
      when OPCODE_BEQ =>
        funct7    <= (others => '0');
        rs2_addr  <= instruction(24 downto 20);
        rs1_addr  <= instruction(19 downto 15);
        funct3    <= instruction(14 downto 12);
        rd        <= (others => '0');

      -- U-TYPE
      when OPCODE_LUI =>
        funct7    <= (others => '0');
        rs2_addr  <= (others => '0');
        rs1_addr  <= (others => '0');
        funct3    <= (others => '0');
        rd        <= instruction(11 downto 7);
       
      -- J-TYPE
      when OPCODE_JAL =>
        funct7    <= (others => '0');
        rs2_addr  <= (others => '0');
        rs1_addr  <= (others => '0');
        funct3    <= (others => '0');
        rd        <= instruction(11 downto 7);

      -- Unsupported instructions
      when others =>
        funct7    <= (others => '0');
        rs2_addr  <= (others => '0');
        rs1_addr  <= (others => '0');
        funct3    <= (others => '0');
        rd        <= (others => '0');
    end case;
       
  end process predecode;

  -- Gestion des valeurs immédiates
  immediate : process (opcode)
  begin
    case opcode is
      -- I-TYPE
      -- FIXME: Le code répété
      when OPCODE_LW =>
        imm(31 downto 11) <= (others => instruction(31));
        imm(10 downto 5)  <= instruction(30 downto 25);
        imm(4 downto 1)   <= instruction(24 downto 21);
        imm(0)            <= instruction(20);

      when OPCODE_ALU_I_TYPE =>
        imm(31 downto 11) <= (others => instruction(31));
        imm(10 downto 5)  <= instruction(30 downto 25);
        imm(4 downto 1)   <= instruction(24 downto 21);
        imm(0)            <= instruction(20);

      -- S-TYPE
      when OPCODE_SW =>
        imm(31 downto 11) <= (others => instruction(31));
        imm(10 downto 5)  <= instruction(30 downto 25);
        imm(4 downto 1)   <= instruction(11 downto 8);
        imm(0)            <= instruction(7);

      -- B-TYPE
      when OPCODE_BEQ =>
        imm(31 downto 12) <= (others => instruction(31));
        imm(11)           <= instruction(7);
        imm(10 downto 5)  <= instruction(30 downto 25);
        imm(4 downto 1)   <= instruction(11 downto 8);
        imm(0)            <= '0';

      -- U-TYPE
      when OPCODE_LUI =>
        -- FIXME: Pourquoi pas avoir compacté les 2 lignes suivantes
        -- à la figure 3 de l'énoncé?
        imm(31)           <= instruction(31);
        imm(30 downto 20) <= instruction(30 downto 20);
        imm(19 downto 12) <= instruction(19 downto 12);
        imm(11 downto 0)  <= (others => '0');
       
      -- J-TYPE
      when OPCODE_JAL =>
        imm(31 downto 20) <= (others => instruction(31));
        imm(19 downto 12) <= instruction(19 downto 12);
        imm(11)           <= instruction(20);
        imm(10 downto 5)  <= instruction(30 downto 25);
        imm(4 downto 1)   <= instruction(24 downto 21);
        imm(0)            <= '0';

      -- R-TYPE
      -- Unsupported instructions
      when others =>
        imm <= (others => '0');
    end case; 

  end process immediate;

  -- Instanciation du Register File
  register_file: entity work.riscv_rf
    port map (
      i_clk     => i_clk,
      i_rstn    => i_rstn,
      i_we      => i_we,
 
      i_addr_ra => rs1_addr,
      o_data_ra => rs1_data,
 
      i_addr_rb => rs2_addr,
      o_data_rb => rs2_data,
 
      i_addr_w  => i_wr_addr,
      i_data_w  => i_wr_data
    );

  -- Decode
  --signal jump   : std_logic;
  --signal branch : std_logic;
  decode_jump_decode:
  process (funct7, funct3, opcode) is
  begin
    case opcode is
      -- R-TYPE
      when OPCODE_JALR =>
        jump    <= '1';
        branch  <= '0';
        alu_opcode <= (others => '0');
        arith  <= '0';
        shamt  <= (others => '0');
        sign <= SIGN_UNSIGNED;

      when OPCODE_ALU_R_TYPE =>
        jump    <= '0';
        branch  <= '0';
        case funct3 is
          when FUNCT3_ADD =>
            -- FUNCT7 distingue la soustraction de l'addition
            -- toutes les opérations sont signées
            case funct7 is =>
              when FUNCT7_SUB_ARITH_SH =>
                arith  <= ARITH_SUBTRACT;
              when others =>
                arith  <= ARITH_ADD;
            end case;
            shamt  <= (others => '0');
            alu_opcode <= ALUOP_ADD;
            sign <= SIGN_SIGNED;
          
          when FUNCT3_SL =>
            jump    <= '0';
            branch  <= '0';
            alu_opcode <= ALUOP_SH_LEFT;
            arith  <= '0'; -- le shift gauche est toujours logique
            shamt  <= (others => '0');
            sign <= SIGN_UNSIGNED;

          when FUNCT3_SLT =>
          when FUNCT3_SLTU =>
          when FUNCT3_XOR =>
          when FUNCT3_SR =>
          when FUNCT3_OR =>
          when FUNCT3_AND =>
          
          when others =>
            -- on n'arrive jamais ici parce que toutes les
            -- possibilités de FUNCT3 sont couvertes par le code plus haut
            alu_opcode <= (others => '0');
            arith  <= '0';
            shamt  <= (others => '0');
            sign <= SIGN_UNSIGNED;

        end case;
        alu_opcode <= (others => '0');
        sign <= SIGN_UNSIGNED;

      -- I-TYPE
      when OPCODE_LW =>
        jump    <= '0';
        branch  <= '0';
        alu_opcode <= (others => '0');
        sign <= SIGN_UNSIGNED;

      when OPCODE_ALU_I_TYPE =>

      -- S-TYPE
      when OPCODE_SW =>
        jump    <= '0';
        branch  <= '0';
        alu_opcode <= (others => '0');
        sign <= SIGN_UNSIGNED;

      -- B-TYPE
      when OPCODE_BEQ =>
        jump    <= '0';
        branch  <= '1';
        alu_opcode <= (others => '0');
        sign <= SIGN_UNSIGNED;

      -- U-TYPE
      when OPCODE_LUI =>
        jump    <= '0';
        branch  <= '0';
        alu_opcode <= (others => '0');
        sign <= SIGN_UNSIGNED;
       
      -- J-TYPE
      when OPCODE_JAL =>
        jump    <= '1';
        branch  <= '0';
        alu_opcode <= (others => '0');
        sign <= SIGN_UNSIGNED;

      -- R-TYPE
      -- Unsupported instructions
      when others =>

    end case; 
  end process decode_jump_decode;

  --signal alu_opcode : std_logic_vector(ALUOP_WIDTH-1 downto 0);
  --signal arith  : std_logic;
  --signal shamt  : std_logic_vector(SHAMT_WIDTH-1 downto 0);
  --signal sign   : std_logic;
  decode_calc:
  process (funct7, funct3, opcode) is
  begin
    case opcode is
      -- R-TYPE
      when OPCODE_JALR =>
        jump    <= '1';
        branch  <= '0';
        alu_opcode <= (others => '0');
        arith  <= '0';
        shamt  <= (others => '0');
        sign <= SIGN_UNSIGNED;

      when OPCODE_ALU_R_TYPE =>
        jump    <= '0';
        branch  <= '0';
        case funct3 is
          when FUNCT3_ADD =>
            -- FUNCT7 distingue la soustraction de l'addition
            -- toutes les opérations sont signées
            case funct7 is =>
              when FUNCT7_SUB_ARITH_SH =>
                arith  <= ARITH_SUBTRACT;
              when others =>
                arith  <= ARITH_ADD;
            end case;
            shamt  <= (others => '0');
            alu_opcode <= ALUOP_ADD;
            sign <= SIGN_SIGNED;
          
          when FUNCT3_SL =>
            jump    <= '0';
            branch  <= '0';
            alu_opcode <= ALUOP_SH_LEFT;
            arith  <= '0'; -- le shift gauche est toujours logique
            shamt  <= (others => '0');
            sign <= SIGN_UNSIGNED;

          when FUNCT3_SLT =>
          when FUNCT3_SLTU =>
          when FUNCT3_XOR =>
          when FUNCT3_SR =>
          when FUNCT3_OR =>
          when FUNCT3_AND =>
          
          when others =>
            -- on n'arrive jamais ici parce que toutes les
            -- possibilités de FUNCT3 sont couvertes par le code plus haut
            alu_opcode <= (others => '0');
            arith  <= '0';
            shamt  <= (others => '0');
            sign <= SIGN_UNSIGNED;

        end case;
        alu_opcode <= (others => '0');
        sign <= SIGN_UNSIGNED;

      -- I-TYPE
      when OPCODE_LW =>
        jump    <= '0';
        branch  <= '0';
        alu_opcode <= (others => '0');
        sign <= SIGN_UNSIGNED;

      when OPCODE_ALU_I_TYPE =>

      -- S-TYPE
      when OPCODE_SW =>
        jump    <= '0';
        branch  <= '0';
        alu_opcode <= (others => '0');
        sign <= SIGN_UNSIGNED;

      -- B-TYPE
      when OPCODE_BEQ =>
        jump    <= '0';
        branch  <= '1';
        alu_opcode <= (others => '0');
        sign <= SIGN_UNSIGNED;

      -- U-TYPE
      when OPCODE_LUI =>
        jump    <= '0';
        branch  <= '0';
        alu_opcode <= (others => '0');
        sign <= SIGN_UNSIGNED;
       
      -- J-TYPE
      when OPCODE_JAL =>
        jump    <= '1';
        branch  <= '0';
        alu_opcode <= (others => '0');
        sign <= SIGN_UNSIGNED;

      -- R-TYPE
      -- Unsupported instructions
      when others =>

    end case; 

  end process decode_jump_decode;


  -- Écrire le registre ID/EX



  -- DEBUG:
  o_decode_reg.shamt <= (others => '1');
  o_decode_reg.arith <= '1';
  o_decode_reg.sign  <= '1';

  o_decode_reg.jump   <= '1';
  o_decode_reg.branch <= '1';
  o_decode_reg.pc     <= (others => '1');
  o_decode_reg.imm    <= (others => '1');

  -- Références:
  -- Écrire le registre pointé
--  write_reg_file:
--  process (i_clk) is
--  begin
--
--    if rising_edge(i_clk) then
--      if i_rstn = '1' then
--        if reg_file_wr_en = '1' then
--          reg_file(to_integer(unsigned(i_addr_w))) <= i_data_w;
--        else
--          reg_file <= reg_file;
--        end if;
--      else
--        reg_file <= (others => (others => '0'));
--      end if;
--    end if;
--  end process write_reg_file;

  -- Transférer la valeur écrite vers un tampon
--  transfer_write_buffers:
--  process (i_clk) is
--  begin
--    if rising_edge(i_clk) then
--      if i_rstn = '1' then
--        write_buffer <= i_data_w;
--      else
--        write_buffer <= (others => '0');
--      end if;
--    end if;
--  end process transfer_write_buffers;
end architecture beh;