Module Verilog：连接模块端口而不实例化新导线

有没有一种方法可以连接两个模块端口而不实例化新的导线

小例子：

module comparator(max,min,in0,in1);

    input[7:0] in0,in1;
    output[7:0] max,min;

    wire[7:0] in0;
    wire[7:0] in1;
    wire[7:0] max;
    wire[7:0] min;

    assign max = (in0>in1) ? in0 : in1;
    assign min = (in0<in1) ? in0 : in1;

endmodule

模块比较器（最大、最小、in0、in1）；
输入[7:0]in0，in1；
输出[7:0]最大值，最小值；
导线[7:0]in0；
导线[7:0]英寸1；
导线[7:0]最大值；
导线[7:0]分钟；
分配最大值=（in0>in1）？in0:in1；
assign min=（in0IEEE标准（1364-2001）引入了
generate
结构，以允许将多个实例连接在一起

IEEE标准（1800-2005）引入了“点星”（
*
）语法，也称为隐式端口连接，用于减少布线。如果您使用的是现代工具，它们应该支持SystemVerilog语法。
我猜您需要一个模块，以类似于您的图表的方式多次实例化模块
比较器
。您需要一个数组（在我的解决方案中是二维的）宽度由参数控制以获得最佳灵活性。在
generate
块内，使用
for loops
和
if else
语句进行连接。我的解决方案使用数组的切片，例如
+：

这遵循IEEE标准（1800-2009），也适用于IEEE标准（1800-2005）

module comparator_list#（参数int SIZE=10）（输入逻辑[7:0]输入[SIZE-1:0]，输出逻辑[7:0]输出[SIZE-1:0]）；
生成
如果（大小==1）开始：通过
总是梳出=插入；
结束：通过
如果（大小==2）开始，则为else：简单
比较器c0（.max（out[0]），.min（out[1]），.in0（in[0]），.in1（in[1]）；
结束：简单
else if（大小%2==1）开始：奇数列表
逻辑[7:0]in_buf[SIZE:0]；
逻辑[7:0]输出[SIZE:0]；
始终\u梳开始：链接\u in
foreach（in[idx]）in_buf[idx]=in[idx]；
in_buf[SIZE]=8'h00；//如果未分配，则强制最后一项为'h0'，如果已分配，则强制最后一项为'h80'
完:链接(u in)
始终\u梳开始：链接\u
foreach（out[idx]）out[idx]=out_buf[idx]；
//注意：out_buf[尺寸]不重要
结束：链接输出
比较器列表#（大小+1）cl（.in（in#buf），.out（out#buf））；
完:单数清单
其他开始：偶数列表
逻辑[（大小/2）*8-1:0]顶部[大小+1]；
逻辑[（大小/2）*8-1:0]机器人[大小+1]；
对于（genvar idx=0；idx
module comparator_list #(parameter int SIZE=10) (input logic [7:0] in [SIZE-1:0], output logic [7:0] out [SIZE-1:0]);
    generate
        if (SIZE==1) begin : pass_through
            always_comb out = in;
        end : pass_through
        else if (SIZE==2) begin : simple
            comparator c0 ( .max(out[0]), .min(out[1]), .in0(in[0]), .in1(in[1]) );
        end : simple
        else if (SIZE%2==1) begin : odd_list
            logic [7:0] in_buf [SIZE:0];
            logic [7:0] out_buf [SIZE:0];
            always_comb begin : link_in
                foreach(in[idx]) in_buf[idx] = in[idx];
                in_buf[SIZE] = 8'h00; // force last entry to 'h0 if unasigned, 'h80 if signed
            end : link_in
            always_comb begin : link_out
                foreach(out[idx]) out[idx] = out_buf[idx];
                // Note: out_buf[SIZE] is don't care
            end : link_out
            comparator_list #(SIZE+1) cl (.in(in_buf), .out(out_buf));
        end : odd_list
        else begin : even_list
            logic [(SIZE/2)*8-1:0] top [SIZE+1];
            logic [(SIZE/2)*8-1:0] bot [SIZE+1];

            for(genvar idx=0; idx<SIZE/2; idx+=1) begin : map
                always_comb {top[0][idx*8+:8],bot[0][idx*8+:8]} = {in[2*idx],in[2*idx+1]};
                always_comb {out[2*idx],out[2*idx+1]} = {top[SIZE][idx*8+:8],bot[SIZE][idx*8+:8]};
            end : map

            for(genvar stage=0; stage<SIZE; stage++) begin : link
                if(stage%2==0) begin : even
                    comparator c0[SIZE/2-1:0] (
                        .max(top[stage+1][0+:(SIZE/2)*8]), .in0(top[stage][0+:(SIZE/2)*8]),
                        .min(bot[stage+1][0+:(SIZE/2)*8]), .in1(bot[stage][0+:(SIZE/2)*8]) );
                end : even
                else begin : odd
                    assign top[stage+1][7:0] = top[stage][7:0];
                    comparator c1[SIZE/2-2:0] (
                        .max(bot[stage+1][0+:(SIZE/2-1)*8]),
                        .min(top[stage+1][8+:(SIZE/2-1)*8]),
                        .in0(bot[stage][0+:(SIZE/2-1)*8]),
                        .in1(top[stage][8+:(SIZE/2-1)*8])
                    );
                    assign bot[stage+1][(SIZE/2-1)*8+:8] = bot[stage][(SIZE/2-1)*8+:8];
                end : odd
            end : link
        end : even_list
    endgenerate
endmodule : comparator_list