Subversion Repositories mlite

---------------------------------------------------------------------

-- TITLE: Arithmetic Logic Unit

-- AUTHOR: Steve Rhoads (rhoadss@yahoo.com)

-- DATE CREATED: 2/8/01

-- FILENAME: alu.vhd

-- PROJECT: Plasma CPU core

-- COPYRIGHT: Software placed into the public domain by the author.

--    Software 'as is' without warranty.  Author liable for nothing.

-- DESCRIPTION:

--    Implements the ALU.

---------------------------------------------------------------------

library ieee;

use ieee.std_logic_1164.all;

use work.mlite_pack.all;

entity alu is

   generic(adder_type : string := "GENERIC");

   port(a_in         : in  std_logic_vector(31 downto 0);

        b_in         : in  std_logic_vector(31 downto 0);

        alu_function : in  alu_function_type;

        c_alu        : out std_logic_vector(31 downto 0));

end; --alu

architecture logic of alu is

--   type alu_function_type is (alu_nothing, alu_add, alu_subtract, 

--      alu_less_than, alu_less_than_signed, 

--      alu_or, alu_and, alu_xor, alu_nor);

   signal aa, bb, sum : std_logic_vector(32 downto 0);

   signal do_add      : std_logic;

begin

alu_proc: process(a_in, b_in, alu_function, sum)

   variable sign_ext  : std_logic;

begin

   if alu_function = alu_add then

      do_add <= '1';

   else

      do_add <= '0';

   end if;

   if alu_function = alu_less_than then

      sign_ext := '0';

   else

      sign_ext := '1';

   end if;

   aa <= (a_in(31) and sign_ext) & a_in;

   bb <= (b_in(31) and sign_ext) & b_in;

   case alu_function is

   when alu_add | alu_subtract => --c=a+b

      c_alu <= sum(31 downto 0);

   when alu_less_than =>          --c=a<b

      c_alu <= ZERO(31 downto 1) & sum(32);

   when alu_less_than_signed =>   --c=a<b;

      c_alu <= ZERO(31 downto 1) & sum(32);

   when alu_or =>                 --c=a|b

      c_alu <= a_in or b_in;

   when alu_and =>                --c=a&b

      c_alu <= a_in and b_in;

   when alu_xor =>                --c=a^b

      c_alu <= a_in xor b_in;

   when alu_nor =>                --c=~(a|b)

      c_alu <= a_in nor b_in;

   when others =>                 --alu_function = alu_nothing

      c_alu <= ZERO;

   end case;

end process;

   generic_adder:

   if adder_type /= "ALTERA" generate

      sum <= bv_adder(aa, bb, do_add);

   end generate; --generic_adder

   --For Altera

   lpm_adder:

   if adder_type = "ALTERA" generate

      lpm_add_sub_component : lpm_add_sub

      GENERIC MAP (

         lpm_width => 33,

         lpm_direction => "UNUSED",

         lpm_type => "LPM_ADD_SUB",

         lpm_hint => "ONE_INPUT_IS_CONSTANT=NO"

      )

      PORT MAP (

         dataa => aa,

         add_sub => do_add,

         datab => bb,

         result => sum

      );

   end generate; --lpm_adder

end; --architecture logic