¿Por qué esta declaración del replicador de Verilog produce un cable de 64 bits?

1

Estoy intentando capturar la ejecución de la adición de dos números de N bits con una transferencia. Mi código es:

module alu(a, b, f, cOut, z);
   parameter size = 8;          // how many bits is each input                  
   parameter n = size - 1;

   input a;                     // operand a                                    
   input b;                     // operand b
   input f;

   wire [n:0] a;
   wire [n:0] b;
   wire [2:0] f;
   wire [n:0] sum;
   assign {cOut,sum} = {(n+1){a + b + {n{f[2]}}}};

En mi replicador interno, estoy tratando de extender en cero el bit en f [2] para que sea el tamaño de los operandos (f [2] es el arrastre). Con el replicador externo, estoy tratando de extender a cero la adición para que quepa en n + 1 bits. Luego, cOut se establecerá en el MSB, que representará la ejecución.

Aquí está el error que Verilator informa:

% verilator -cc alu.v
%Warning-WIDTH: alu.v:22: Operator ASSIGNW expects 9 bits on the Assign RHS, but Assign RHS's REPLICATE generates 64 bits.
%Warning-WIDTH: Use "/* verilator lint_off WIDTH */" and lint_on around source to disable this message.
%Error: Exiting due to 1 warning(s)
%Error: Command Failed /usr/bin/verilator_bin -cc alu.

¿Alguien sabe por qué Verilator piensa que el RHS será de 64 bits? ¿Y hay una mejor manera de escribir esto sin replicadores anidados en Verilog?

    
pregunta David

2 respuestas

2

Los replicadores no se extienden a cero, se replican. {7{f[2]}} significa {f[2],f[2],f[2],f[2],f[2],f[2],f[2]}

Te perdiste el mensaje. El RHS tiene 9 bits, pero se le asignan 64 bits (el ancho de LHS). a y b son valores de 8 bits, se utilizan como el ancho inicial que se replicará. el valor del Replicador (n+8) es 8. 8 * 8 es 64, que ahora es el valor de ancho LHS.

Para extender los ceros iniciales, use { {n{1'b0}}, f[2] } , que en este caso se evaluará como {7'b0000000,f[2]}

La mayoría de los sintetizadores generarán la lógica adecuada con assign {cOut,sum} = a + b + f[2]; , y esto suponiendo que desea una lógica sin firma.

    
respondido por el Greg
0

a tiene 8 bits de ancho

b tiene 8 bits de ancho

{n {f2}} tiene 8 bits de ancho

entonces a + b + {n {f2}} también tiene 8 bits de ancho

así que {8 {a + b + {n {f2}}}} tiene 64 bits de ancho

En casos como thin, a menudo ayuda a hacer explícitos todos los anchos, hacer todo en 9 bits y dejar que la herramienta de síntesis optimice el contenido, algo como:

signo {cOut, suma} = {1'b0, a} + {1'b0, b} + {{tamaño {1'b0}}, f [2]};

    
respondido por el Taniwha

Lea otras preguntas en las etiquetas