适配64至4位操作数的MMX x86指令VHDL算术单元设计问询

背景 #

正在开发一款支持6种MMX x86指令的VHDL算术单元，原设计支持64至8位操作数，基于8位行波进位加法器（RCA）级联实现了PADD指令。现在需要将适配范围扩展到64至4位操作数，在尝试用generate语句实例化加法器时遇到索引和多路器逻辑适配问题。

现有PADD组件代码 #

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity PADD is
    generic (
        DATA_WIDTH : integer := 64
    );
    Port (
        Cin, clk, reset, enable : in std_logic;
        op1, op2 : in std_logic_vector(DATA_WIDTH - 1 downto 0);
        result : out std_logic_vector(DATA_WIDTH - 1 downto 0);
        Cout : out std_logic
    );  
end PADD;

architecture Behavioral of PADD is
    signal carry : std_logic_vector(7 downto 0);
    signal S : std_logic_vector(DATA_WIDTH - 1  downto 0);

    component full_adder
        Port (A, B, Cin : in std_logic; 
              S, Cout : out std_logic);
    end component;

    component ripple_carry_adder_padd
    Port (
        A, B    : in  std_logic_vector(7 downto 0);
        Cin     : in  std_logic;
        S       : out std_logic_vector(7 downto 0);
        Cout    : out std_logic
        );
    end component;
    
    signal mux_res : std_logic_vector(DATA_WIDTH - 1 downto 0);

begin
    
    carry(0) <= '0';

    RCA_1 : ripple_carry_adder_padd port map(A => op1(7 downto 0), B => op2(7 downto 0), Cin => carry(0), S => S(7 downto 0), Cout => carry(1));
    RCA_2 : ripple_carry_adder_padd port map(A => op1(15 downto 8), B => op2(15 downto 8), Cin => carry(1), S => S(15 downto 8), Cout => carry(2));
    RCA_3 : ripple_carry_adder_padd port map(A => op1(23 downto 16), B => op2(23 downto 16), Cin => carry(2), S => S(23 downto 16), Cout => carry(3));
    RCA_4 : ripple_carry_adder_padd port map(A => op1(31 downto 24), B => op2(31 downto 24), Cin => carry(3), S => S(31 downto 24), Cout => carry(4));
    RCA_5 : ripple_carry_adder_padd port map(A => op1(39 downto 32), B => op2(39 downto 32), Cin => carry(4), S => S(39 downto 32), Cout => carry(5));
    RCA_6 : ripple_carry_adder_padd port map(A => op1(47 downto 40), B => op2(47 downto 40), Cin => carry(5), S => S(47 downto 40), Cout => carry(6));
    RCA_7 : ripple_carry_adder_padd port map(A => op1(55 downto 48), B => op2(55 downto 48), Cin => carry(6), S => S(55 downto 48), Cout => carry(7));
    RCA_8 : ripple_carry_adder_padd port map(A => op1(63 downto 56), B => op2(63 downto 56), Cin => carry(7), S => S(63 downto 56), Cout => Cout);
   
    
    MUX_process: process(carry, S)
    begin
        if carry(1) = '1' then
            mux_res <= "00000000000000000000000000000000000000000000000000000000" & S(DATA_WIDTH - 1 downto DATA_WIDTH - 8); --7 downto 0
        elsif carry(2) = '1' then
            mux_res <= "000000000000000000000000000000000000000000000000" & S(DATA_WIDTH - 1 downto DATA_WIDTH - 16); -- 15 downto 0
        elsif carry(3) = '1' then
            mux_res <= "0000000000000000000000000000000000000000" & S(DATA_WIDTH - 1 downto DATA_WIDTH - 24); --23 downto 0
        elsif carry(4) = '1' then  
            mux_res <= "00000000000000000000000000000000" & S(DATA_WIDTH - 1 downto DATA_WIDTH - 32); --31 dowto 0
        elsif carry(5) = '1' then
            mux_res <= "000000000000000000000000" & S(DATA_WIDTH - 1 downto DATA_WIDTH - 40); --39 downto 0
        elsif carry(6) = '1' then
            mux_res <= "0000000000000000" & S(DATA_WIDTH - 1 downto DATA_WIDTH - 48); --47 downto 0
        elsif carry(7) = '1' then
            mux_res <= "00000000" & S(DATA_WIDTH - 1 downto DATA_WIDTH - 56); -- 55 downto 0
        else
            mux_res <= S(DATA_WIDTH - 1 downto DATA_WIDTH - 64);
        end if;
    end process;
    
    result <= mux_res;

