Verilog运算符与表达式详解
本文档详细介绍Verilog中的各种运算符和表达式使用方法，包括算术、逻辑、位操作等运算符的语法规则、优先级和实际应用场景。
目录
表达式基础概念
🔍 表达式组成
表达式由操作数和运算符组成，用于根据运算符的语义计算出结果值。表达式可以出现在任何需要数值的地方。
// 表达式示例
assign result = (a + b) * c; // 算术表达式
assign valid = enable && ready; // 逻辑表达式
assign data_out = sel ? data_a : data_b; // 条件表达式
📊 操作数类型
| 操作数类型 |
描述 |
示例 |
| 常数 |
数值常量 |
8'h55, 16'd1024 |
| 整数 |
integer类型变量 |
loop_counter, delay_value |
| 实数 |
real类型变量 |
voltage, frequency |
| 线网 |
wire类型信号 |
data_bus, clock |
| 寄存器 |
reg类型变量 |
state, counter |
| 位选择 |
向量的某一位 |
data[7], address[15:8] |
| 存储器 |
数组元素 |
memory[addr], cache[index] |
| 函数调用 |
函数返回值 |
$random, calculate(x, y) |
⚙️ 运算符分类
Verilog提供了丰富的运算符，大部分语法与C语言相似：
graph TD
A[Verilog运算符] --> B[算术运算符]
A --> C[关系运算符]
A --> D[相等运算符]
A --> E[逻辑运算符]
A --> F[位运算符]
A --> G[归约运算符]
A --> H[移位运算符]
A --> I[特殊运算符]
B --> B1[+ - * / % **]
C --> C1[> < >= <=]
D --> D1[== != === !==]
E --> E1[&& || !]
F --> F1[& | ^ ~]
G --> G1[&data |data ^data]
H --> H1[<< >> <<< >>>]
I --> I1[?: {} {n{}} [+: -:]]
算术运算符
🔢 基本算术运算
| 运算符 |
功能 |
示例 |
结果位宽 |
说明 |
+ |
加法 |
8'd10 + 8'd5 |
最大操作数位宽 |
支持有符号/无符号 |
- |
减法 |
16'h100 - 16'h50 |
最大操作数位宽 |
注意下溢问题 |
* |
乘法 |
4'd3 * 4'd5 |
操作数位宽之和 |
结果位宽会扩展 |
/ |
除法 |
32'd100 / 32'd3 |
最大操作数位宽 |
整数除法，截断小数 |
% |
取模 |
8'd17 % 8'd5 |
最大操作数位宽 |
求余运算 |
** |
幂运算 |
2**3 |
依赖于操作数 |
2的3次方 = 8 |
📝 算术运算示例
module arithmetic_demo (
input [7:0] a, b,
output reg [15:0] sum,
output reg [15:0] product,
output reg [7:0] quotient,
output reg [7:0] remainder
);
always @(*) begin
// 加法 - 注意位宽扩展避免溢出
sum = {1'b0, a} + {1'b0, b}; // 9位加法，防止溢出
// 乘法 - 结果位宽为操作数位宽之和
product = a * b; // 8*8=16位结果
// 除法和取模
quotient = a / b; // 整数除法
remainder = a % b; // 取余运算
end
endmodule
⚠️ 算术运算注意事项
// 有符号与无符号运算
reg signed [7:0] signed_a = -8'd10; // -10
reg [7:0] unsigned_b = 8'd5; // 5
// 混合运算时的类型转换
wire signed [8:0] result1 = signed_a + unsigned_b; // 有符号结果
wire [8:0] result2 = unsigned_b + signed_a; // 无符号结果
// 溢出检测
reg [3:0] small_reg;
reg overflow_flag;
always @(*) begin
{overflow_flag, small_reg} = a[3:0] + b[3:0]; // 进位作为溢出标志
end
关系与相等运算符
🔍 关系运算符
| 运算符 |
功能 |
示例 |
返回值 |
X/Z处理 |
> |
大于 |
a > b |
1位 (0/1) |
包含X/Z时返回X |
< |
小于 |
a < b |
1位 (0/1) |
包含X/Z时返回X |
>= |
大于等于 |
a >= b |
1位 (0/1) |
包含X/Z时返回X |
<= |
小于等于 |
a <= b |
1位 (0/1) |
包含X/Z时返回X |
⚖️ 相等运算符
| 运算符 |
功能 |
X/Z处理 |
应用场景 |
== |
逻辑相等 |
X/Z导致结果为X |
一般比较 |
!= |
逻辑不等 |
X/Z导致结果为X |
一般比较 |
=== |
全等 |
X/Z参与比较 |
精确比较、仿真 |
!== |
全不等 |
X/Z参与比较 |
精确比较、仿真 |
🧪 相等运算示例
module equality_demo;
reg [3:0] a, b, c;
reg eq_result, case_eq_result;
initial begin
a = 4'b101x; // 包含不定值
b = 4'b101x; // 相同的不定值
c = 4'b1010; // 确定值
// 逻辑相等 - X值导致结果不定
eq_result = (a == b); // 结果为 X
eq_result = (a == c); // 结果为 X
// 全等比较 - X值参与比较
case_eq_result = (a === b); // 结果为 1 (完全相同)
case_eq_result = (a === c); // 结果为 0 (不同)
$display("a=%b, b=%b, c=%b", a, b, c);
$display("a==b: %b, a===b: %b", (a==b), (a===b));
$display("a==c: %b, a===c: %b", (a==c), (a===c));
end
endmodule
逻辑运算符
🔀 逻辑运算符特性
| 运算符 |
功能 |
短路求值 |
返回值 |
示例 |
&& |
逻辑与 |
是 |
0/1/X |
enable && valid |
|| |
逻辑或 |
是 |
0/1/X |
error || warning |
! |
逻辑非 |
否 |
0/1/X |
!reset_n |
⚡ 短路求值机制
// 短路求值在复杂条件中的应用
module short_circuit_demo (
input [7:0] data,
input valid,
input enable
);
wire safe_condition;
// 短路求值避免无效访问
assign safe_condition = valid && (data != 8'h00) && enable;
// 如果valid为0，后续条件不会被求值
// 这在避免除零等错误时很有用
always @(*) begin
if (enable && valid && (data > 8'h10)) begin
// 只有当enable和valid都为真时，才会检查data的值
$display("Data is valid and greater than 16");
end
end
endmodule
🎯 逻辑运算应用
// 状态机中的逻辑运算
module fsm_logic (
input clk, reset_n,
input start, stop, error,
output reg busy, done
);
typedef enum reg [1:0] {
IDLE = 2'b00,
RUN = 2'b01,
DONE = 2'b10,
ERR = 2'b11
} state_t;
state_t state, next_state;
// 组合逻辑中的复杂条件
always @(*) begin
case (state)
IDLE: begin
next_state = (start && !error) ? RUN : IDLE;
busy = 1'b0;
done = 1'b0;
end
RUN: begin
next_state = error ? ERR :
stop ? DONE : RUN;
busy = 1'b1;
done = 1'b0;
end
DONE: begin
next_state = start ? RUN : IDLE;
busy = 1'b0;
done = 1'b1;
end
ERR: begin
next_state = !error ? IDLE : ERR;
busy = 1'b0;
done = 1'b0;
end
endcase
end
endmodule
位操作运算符
🔧 位运算符详解
| 运算符 |
功能 |
示例 |
结果 |
应用场景 |
& |
按位与 |
4'b1010 & 4'b1100 |
4'b1000 |
掩码操作 |
| |
按位或 |
4'b1010 | 4'b1100 |
4'b1110 |
位设置 |
^ |
按位异或 |
4'b1010 ^ 4'b1100 |
4'b0110 |
奇偶校验 |
~ |
按位取反 |
~4'b1010 |
4'b0101 |
求反码 |
~& |
与非 |
~(4'b1010 & 4'b1100) |
4'b0111 |
NAND操作 |
~| |
或非 |
~(4'b1010 | 4'b1100) |
4'b0001 |
NOR操作 |
~^ |
同或 |
~(4'b1010 ^ 4'b1100) |
4'b1001 |
相等检测 |
📝 位操作实用示例
module bit_operations (
input [31:0] data_in,
input [4:0] bit_pos,
output reg [31:0] data_out,
output reg parity,
output reg [7:0] byte_reversed
);
always @(*) begin
// 位设置和清除
data_out = data_in | (1 << bit_pos); // 设置指定位
data_out = data_in & ~(1 << bit_pos); // 清除指定位
data_out = data_in ^ (1 << bit_pos); // 翻转指定位
// 奇偶校验计算
parity = ^data_in[7:0]; // 8位数据的奇偶校验
// 字节反转
byte_reversed = {data_in[0], data_in[1], data_in[2], data_in[3],
data_in[4], data_in[5], data_in[6], data_in[7]};
end
endmodule
🔍 归约运算符
归约运算符对单个操作数的所有位进行运算：
module reduction_operators (
input [7:0] data,
output and_reduce, // 所有位的与
output or_reduce, // 所有位的或
output xor_reduce, // 所有位的异或
output nand_reduce, // 所有位的与非
output nor_reduce, // 所有位的或非
output xnor_reduce // 所有位的同或
);
assign and_reduce = &data; // data[7] & data[6] & ... & data[0]
assign or_reduce = |data; // data[7] | data[6] | ... | data[0]
assign xor_reduce = ^data; // data[7] ^ data[6] ^ ... ^ data[0]
assign nand_reduce = ~&data; // ~(data[7] & data[6] & ... & data[0])
assign nor_reduce = ~|data; // ~(data[7] | data[6] | ... | data[0])
assign xnor_reduce = ~^data; // ~(data[7] ^ data[6] ^ ... ^ data[0])
endmodule
// 归约运算符的实际应用
module practical_reduction (
input [31:0] instruction,
input [7:0] data_byte,
output all_zeros, // 检测是否全为0
output any_ones, // 检测是否有1
output even_parity // 偶校验
);
assign all_zeros = ~|instruction; // 如果全为0，则结果为1
assign any_ones = |instruction; // 如果有任何1，则结果为1
assign even_parity = ~^data_byte; // 偶校验位
endmodule
移位运算符
↔️ 移位运算符类型
| 运算符 |
功能 |
填充方式 |
应用场景 |
<< |
逻辑左移 |
右侧补0 |
乘以2的幂次 |
>> |
逻辑右移 |
左侧补0 |
无符号除法 |
<<< |
算术左移 |
右侧补0 |
有符号乘法 |
>>> |
算术右移 |
左侧补符号位 |
有符号除法 |
🔄 移位运算详解
module shift_operations (
input signed [7:0] signed_data,
input [7:0] unsigned_data,
input [2:0] shift_amount,
output reg [7:0] logical_left,
output reg [7:0] logical_right,
output reg signed [7:0] arith_left,
output reg signed [7:0] arith_right
);
always @(*) begin
// 逻辑移位 - 空位补0
logical_left = unsigned_data << shift_amount; // 左移，右侧补0
logical_right = unsigned_data >> shift_amount; // 右移，左侧补0
// 算术移位 - 保持符号位
arith_left = signed_data <<< shift_amount; // 左移，右侧补0
arith_right = signed_data >>> shift_amount; // 右移，左侧补符号位
end
endmodule
// 移位运算的实际应用
module barrel_shifter #(
parameter DATA_WIDTH = 8,
parameter SHIFT_WIDTH = 3
)(
input [DATA_WIDTH-1:0] data_in,
input [SHIFT_WIDTH-1:0] shift_amount,
input shift_direction, // 0:左移, 1:右移
input shift_type, // 0:逻辑, 1:算术
output reg [DATA_WIDTH-1:0] data_out
);
always @(*) begin
case ({shift_direction, shift_type})
2'b00: data_out = data_in << shift_amount; // 逻辑左移
2'b01: data_out = data_in <<< shift_amount; // 算术左移
2'b10: data_out = data_in >> shift_amount; // 逻辑右移
2'b11: data_out = $signed(data_in) >>> shift_amount; // 算术右移
endcase
end
endmodule
特殊运算符
🎯 条件运算符 (三目运算符)
// 基本语法: condition ? true_value : false_value
module conditional_examples (
input [7:0] a, b,
input sel,
input enable,
output [7:0] mux_out,
output [7:0] max_value,
output [7:0] safe_divide
);
// 简单多路选择
assign mux_out = sel ? a : b;
// 条件最大值
assign max_value = (a > b) ? a : b;
// 嵌套条件表达式
assign safe_divide = (b == 0) ? 8'hFF : // 除数为0时返回最大值
(a >= b) ? (a / b) : // 正常除法
8'h00; // 结果小于1时返回0
// 复杂条件表达式
wire [7:0] complex_result;
assign complex_result = enable ? (sel ? (a + b) : (a - b)) : 8'h00;
endmodule
📦 拼接运算符
module concatenation_examples (
input [3:0] nibble_h, nibble_l,
input [1:0] mode,
input bit_val,
output [7:0] concat_result,
output [15:0] replicate_result,
output [31:0] complex_concat
);
// 基本拼接
assign concat_result = {nibble_h, nibble_l}; // 8位结果
// 重复拼接
assign replicate_result = {8{mode}}; // mode重复8次
// 复杂拼接
assign complex_concat = {
8'hFF, // 常数
nibble_h, // 4位变量
{4{bit_val}}, // 1位重复4次
concat_result, // 8位变量
8'h00 // 常数
}; // 总共32位
endmodule
// 动态位选择
module dynamic_selection (
input [31:0] data,
input [4:0] start_bit,
input [4:0] width,
output reg [31:0] selected_bits
);
always @(*) begin
// 动态位选择 [start_bit +: width]
case (width)
5'd8: selected_bits = {{24{1'b0}}, data[start_bit +: 8]};
5'd16: selected_bits = {{16{1'b0}}, data[start_bit +: 16]};
5'd32: selected_bits = data[start_bit +: 32];
default: selected_bits = 32'h0;
endcase
end
endmodule
运算符优先级
📊 优先级表格
| 优先级 |
运算符 |
功能 |
结合性 |
| 1 (最高) |
+ - ! ~ |
一元运算符 |
右结合 |
| 2 |
** |
幂运算 |
右结合 |
| 3 |
* / % |
乘除取模 |
左结合 |
| 4 |
+ - |
加减 |
左结合 |
| 5 |
<< >> <<< >>> |
移位 |
左结合 |
| 6 |
< <= > >= |
关系比较 |
左结合 |
| 7 |
== != === !== |
相等比较 |
左结合 |
| 8 |
& |
按位与 |
左结合 |
| 9 |
^ ~^ |
按位异或 |
左结合 |
| 10 |
| |
按位或 |
左结合 |
| 11 |
&& |
逻辑与 |
左结合 |
| 12 |
|| |
逻辑或 |
左结合 |
| 13 (最低) |
?: |
条件运算符 |
右结合 |
🔍 优先级应用示例
module precedence_examples (
input [7:0] a, b, c, d,
input enable, valid,
output [7:0] result1,
output [7:0] result2,
output condition_result
);
// 没有括号的表达式 - 依赖优先级
assign result1 = a + b * c; // 等价于 a + (b * c)
assign result2 = a << 2 + b; // 等价于 a << (2 + b)
// 推荐使用括号明确优先级
assign result1 = a + (b * c); // 清晰表达意图
assign result2 = (a << 2) + b; // 避免歧义
// 复杂条件表达式
assign condition_result = enable && valid || a > b; // 可能引起歧义
assign condition_result = (enable && valid) || (a > b); // 清晰明确
endmodule
实际应用案例
🧮 ALU设计
module alu #(
parameter DATA_WIDTH = 8
)(
input [DATA_WIDTH-1:0] a, b,
input [3:0] alu_op,
output reg [DATA_WIDTH-1:0] result,
output reg zero_flag,
output reg carry_flag,
output reg negative_flag
);
reg [DATA_WIDTH:0] temp_result; // 多一位检测进位
always @(*) begin
carry_flag = 1'b0;
case (alu_op)
4'h0: temp_result = a + b; // ADD
4'h1: temp_result = a - b; // SUB
4'h2: temp_result = a & b; // AND
4'h3: temp_result = a | b; // OR
4'h4: temp_result = a ^ b; // XOR
4'h5: temp_result = ~a; // NOT
4'h6: temp_result = a << 1; // SHL
4'h7: temp_result = a >> 1; // SHR
4'h8: temp_result = (a > b) ? a : b; // MAX
4'h9: temp_result = (a < b) ? a : b; // MIN
4'hA: temp_result = {a[DATA_WIDTH-2:0], a[DATA_WIDTH-1]}; // ROL
4'hB: temp_result = {a[0], a[DATA_WIDTH-1:1]}; // ROR
default: temp_result = {(DATA_WIDTH+1){1'b0}};
endcase
result = temp_result[DATA_WIDTH-1:0];
carry_flag = temp_result[DATA_WIDTH];
zero_flag = (result == {DATA_WIDTH{1'b0}});
negative_flag = result[DATA_WIDTH-1];
end
endmodule
🌐 网络数据包处理
module packet_processor (
input [31:0] packet_header,
output [3:0] packet_type,
output [15:0] packet_length,
output [7:0] checksum,
output header_valid
);
// 位字段提取
assign packet_type = packet_header[31:28]; // 高4位
assign packet_length = packet_header[27:12]; // 中间16位
// 校验和计算 (简化版)
assign checksum = packet_header[31:24] ^
packet_header[23:16] ^
packet_header[15:8] ^
packet_header[7:0];
// 头部有效性检查
assign header_valid = (packet_type != 4'h0) && // 类型非零
(packet_length != 16'h0) && // 长度非零
(packet_length <= 16'h5DC) && // 最大1500字节
(~|packet_header[11:8]) && // 保留位为0
(^checksum == 1'b0); // 偶校验
endmodule
总结
掌握Verilog运算符和表达式是进行有效硬件设计的核心技能：
✅ 基础运算: 熟练使用算术、逻辑、关系运算符
✅ 位操作: 掌握位运算和归约运算的应用技巧
✅ 移位运算: 理解逻辑移位与算术移位的区别
✅ 特殊运算: 善用条件运算符和拼接运算符
✅ 优先级: 合理使用括号避免优先级歧义
✅ 实际应用: 能够应用到ALU、数据处理等实际设计中
浙公网安备 33010602011771号