Verilog 拼接与复制：{} 运算符

两个小而实用的运算符

Verilog 有两种 {} 形式：

1. 拼接：{a, b, c}，把多个信号拼成一个更宽的信号。
2. 复制：{N{pattern}}，把一个模式复制 N 次。

这两个你都会经常用到。每当总线需要拆分、合并、填充或符号扩展时，答案都是这两个运算符之一。

拼接：{a, b, c}

最简单的情况是把两个信号叠成一个：

module concat_demo;
    wire [3:0] a = 4'hA;
    wire [3:0] b = 4'h5;
    wire [7:0] combined = {a, b};   // 8 bits: AAAA_0101

    initial begin
        $display("a        = %b (%h)", a, a);
        $display("b        = %b (%h)", b, b);
        $display("combined = %b (%h)", combined, combined);
        $finish;
    end
endmodule

从左到右读：a 是高半部分，b 是低半部分。{} 中的第一个操作数位于最高位。结果的宽度是所有操作数宽度之和。

你可以拼接任意数量的操作数：

wire [31:0] word = {byte3, byte2, byte1, byte0};

而且操作数的宽度可以各不相同：

wire [11:0] frame = {start_bit, data_byte, parity, stop_bit};
//                    1 bit      8 bits     1 bit   2 bits  = 12

一条常见规则：拼接的所有操作数都必须有明确的宽度。不带宽度的字面量（写 1 而不是 1'b1）会导致错误，因为解析器不知道该分配多少位。在 {} 中始终写 1'b0、1'b1、4'd0，绝不写单独的 0 或 1。

在左侧使用拼接

在赋值的左侧使用拼接，可以把一个宽信号拆回各个部分：

module split;
    wire [7:0] a = 8'd200;
    wire [7:0] b = 8'd100;
    wire [8:0] full_sum = a + b;
    wire carry_out;
    wire [7:0] sum_bits;

    // Split the 9-bit sum into a carry bit and an 8-bit sum
    assign {carry_out, sum_bits} = full_sum;

    initial begin
        #1 $display("a + b = %0d, carry_out=%b, sum_bits=%0d",
                    full_sum, carry_out, sum_bits);
        $finish;
    end
endmodule

这是带进位加法器的标准写法。{carry_out, sum_bits} 在赋值左侧构成一个 9 位的目标，各个位会被分配下去：最高位给 carry_out，低 8 位给 sum_bits。

左侧拼接在 assign 和过程块中都可以使用：

always @(posedge clk) begin
    {high_byte, low_byte} <= incoming_word;
end

复制：{N{pattern}}

复制运算符把一个模式复制固定的次数。写法是 {N{pattern}}：先写次数，再把模式放在它自己的一对大括号里：

module replicate;
    initial begin
        $display("{8{1'b1}}        = %b", {8{1'b1}});         // 11111111
        $display("{4{1'b1}}        = %b", {4{1'b1}});         // 1111
        $display("{4{2'b10}}       = %b", {4{2'b10}});        // 10101010
        $display("{2{4'hA}}        = %h", {2{4'hA}});         // AA
        $display("{3{3'b101}}      = %b", {3{3'b101}});       // 101101101
        $finish;
    end
endmodule

N 必须是常量，因为编译器在展开（elaboration）阶段就需要知道结果的宽度。模式可以是字面量、参数，或任何宽度已知的表达式。

别忘了内层的大括号。{8 1'b1} 是语法错误，{8{1'b1}} 才是正确的。外层的 {} 是运算符，内层的 {...} 包住要复制的模式。

组合使用：符号扩展与零扩展

这两个运算符可以很自然地组合起来构建更宽的值：

module extension;
    wire [7:0] a_unsigned = 8'h7F;
    wire [7:0] a_negative = 8'hFF;   // would be -1 as signed

    // Zero-extend to 16 bits
    wire [15:0] zext = {8'b0, a_unsigned};

    // Sign-extend to 16 bits: replicate the top bit of a_negative
    wire [15:0] sext = { {8{a_negative[7]}}, a_negative };

    initial begin
        $display("a_unsigned    = %b -> zext = %b", a_unsigned, zext);
        $display("a_negative    = %b -> sext = %b", a_negative, sext);
        $finish;
    end
endmodule

{ {8{a_negative[7]}}, a_negative } 是标准的符号扩展写法。读作：把符号位复制八次，再接上原来的 8 位。最终结果是同一个数的 16 位二进制补码表示。

对于无符号的扩宽，可以依赖赋值本身：当目标更宽时，Verilog 会自动做零扩展：

wire [15:0] zext_auto = a_unsigned;   // works, top 8 bits are 0

但除非操作数和目标都声明为 signed，否则符号扩展永远不会隐式发生。显式的复制写法更安全。

实用写法

构建 N 个 1 的掩码

parameter N = 5;
wire [31:0] mask = { {32-N{1'b0}}, {N{1'b1}} };
// e.g. with N=5, mask = 32'h0000_001F

反转向量

Verilog 没有内置的反转操作，但你可以用拼接直接写出来：

wire [3:0] forward  = 4'b1010;
wire [3:0] reversed = {forward[0], forward[1], forward[2], forward[3]};
// reversed = 4'b0101

对于更宽的向量，用 generate 循环或 function 会更简洁。

把标志位打包成状态字节

wire [7:0] status = {
    error_flag,    // [7]
    overflow,      // [6]
    underflow,     // [5]
    ready,         // [4]
    busy,          // [3]
    1'b0,          // [2] reserved
    1'b0,          // [1] reserved
    valid          // [0]
};

1 位的保留位都写明了宽度：在 {} 中绝不写单独的 0。

常见错误

{} 中使用不带宽度的字面量。 {a, 0} 要么是语法错误，要么得到一个 32 位宽的零。务必写明宽度：{a, 1'b0}。

复制时忘了内层大括号。 {8 1'b1} 无法解析，{8{1'b1}} 才可以。

弄错顺序。 {a, b} 把 a 放在高位，b 放在低位。如果你的假设反了，某处的字节顺序就会颠倒。

复制零次。 标准 Verilog 中 {0{...}} 是非法的。SystemVerilog 允许这样写（得到一个零宽度的结果），但普通 Verilog 会拒绝它。

接下来

到这里，你已经见过所有 Verilog 运算符了。下一章换个方向，深入讲解结构：模块之间如何连接、端口的规则，以及通过实例化子模块构建更大设计的语法。