end Behavioral;

问题 #

1. 如何修改实例化逻辑以无缝适配64至4位操作数？
2. 有无更优方案实现多操作数宽适配，避免重复实例化语句？
3. 如何调整多路器逻辑以适配不同操作数宽？

1. 修改实例化逻辑适配64至4位操作数 #

核心是将固定8位分组改为4位最小粒度分组，并动态计算实例数量和索引：

• 新增一个4位通用行波进位加法器组件，或直接修改现有ripple_carry_adder_padd为支持位宽配置的通用组件。
• 用generate语句根据DATA_WIDTH自动计算分组数，动态实例化加法器，同时处理信号索引的动态映射。

示例修改：

-- 定义通用位宽的行波进位加法器组件
component generic_ripple_carry_adder
    generic (
        WIDTH : integer := 4
    );
    Port (
        A, B    : in  std_logic_vector(WIDTH - 1 downto 0);
        Cin     : in  std_logic;
        S       : out std_logic_vector(WIDTH - 1 downto 0);
        Cout    : out std_logic
        );
end component;

-- 在architecture中调整信号和实例化逻辑
signal carry : std_logic_vector(((DATA_WIDTH / 4)) downto 0); -- 按4位分组的进位信号
signal S : std_logic_vector(DATA_WIDTH - 1 downto 0);

begin
    carry(0) <= Cin; -- 使用外部输入的Cin，符合MMX指令规范

    -- 动态生成4位加法器实例
    RCA_GEN: for i in 0 to ((DATA_WIDTH / 4) - 1) generate
        RCA_INST: generic_ripple_carry_adder
            generic map(WIDTH => 4)
            port map(
                A => op1((i*4)+3 downto i*4),
                B => op2((i*4)+3 downto i*4),
                Cin => carry(i),
                S => S((i*4)+3 downto i*4),
                Cout => carry(i+1)
            );
    end generate RCA_GEN;

    Cout <= carry(DATA_WIDTH / 4); -- 输出总进位

2. 最优多操作数宽适配方案：通用组件+Generate语句 #

彻底避免重复实例化的关键是通用化组件+动态生成：

1. 所有加法器组件改为支持位宽配置的通用版本，最小粒度设为4位。
2. 在顶层generic中新增MIN_OP_WIDTH参数（默认4），让设计可灵活调整最小操作粒度。
3. 用generate循环根据DATA_WIDTH和MIN_OP_WIDTH计算分组数，自动实例化对应数量的加法器，进位信号宽度也通过公式(DATA_WIDTH / MIN_OP_WIDTH) + 1动态生成。

示例通用化顶层定义：

entity PADD is
    generic (
        DATA_WIDTH    : integer := 64;
        MIN_OP_WIDTH  : integer := 4 -- 最小操作数宽，支持4/8/16等
    );
    Port (
        Cin, clk, reset, enable : in std_logic;
        op1, op2 : in std_logic_vector(DATA_WIDTH - 1 downto 0);
        result : out std_logic_vector(DATA_WIDTH - 1 downto 0);
        Cout : out std_logic
    );  
end PADD;

3. 调整多路器逻辑适配不同操作数宽 #

原多路器用固定字符串拼接无法适配动态位宽，改为动态零填充+信号切片的方式：

• 遍历进位信号，找到第一个产生进位的分组，确定有效结果的位宽。
• 高位自动补零到DATA_WIDTH位，无需硬编码零字符串。

示例修改：

MUX_process: process(carry, S)
    variable valid_bit_width : integer := DATA_WIDTH; -- 默认全宽有效
begin
    -- 从低位分组开始查找第一个进位，确定有效结果位宽
    for i in 1 to carry'length - 1 loop
        if carry(i) = '1' then
            valid_bit_width := i * MIN_OP_WIDTH;
            exit; -- 找到第一个进位即停止遍历
        end if;
    end loop;

    -- 高位补零，拼接得到最终结果
    mux_res <= (DATA_WIDTH - 1 downto valid_bit_width => '0') & S(valid_bit_width - 1 downto 0);
end process;

内容的提问来源于stack exchange，提问作者nana