Se define el desbordamiento para VHDL numeric_std signed/unsigned

Question

Si tengo un unsigned(MAX downto 0) que contiene el valor 2**MAX - 1, ¿los estándares VHDL (87 | 93 | 200X) definen qué sucede cuando lo incremento en uno? (O, de manera similar, cuando disminuirlo por uno desde cero?)

Answer 1

Respuesta corta:

no hay manipulación de desbordamiento, el acarreo de desbordamiento simplemente se pierde. Por lo tanto, el resultado es simplemente el resultado entero de su operación módulo 2^MÁX.

Respuesta larga:

numeric_std El paquete es un paquete estándar, pero no es es el núcleo de los estándares VHDL (87,93,200X). para la referencia: numeric_std.vhd

El operador + al final llama a la función ADD_UNSIGNED (L, R : unsigned; C : std_logic) (con C = '0'). Tenga en cuenta que cualquier entero/operando natural se convierte primero en unsigned.

definición de la función es:

function ADD_UNSIGNED (L, R : unsigned; C : std_logic) return unsigned is 
    constant L_left : integer := L'length-1; 
    alias XL  : unsigned(L_left downto 0) is L; 
    alias XR  : unsigned(L_left downto 0) is R; 
    variable RESULT : unsigned(L_left downto 0); 
    variable CBIT : std_logic := C; 
begin 
    for i in 0 to L_left loop 
     RESULT(i) := CBIT xor XL(i) xor XR(i); 
     CBIT  := (CBIT and XL(i)) or (CBIT and XR(i)) or (XL(i) and XR(i)); 
    end loop; 
    return RESULT; 
end ADD_UNSIGNED; 

Como se puede ver un "desbordamiento" se produce si CBIT='1' (bit de acarreo) para i = L_left. El bit de resultado RESULT(i) se calcula normalmente y el último valor de bot de transporte se ignora.

Answer 2

que he tenido el problema con el deseo de un unsigned a desbordarse/flujo inferior como en C o en Verilog y esto es lo que ocurrió con (result y delta son unsigned):

result <= unsigned(std_logic_vector(resize(('1' & result) - delta, result'length))); -- proper underflow 
result <= unsigned(std_logic_vector(resize(('0' & result) + delta, result'length))); -- proper overflow 

Por desbordamiento '0' & result hace un unsigned que es 1 bit más grande para poder acomodar correctamente el valor de la suma. El MSB luego se elimina mediante el comando resize que produce el valor de desbordamiento correcto. Lo mismo para underflow.

Answer 3

Para un valor de MAX igual a 7, sumando 1 a 2 ** 7 - 1 (127) dará como resultado el valor 2 ** 7 (128).

El valor máximo sin signo se determina por la longitud de un unsigned tipo de matriz:

library ieee; 
use ieee.std_logic_1164.all; 
use ieee.numeric_std.all; 

entity foo is 
end entity; 

architecture faa of foo is 
    constant MAX: natural := 7; 
    signal somename: unsigned (MAX downto 0) := (others => '1'); 
begin 
UNLABELED: 
    process 
    begin 
     report "somename'length = " & integer'image(somename'length); 
     report "somename maximum value = " &integer'image(to_integer(somename)); 
     wait; 
    end process; 
end architecture; 

El agregado (others => '1') representa un '1' en cada elemento de somename que es un tipo de matriz sin firmar y representa el máximo binario valor posible.

Esto da:

foo.vhdl: 15: 9: @ 0 ms: (nota informe): somename'length = 8
foo.vhdl: 16: 9: @ 0 ms: (informe nota): somename valor máximo = 255

la longitud es de 8 y el representable numérico rango de valores por el tipo de matriz sin signo es de 0 a 2 ** 8 - 1 (255), el valor máximo posible es mayor que 2 ** 7 (128) y no hay desbordamiento.

Esto se notó en una pregunta más reciente VHDL modulo 2^32 addition. En el contexto de su respuesta aceptada, asume que se refiere a la longitud en lugar del valor más a la izquierda.

La disminución de la caja cero da como resultado un valor de 2 ** 8 - 1 (255) (MAX = 7). Un underflow o un overflow dependiendo de su religión matemática.

Sombrero de punta a Jonathan Drolet para señalar esto en la nueva pregunta vinculada.