汇编语言中的逻辑指令
逻辑指令是处理二进制位级操作的基础指令集，也是汇编语言程序员的核心工具。这些指令不仅用于实现布尔逻辑运算，还广泛应用于位标志处理、位掩码操作、优化算法以及各种低级系统编程任务。本文将详细介绍主要处理器架构中的逻辑指令，它们的工作原理、用途和高效使用技巧。
1. 基本逻辑运算
1.1 按位与操作(AND)
AND指令执行逻辑与操作，只有当两个操作数的对应位都为1时，结果位才为1。
x86/x64架构
assembly
; Intel语法
; AND destination, source (destination = destination AND source)
; 寄存器与寄存器
AND EAX, EBX ; EAX = EAX AND EBX
; 寄存器与立即数
AND CL, 0x0F ; CL = CL AND 0x0F (清除高4位)
; 寄存器与内存
AND EDX, [mask] ; EDX = EDX AND 内存中的掩码值
; 内存与寄存器/立即数
AND BYTE [flags], 0xFE ; 内存地址flags处的字节与0xFE按位与(清除最低位)
; 影响标志位: OF=0, CF=0, SF, ZF, PF (可预测:OF和CF总是被清除)
ARM架构
assembly
; ARM汇编
; AND{S} destination, source1, source2
; {S}后缀表示更新标志位
; 寄存器操作
AND R0, R1, R2 ; R0 = R1 AND R2
; 立即数操作
AND R0, R1, #0xFF ; R0 = R1 AND 0xFF (保留低8位)
; 带更新标志位
ANDS R0, R1, #0 ; R0 = R1 AND 0, 更新标志寄存器
; ARM64版本
AND W0, W1, W2 ; 32位操作
AND X0, X1, X2 ; 64位操作
RISC-V架构
assembly
# RISC-V汇编
# and rd, rs1, rs2 (rd = rs1 & rs2)
# 寄存器操作
and a0, a1, a2 # a0 = a1 & a2
# 立即数操作
andi a0, a1, 0xFF # a0 = a1 & 0xFF (保留低8位)
1.2 按位或操作(OR)
OR指令执行逻辑或操作，如果两个操作数的对应位中至少有一位为1，则结果位为1。
x86/x64架构
assembly
; Intel语法
; OR destination, source (destination = destination OR source)
; 寄存器与寄存器
OR EAX, EBX ; EAX = EAX OR EBX
; 寄存器与立即数
OR CL, 0x80 ; CL = CL OR 0x80 (设置最高位)
; 寄存器与内存
OR EDX, [flags] ; EDX = EDX OR 内存中的标志值
; 内存与寄存器/立即数
OR WORD [control], 0x0003 ; 设置内存地址control处的两个低位
; 影响标志位: OF=0, CF=0, SF, ZF, PF (可预测:OF和CF总是被清除)
ARM架构
assembly
; ARM汇编
; ORR{S} destination, source1, source2
; 寄存器操作
ORR R0, R1, R2 ; R0 = R1 OR R2
; 立即数操作
ORR R0, R1, #0x80 ; R0 = R1 OR 0x80 (设置第7位)
; ARM64版本
ORR W0, W1, W2 ; 32位操作
ORR X0, X1, X2 ; 64位操作
RISC-V架构
assembly
# RISC-V汇编
# or rd, rs1, rs2 (rd = rs1 | rs2)
# 寄存器操作
or a0, a1, a2 # a0 = a1 | a2
# 立即数操作
ori a0, a1, 0x80 # a0 = a1 | 0x80 (设置第7位)
1.3 按位异或操作(XOR)
XOR指令执行逻辑异或操作，当两个操作数的对应位不同时，结果位为1。
x86/x64架构
assembly
; Intel语法
; XOR destination, source (destination = destination XOR source)
; 寄存器与寄存器
XOR EAX, EBX ; EAX = EAX XOR EBX
; 寄存器与立即数
XOR CL, 0xFF ; CL = CL XOR 0xFF (翻转所有位)
; 快速清零寄存器(同一寄存器异或自身)
XOR EAX, EAX ; EAX = 0 (比MOV EAX,0更快且代码更小)
; 内存操作
XOR DWORD [buffer], 0x12345678 ; 与魔数进行异或(简单加密)
; 影响标志位: OF=0, CF=0, SF, ZF, PF (可预测:OF和CF总是被清除)
ARM架构
assembly
; ARM汇编
; EOR{S} destination, source1, source2
; 寄存器操作
EOR R0, R1, R2 ; R0 = R1 XOR R2
; 立即数操作
EOR R0, R1, #0xFF ; R0 = R1 XOR 0xFF (翻转低8位)
; 快速清零
EOR R0, R0, R0 ; R0 = 0
; ARM64版本
EOR W0, W1, W2 ; 32位操作
EOR X0, X1, X2 ; 64位操作
RISC-V架构
assembly
# RISC-V汇编
# xor rd, rs1, rs2 (rd = rs1 ^ rs2)
# 寄存器操作
xor a0, a1, a2 # a0 = a1 ^ a2
# 立即数操作
xori a0, a1, 0xFF # a0 = a1 ^ 0xFF (翻转低8位)
# 快速清零
xor a0, a0, a0 # a0 = 0
1.4 按位非操作(NOT)
NOT指令执行一元逻辑非操作，将操作数的每一位都取反。
x86/x64架构
assembly
; Intel语法
; NOT operand (operand = ~operand)
; 寄存器操作
NOT EAX ; EAX = ~EAX (翻转所有位)
; 内存操作
NOT BYTE [flags] ; 翻转内存中的标志字节的所有位
; 注意: NOT指令不影响任何标志位
ARM架构
assembly
; ARM汇编
; ARM使用MVN(MoVe Not)指令
; 寄存器操作
MVN R0, R1 ; R0 = ~R1 (R1的按位取反)
; 立即数操作
MVN R0, #0xFF ; R0 = ~0xFF (非0xFF)
; ARM64版本
MVN W0, W1 ; 32位操作
MVN X0, X1 ; 64位操作
RISC-V架构
assembly
# RISC-V汇编(没有专用的NOT指令，使用XORI实现)
# 实现NOT操作
xori a0, a1, -1 # a0 = a1 ^ -1 (按位取反)
# 或者使用更原始的序列
addi a0, zero, -1 # a0 = -1 (全1)
xor a0, a0, a1 # a0 = ~a1 (按位取反)
2. 位移和旋转操作
位移和旋转指令是位操作的重要组成部分，它们可以将操作数的位向左或向右移动特定的位数。
2.1 逻辑左移(SHL/SAL)
逻辑左移将所有位向左移动指定的位数，右侧用0填充，最左侧的位移出。
x86/x64架构
assembly
; Intel语法
; SHL/SAL destination, count (逻辑左移/算术左移，这两个指令功能相同)
; 寄存器操作，移动固定位数
SHL EAX, 1 ; EAX = EAX << 1 (左移1位)
SHL BX, 4 ; BX = BX << 4 (左移4位)
; 由CL寄存器指定移位数量
MOV CL, 3
SHL EDX, CL ; EDX = EDX << 3 (左移CL指定的位数)
; 内存操作
SHL DWORD [value], 2 ; 内存中的双字左移2位
; 影响标志位: CF(最后移出的位), OF(对于1位移动，设置为最高两位的XOR), SF, ZF, PF
ARM架构
assembly
; ARM汇编
; LSL{S} destination, source, #shift/register
; 立即数移位
LSL R0, R1, #4 ; R0 = R1 << 4 (左移4位)
; 寄存器控制移位
LSL R0, R1, R2 ; R0 = R1 << R2 (左移R2指定的位数)
; ARM64版本
LSL W0, W1, #4 ; 32位左移
LSL X0, X1, #4 ; 64位左移
RISC-V架构
assembly
# RISC-V汇编
# slli rd, rs1, imm (rd = rs1 << imm，立即数移位)
# sll rd, rs1, rs2 (rd = rs1 << rs2，寄存器移位)
# 立即数移位
slli a0, a1, 4 # a0 = a1 << 4 (左移4位)
# 寄存器控制移位
sll a0, a1, a2 # a0 = a1 << a2 (左移a2指定的位数)
2.2 逻辑右移(SHR)
逻辑右移将所有位向右移动指定的位数，左侧用0填充，最右侧的位移出。
x86/x64架构
assembly
; Intel语法
; SHR destination, count
; 寄存器操作，移动固定位数
SHR EAX, 1 ; EAX = EAX >> 1 (右移1位)
SHR BX, 4 ; BX = BX >> 4 (右移4位)
; 由CL寄存器指定移位数量
MOV CL, 3
SHR EDX, CL ; EDX = EDX >> 3 (右移CL指定的位数)
; 内存操作
SHR DWORD [value], 2 ; 内存中的双字右移2位
; 影响标志位: CF(最后移出的位), OF(对于1位移动，设置为原始符号位), SF, ZF, PF
ARM架构
assembly
; ARM汇编
; LSR{S} destination, source, #shift/register
; 立即数移位
LSR R0, R1, #4 ; R0 = R1 >> 4 (逻辑右移4位)
; 寄存器控制移位
LSR R0, R1, R2 ; R0 = R1 >> R2 (逻辑右移R2指定的位数)
; ARM64版本
LSR W0, W1, #4 ; 32位逻辑右移
LSR X0, X1, #4 ; 64位逻辑右移
RISC-V架构
assembly
# RISC-V汇编
# srli rd, rs1, imm (rd = rs1 >> imm，立即数逻辑右移)
# srl rd, rs1, rs2 (rd = rs1 >> rs2，寄存器逻辑右移)
# 立即数移位
srli a0, a1, 4 # a0 = a1 >> 4 (逻辑右移4位)
# 寄存器控制移位
srl a0, a1, a2 # a0 = a1 >> a2 (逻辑右移a2指定的位数)
2.3 算术右移(SAR)
算术右移与逻辑右移类似，但保留符号位，左侧用符号位填充。
x86/x64架构
assembly
; Intel语法
; SAR destination, count
; 寄存器操作，移动固定位数
SAR EAX, 1 ; EAX = EAX >> 1 (算术右移1位)
SAR BX, 4 ; BX = BX >> 4 (算术右移4位)
; 由CL寄存器指定移位数量
MOV CL, 3
SAR EDX, CL ; EDX = EDX >> 3 (算术右移CL指定的位数)
; 内存操作
SAR DWORD [value], 2 ; 内存中的双字算术右移2位
; 影响标志位: CF(最后移出的位), OF(对于1位移动，清零), SF, ZF, PF
ARM架构
assembly
; ARM汇编
; ASR{S} destination, source, #shift/register
; 立即数移位
ASR R0, R1, #4 ; R0 = R1 >> 4 (算术右移4位)
; 寄存器控制移位
ASR R0, R1, R2 ; R0 = R1 >> R2 (算术右移R2指定的位数)
; ARM64版本
ASR W0, W1, #4 ; 32位算术右移
ASR X0, X1, #4 ; 64位算术右移
RISC-V架构
assembly
# RISC-V汇编
# srai rd, rs1, imm (rd = rs1 >> imm，立即数算术右移)
# sra rd, rs1, rs2 (rd = rs1 >> rs2，寄存器算术右移)
# 立即数移位
srai a0, a1, 4 # a0 = a1 >> 4 (算术右移4位)
# 寄存器控制移位
sra a0, a1, a2 # a0 = a1 >> a2 (算术右移a2指定的位数)
2.4 旋转操作(ROL/ROR)
旋转操作将位循环移位，移出的位会从另一端移入，不会丢失任何位。
x86/x64架构
assembly
; Intel语法
; ROL destination, count (向左旋转)
; ROR destination, count (向右旋转)
; 向左旋转
ROL EAX, 1 ; 将EAX中的所有位向左旋转1位
ROL BL, 4 ; 将BL中的所有位向左旋转4位
; 向右旋转
ROR EDX, 1 ; 将EDX中的所有位向右旋转1位
ROR WORD [value], 3 ; 将内存中的字向右旋转3位
; 由CL寄存器指定旋转位数
MOV CL, 5
ROL ESI, CL ; 将ESI中的所有位向左旋转CL指定的位数
; 影响标志位: CF(最后旋转出的位), OF(对于1位旋转，设置为结果最高位与次高位的XOR)
ARM架构
assembly
; ARM汇编
; ROR{S} destination, source, #shift/register
; 立即数旋转
ROR R0, R1, #8 ; R0 = R1 ROR 8 (向右旋转8位)
; 寄存器控制旋转
ROR R0, R1, R2 ; R0 = R1 ROR R2 (向右旋转R2指定的位数)
; ARM64版本
ROR W0, W1, #8 ; 32位向右旋转
ROR X0, X1, #8 ; 64位向右旋转
; 注意: ARM没有专用的向左旋转指令，但可以使用向右旋转实现
; 左旋N位 = 右旋(寄存器宽度-N)位
ROR R0, R1, #(32-8) ; 等效于向左旋转8位
RISC-V架构
assembly
# RISC-V (RV32I/RV64I基本指令集没有内置旋转指令)
# 在RV32B/RV64B位操作扩展中提供
# 使用RV32B扩展
rol a0, a1, a2 # 向左旋转
rori a0, a1, 8 # 向左旋转立即数8位
ror a0, a1, a2 # 向右旋转
rori a0, a1, 8 # 向右旋转立即数8位
# 不使用B扩展时的模拟方法(向左旋转)
# a0 = a1循环左移a2位
sll t0, a1, a2 # t0 = a1 << a2
sub t1, zero, a2
addi t1, t1, 32 # t1 = 32 - a2
srl t2, a1, t1 # t2 = a1 >> (32 - a2)
or a0, t0, t2 # 组合两部分
2.5 带进位的移位指令(RCL/RCR)
这些指令在移位过程中包含进位标志，形成更长的旋转链。
x86/x64架构
assembly
; Intel语法
; RCL destination, count (带进位向左旋转)
; RCR destination, count (带进位向右旋转)
; 带进位向左旋转
STC ; 设置进位标志(CF=1)
RCL EAX, 1 ; 旋转EAX和CF，CF进入LSB，MSB进入CF
; 带进位向右旋转
CLC ; 清除进位标志(CF=0)
RCR EAX, 1 ; 旋转EAX和CF，CF进入MSB，LSB进入CF
; 影响标志位: CF(最后移出的位), OF(对于1位旋转，由结果符号位变化设置)
注意: ARM和RISC-V基本指令集没有直接对应的带进位旋转指令，需要使用常规指令组合实现类似功能。
3. 位测试和位操作指令
这些指令用于测试、设置、清除或翻转特定位，非常适合位级编程。
3.1 位测试指令(BT/BTS/BTR/BTC)
这些指令测试特定位，并可选择性地设置、复位或补码该位。
x86/x64架构
assembly
; Intel语法
; BT destination, bit_position (位测试)
; BTS destination, bit_position (位测试并设置)
; BTR destination, bit_position (位测试并重置)
; BTC destination, bit_position (位测试并补码)
; 测试第3位(0-based)
BT EAX, 3 ; 测试EAX的第3位，结果放入CF
JC bit_is_set ; 如果第3位是1，则跳转
; 测试并设置第5位
BTS DWORD [flags], 5 ; 测试内存中双字的第5位，然后设置为1
; 测试并重置第2位
BTR ECX, 2 ; 测试ECX的第2位，然后设置为0
; 测试并翻转第7位
BTC BL, 7 ; 测试BL的第7位，然后将其翻转
; 使用寄存器指定位位置
MOV CL, 4
BT EDX, CL ; 测试EDX的第CL(4)位
; 影响标志位: CF(被测试的位), 其他标志位未定义
注意: ARM和RISC-V基本指令集中没有直接对应的位测试指令，需要使用AND和比较指令组合实现。
3.2 位扫描指令(BSF/BSR)
这些指令在操作数中搜索第一个设置(1)或清除(0)的位。
x86/x64架构
assembly
; Intel语法
; BSF destination, source (正向扫描位 - 查找最低的设置位)
; BSR destination, source (反向扫描位 - 查找最高的设置位)
; 查找最低设置位
BSF EAX, EBX ; 在EBX中找到第一个设为1的位，索引存入EAX
JZ zero_input ; 如果输入为0，则跳转(未找到位)
; 查找最高设置位
BSR EDX, [value] ; 在内存值中找到最高设为1的位，索引存入EDX
; 这些指令在输入为0时，ZF=1，目标寄存器值未定义
; 否则，ZF=0，目标寄存器包含找到的位索引
ARM架构
assembly
; ARM汇编
; ARM提供计数前导零指令CLZ和ARMv8提供计数尾随零RBIT+CLZ
; 查找最高设置位(类似于BSR)
CLZ R0, R1 ; R0 = 前导零的数量
RSB R0, R0, #31 ; R0 = 31 - 前导零 = 最高设置位的索引
; 查找最低设置位(类似于BSF，ARMv7没有直接支持)
RBIT R0, R1 ; 位反转 (ARMv8/ARM64)
CLZ R0, R0 ; 计算尾随零
RISC-V架构
assembly
# RISC-V位操作扩展(B)提供这些功能
# 最高位(类似于BSR)
clz a0, a1 # 计数前导零
addi a2, zero, 31
sub a0, a2, a0 # a0 = 31 - 前导零 = 最高位索引
# 最低位(类似于BSF)
ctz a0, a1 # 计数尾随零
3.3 位字段提取和插入(x86)
这些指令允许在一个操作数中提取和插入连续的位字段。
x86/x64架构
assembly
; Intel语法
; BF指令族仅在Intel 386处理器后提供
; BEXTR - 位提取(BMI1扩展)
; BEXTR destination, source, control
; control: 低8位=起始位，中间8位=长度
; 提取位字段示例
MOV EAX, 0x12345678 ; 示例值
MOV EBX, 0x0C04 ; 开始位=4, 长度=12
BEXTR ECX, EAX, EBX ; ECX = 从位4开始提取12位 = 0x00000567
; BMI2扩展中更多位操作:
; BZHI - 零高位
BZHI EAX, EBX, ECX ; EAX = EBX截断到ECX指定的索引(清除更高位)
; PEXT - 并行位提取
PEXT EAX, EBX, ECX ; 从EBX提取ECX中设置的位并压缩到EAX
; PDEP - 并行位存放
PDEP EAX, EBX, ECX ; 将EBX中的位扩展到ECX中设置的位位置
4. 常见的逻辑指令应用模式
4.1 位掩码操作
位掩码是处理二进制数据的基本技术，使用逻辑指令结合特定的掩码值。
设置特定位
assembly
; Intel语法 - 设置特定位
MOV EAX, [flags] ; 加载当前标志
OR EAX, 0x00000008 ; 设置位3 (0-based)
MOV [flags], EAX ; 存储更新后的标志
; ARM汇编
LDR R0, [R1] ; 加载当前标志
ORR R0, R0, #0x8 ; 设置位3
STR R0, [R1] ; 存储更新后的标志
; RISC-V汇编
lw a0, 0(a1) # 加载当前标志
ori a0, a0, 0x8 # 设置位3
sw a0, 0(a1) # 存储更新后的标志
清除特定位
assembly
; Intel语法 - 清除特定位
MOV EAX, [flags] ; 加载当前标志
AND EAX, ~0x00000004 ; 清除位2 (~为C语言按位取反运算符)
MOV [flags], EAX ; 存储更新后的标志
; 替代方式(避免使用大立即数)
AND EAX, 0xFFFFFFFB ; 0xFFFFFFFB = ~0x00000004
; ARM汇编
LDR R0, [R1] ; 加载当前标志
BIC R0, R0, #0x4 ; 位清除(R0 = R0 & ~0x4)
STR R0, [R1] ; 存储更新后的标志
; RISC-V汇编
lw a0, 0(a1) # 加载当前标志
li a2, 0x4
not a2, a2 # a2 = ~0x4
and a0, a0, a2 # 清除位2
sw a0, 0(a1) # 存储更新后的标志
测试特定位
assembly
; Intel语法 - 测试特定位
MOV EAX, [flags] ; 加载标志
TEST EAX, 0x00000002 ; 测试位1
JNZ bit_is_set ; 如果位1设置，则跳转
; 替代方式(使用BT指令)
BT DWORD [flags], 1 ; 测试位1
JC bit_is_set ; 如果位1设置，则跳转
; ARM汇编
LDR R0, [R1] ; 加载标志
TST R0, #0x2 ; 测试位1
BNE bit_is_set ; 如果位1设置，则跳转
; RISC-V汇编
lw a0, 0(a1) # 加载标志
andi a0, a0, 0x2 # 测试位1
bnez a0, bit_is_set # 如果位1设置，则跳转
翻转特定位
assembly
; Intel语法 - 翻转特定位
MOV EAX, [flags] ; 加载当前标志
XOR EAX, 0x00000001 ; 翻转位0
MOV [flags], EAX ; 存储更新后的标志
; 替代方式(使用BTC指令)
BTC DWORD [flags], 0 ; 测试并翻转位0
; ARM汇编
LDR R0, [R1] ; 加载当前标志
EOR R0, R0, #0x1 ; 翻转位0
STR R0, [R1] ; 存储更新后的标志
; RISC-V汇编
lw a0, 0(a1) # 加载当前标志
xori a0, a0, 0x1 # 翻转位0
sw a0, 0(a1) # 存储更新后的标志
4.2 位字段操作
操作一个值中的连续位字段。
提取位字段
assembly
; Intel语法 - 提取位字段
; 例如: 从EAX提取位8-15(8位字段)
MOV EBX, EAX ; 复制值
SHR EBX, 8 ; 右移8位，将目标字段移至最低位
AND EBX, 0xFF ; 掩码，仅保留最低8位
; 替代方式(无符号右移保证高位为0)
MOV EBX, EAX ; 复制值
SHR EBX, 8 ; 右移8位
AND EBX, 0xFF ; 掩码操作
; ARM汇编
MOV R1, R0 ; 复制值
LSR R1, R1, #8 ; 右移8位
AND R1, R1, #0xFF ; 掩码操作
; 或者使用UBFX(无符号位字段提取)
UBFX R1, R0, #8, #8 ; R1 = R0[15:8]
; RISC-V汇编
srli a1, a0, 8 # 右移8位
andi a1, a1, 0xFF # 掩码操作
插入位字段
assembly
; Intel语法 - 插入位字段
; 例如: 将CL中的值插入EAX的位16-23
AND EAX, ~0x00FF0000 ; 清除目标位置
MOV EBX, ECX ; 复制值到EBX
AND EBX, 0xFF ; 确保只有8位有效
SHL EBX, 16 ; 将值左移到正确位置
OR EAX, EBX ; 将值插入到EAX
; ARM汇编
BIC R0, R0, #0xFF0000 ; 清除目标位置
AND R2, R1, #0xFF ; 掩码输入值
LSL R2, R2, #16 ; 将值左移到正确位置
ORR R0, R0, R2 ; 将值插入到R0
; 或者使用BFI(位字段插入)
BFI R0, R1, #16, #8 ; 将R1的低8位插入R0位16-23
; RISC-V汇编(RV32基本指令集)
li a3, 0xFF0000
not a3, a3 # a3 = ~0xFF0000
and a0, a0, a3 # 清除目标位置
andi a2, a1, 0xFF # 掩码输入值
slli a2, a2, 16 # 将值左移到正确位置
or a0, a0, a2 # 将值插入到a0
4.3 条件处理
使用逻辑指令进行条件处理可以避免分支，提高性能。
条件选择(无分支)
assembly
; Intel语法 - 根据条件EBX>=0选择: result = EBX>=0 ? EAX : ECX
MOV EDX, EAX ; 复制第一个选项
TEST EBX, EBX ; 测试EBX的符号
MOV EDX, ECX ; 如果EBX<0，使用第二个选项(可能影响前一个值)
CMOVS EDX, EAX ; 如果符号位置位(负)，选择第一个选项
; ARM汇编
MOV R3, R0 ; 复制第一个选项
CMP R1, #0 ; 比较R1和0
MOVLT R3, R2 ; 如果R1<0，使用第二个选项
; 或使用ARM64的条件选择
CMP X1, #0 ; 比较X1和0
CSEL X3, X0, X2, LT ; 如果X1<0，X3=X0，否则X3=X2
; RISC-V汇编
mv a3, a0 # 复制第一个选项
bgez a1, skip # 如果a1>=0，跳过
mv a3, a2 # 使用第二个选项
skip:
# 结果在a3中
条件设置(无分支)
assembly
; Intel语法 - 设置结果为: result = (EAX < 100) ? 1 : 0
XOR ECX, ECX ; 清零结果寄存器
CMP EAX, 100 ; 比较EAX与100
SETL CL ; 如果EAX<100，设置CL=1，否则CL=0
; 或使用SETcc指令
CMP EAX, 100 ; 比较EAX与100
SBB EDX, EDX ; 如果CF=1，EDX=0xFFFFFFFF，否则EDX=0
AND EDX, 1 ; 保留最低位，结果为0或1
; ARM汇编
MOV R2, #0 ; 默认结果为0
CMP R0, #100 ; 比较R0与100
MOVLT R2, #1 ; 如果R0<100，设置结果为1
; RISC-V汇编
li a2, 0 # 默认结果为0
slti a3, a0, 100 # a3 = (a0 < 100) ? 1 : 0
mv a2, a3 # 复制结果
4.4 快速算法优化
逻辑指令可以用于优化特定算法，尤其是位级操作。
奇偶性检查
assembly
; Intel语法 - 检查EAX中的位计数是否为偶数
MOV ECX, EAX ; 复制值
SHR ECX, 16 ; 将高16位移到低位
XOR EAX, ECX ; 合并奇偶性
MOV ECX, EAX ; 再次复制
SHR ECX, 8 ; 右移8位
XOR EAX, ECX ; 合并奇偶性
MOV ECX, EAX ; 再次复制
SHR ECX, 4 ; 右移4位
XOR EAX, ECX ; 合并奇偶性
MOV ECX, EAX ; 再次复制
SHR ECX, 2 ; 右移2位
XOR EAX, ECX ; 合并奇偶性
MOV ECX, EAX ; 再次复制
SHR ECX, 1 ; 右移1位
XOR EAX, ECX ; 最终奇偶性位在位0
AND EAX, 1 ; 提取奇偶性位
; 更简单的方式(通过POPCNT和条件)
POPCNT EAX, EAX ; 计算位计数
AND EAX, 1 ; 检查是否为偶数(位0=0表示偶数)
; 另一种方式(使用奇偶位PF)
TEST EAX, EAX ; 设置PF标志
SETP AL ; 如果奇偶位相等(偶数个1)则AL=1
; ARM NEON汇编(较复杂)
VCNT.8 D0, D0 ; 按字节计数位
VPADD.I8 D0, D0, D0 ; 对位计数求和
VMOV.32 R0, D0[0] ; 移动结果到通用寄存器
AND R0, R0, #1 ; 提取奇偶性
; RISC-V汇编
# 使用类似于x86的多步XOR方法
srli t0, a0, 16 # 右移16位
xor a0, a0, t0 # 合并奇偶性
srli t0, a0, 8 # 右移8位
xor a0, a0, t0 # 合并奇偶性
srli t0, a0, 4 # 右移4位
xor a0, a0, t0 # 合并奇偶性
srli t0, a0, 2 # 右移2位
xor a0, a0, t0 # 合并奇偶性
srli t0, a0, 1 # 右移1位
xor a0, a0, t0 # 最终奇偶性位在位0
andi a0, a0, 1 # 提取奇偶性位
计算绝对值(无分支)
assembly
; Intel语法 - 计算绝对值: EAX = abs(EAX)
MOV ECX, EAX ; 保存原始值
NEG EAX ; 计算-EAX
TEST ECX, ECX ; 测试原始值的符号
CMOVS EAX, ECX ; 如果原始值为负，取补码
; 较短方式:
MOV EDX, EAX ; 复制值
SAR EDX, 31 ; 算术右移31位：如果EAX<0则EDX=0xFFFFFFFF，否则EDX=0
XOR EAX, EDX ; 相当于: 如果EDX=0xFFFFFFFF则按位翻转EAX
SUB EAX, EDX ; 添加1(如果EDX=0xFFFFFFFF，否则加0)
; ARM汇编
EOR R1, R0, R0, ASR #31 ; R1 = R0 XOR (R0>>31)
SUB R0, R1, R0, ASR #31 ; R0 = R1 - (R0>>31)
; RISC-V汇编
srai t0, a0, 31 # t0 = a0 >> 31 (复制符号位)
xor a0, a0, t0 # 条件按位翻转
sub a0, a0, t0 # 负数情况下加1
判断2的幂次
assembly
; Intel语法 - 检查EAX是否为2的幂
TEST EAX, EAX ; 首先检查是否为0
JZ not_power_of_two ; 如果是0，则不是2的幂
MOV ECX, EAX ; 复制值
SUB ECX, 1 ; 减1
AND EAX, ECX ; 按位与操作
JZ is_power_of_two ; 如果结果为0，则是2的幂
; ARM汇编
CMP R0, #0 ; 检查是否为0
BEQ not_power_of_two
SUB R1, R0, #1 ; R1 = R0 - 1
TST R0, R1 ; 测试 R0 & (R0 - 1)
BEQ is_power_of_two ; 如果结果为0，则是2的幂
; RISC-V汇编
beqz a0, not_power_of_two # 检查是否为0
addi t0, a0, -1 # t0 = a0 - 1
and t0, a0, t0 # t0 = a0 & (a0 - 1)
beqz t0, is_power_of_two # 如果结果为0，则是2的幂
4.5 高级位操作技术
一些复杂但有用的位操作技术。
隔离最低设置位
assembly
; Intel语法 - 提取最低设置位: EBX = EAX & -EAX
MOV EBX, EAX ; 复制值
NEG EBX ; 对EBX取负(取补+1)
AND EBX, EAX ; EBX = EAX & -EAX (提取最低设置位)
; 或使用BMI1扩展中的BLSI指令
BLSI EBX, EAX ; 提取最低设置位
; ARM汇编
RSB R1, R0, #0 ; R1 = -R0 (取补+1)
AND R1, R0, R1 ; R1 = R0 & -R0
; RISC-V汇编
neg t0, a0 # t0 = -a0
and a1, a0, t0 # a1 = a0 & -a0
清除最低设置位
assembly
; Intel语法 - 清除最低设置位: EBX = EAX & (EAX - 1)
MOV EBX, EAX ; 复制值
SUB EBX, 1 ; 减1
AND EBX, EAX ; EBX = EAX & (EAX - 1)
; 或使用BMI1扩展中的BLSR指令
BLSR EBX, EAX ; 清除最低设置位
; ARM汇编
SUB R1, R0, #1 ; R1 = R0 - 1
AND R1, R0, R1 ; R1 = R0 & (R0 - 1)
; RISC-V汇编
addi t0, a0, -1 # t0 = a0 - 1
and a1, a0, t0 # a1 = a0 & (a0 - 1)
位反转(镜像)
assembly
; Intel语法(x86) - 反转EAX中的所有位
; 使用分步交换算法:
; 交换相邻位
MOV ECX, EAX
SHR ECX, 1
AND ECX, 0x55555555 ; 提取偶数位并右移
AND EAX, 0x55555555 ; 提取奇数位
SHL EAX, 1 ; 左移
OR EAX, ECX ; 组合
; 交换相邻2位对
MOV ECX, EAX
SHR ECX, 2
AND ECX, 0x33333333 ; 提取偶数对并右移
AND EAX, 0x33333333 ; 提取奇数对
SHL EAX, 2 ; 左移
OR EAX, ECX ; 组合
; 交换相邻4位对
MOV ECX, EAX
SHR ECX, 4
AND ECX, 0x0F0F0F0F ; 提取偶数4位并右移
AND EAX, 0x0F0F0F0F ; 提取奇数4位
SHL EAX, 4 ; 左移
OR EAX, ECX ; 组合
; 交换字节
BSWAP EAX ; 反转字节顺序(仅适用于32/64位寄存器)
; 使用BMI2扩展时:
MOVD XMM0, EAX
PEXT EAX, EAX, 0 ; 清零EAX
MOVQ XMM1, RAX
MOVDQA XMM2, [bit_reverse_table]
PSHUFB XMM0, XMM2 ; 使用查找表反转位
MOVD EAX, XMM0
; ARM汇编
RBIT R0, R0 ; 反转R0中的所有位(ARMv7及更高版本)
; RISC-V汇编(使用位操作扩展B)
grevi a0, a0, 31 # 通用位反转 - 0x1F
5. 特定应用场景中的逻辑指令
5.1 密码学应用
逻辑指令在密码学算法中广泛使用，特别是在对称加密和哈希函数中。
简单XOR加密
assembly
; Intel语法 - 使用密钥对缓冲区加密
; 参数: ESI=缓冲区指针, EDI=长度, EBX=密钥
xor_encrypt:
mov ecx, edi ; 设置计数器
test ecx, ecx ; 检查长度
jz encrypt_done ; 如果长度为0，则完成
encrypt_loop:
mov al, [esi] ; 加载字节
xor al, bl ; 与密钥异或
mov [esi], al ; 存储加密的字节
inc esi ; 增加指针
rol ebx, 1 ; 旋转密钥以增加安全性
dec ecx ; 减少计数器
jnz encrypt_loop ; 如果未完成，则继续
encrypt_done:
ret
; ARM汇编
; 参数: R0=缓冲区指针, R1=长度, R2=密钥
xor_encrypt:
CMP R1, #0 ; 检查长度
BEQ encrypt_done ; 如果为0，则完成
encrypt_loop:
LDRB R3, [R0] ; 加载字节
EOR R3, R3, R2 ; 与密钥异或
STRB R3, [R0], #1 ; 存储并增加指针
ROR R2, R2, #1 ; 旋转密钥
SUBS R1, R1, #1 ; 减少计数器
BNE encrypt_loop ; 继续循环
encrypt_done:
BX LR ; 返回
SHA-256逻辑函数(简化)
assembly
; Intel语法 - SHA-256的核心逻辑函数(简化)
; Ch(x,y,z) = (x & y) ^ (~x & z)
sha256_ch:
mov ecx, eax ; ECX = x
and ecx, ebx ; ECX = x & y
not eax ; EAX = ~x
and eax, edx ; EAX = ~x & z
xor eax, ecx ; EAX = (x & y) ^ (~x & z)
ret
; Maj(x,y,z) = (x & y) ^ (x & z) ^ (y & z)
sha256_maj:
mov esi, eax ; ESI = x
mov edi, eax ; EDI = x
and esi, ebx ; ESI = x & y
and edi, edx ; EDI = x & z
xor esi, edi ; ESI = (x & y) ^ (x & z)
mov edi, ebx ; EDI = y
and edi, edx ; EDI = y & z
xor eax, esi ; EAX = ESI ^ (y & z)
ret
5.2 图形编程
位操作在图形编程中用于颜色处理、掩码操作和快速算法。
颜色分量提取(RGBA)
assembly
; Intel语法 - 从32位RGBA颜色中提取分量
; 输入: EAX = RGBA颜色(0xAARRGGBB)
; 提取红色分量(第二个字节)
mov ebx, eax ; 复制颜色
shr ebx, 16 ; 右移16位
and ebx, 0xFF ; 掩码，只保留红色分量
; 提取绿色分量(第三个字节)
mov ecx, eax ; 复制颜色
shr ecx, 8 ; 右移8位
and ecx, 0xFF ; 掩码，只保留绿色分量
; 提取蓝色分量(第四个字节)
mov edx, eax ; 复制颜色
and edx, 0xFF ; 掩码，只保留蓝色分量
; 提取Alpha分量(第一个字节)
mov esi, eax ; 复制颜色
shr esi, 24 ; 右移24位(alpha在最高位)
; 使用BMI2扩展:
MOVD XMM0, EAX ; 移动颜色到XMM寄存器
PEXTRB EBX, XMM0, 2 ; 提取红色(索引2)
PEXTRB ECX, XMM0, 1 ; 提取绿色(索引1)
PEXTRB EDX, XMM0, 0 ; 提取蓝色(索引0)
PEXTRB ESI, XMM0, 3 ; 提取alpha(索引3)
颜色混合(alpha混合)
assembly
; Intel语法 - Alpha混合
; EAX = 背景色, EBX = 前景色, CL = alpha值(0-255)
; 结果 = 前景色 * alpha + 背景色 * (255 - alpha) / 255
blend_color:
push ebp
mov ebp, esp
; 提取颜色分量，做法与上一个示例相同
; (假设这里已经提取了各个颜色分量)
; 混合红色分量
imul edx, ecx ; 前景红色 * alpha
mov edi, 255
sub edi, ecx ; 255 - alpha
imul esi, edi ; 背景红色 * (255 - alpha)
add edx, esi ; 总和
shr edx, 8 ; 除以255(近似)
; 对其他颜色分量重复上述过程...
; 组合回32位颜色
shl edx, 16 ; 将红色移到适当位置
; 添加其他颜色分量...
mov esp, ebp
pop ebp
ret
5.3 低级系统编程
逻辑指令在操作系统和设备驱动程序中非常重要。
位图内存分配器
assembly
; Intel语法 - 在位图中查找和设置一个空闲位
; 参数: ESI = 位图指针, EDI = 位图大小(字节)
find_free_bit:
mov ecx, edi ; 初始化计数器
xor eax, eax ; 初始化位图索引
scan_loop:
cmp BYTE [esi+eax], 0xFF ; 如果字节已满，则跳过
jne found_potential_byte
inc eax ; 下一个字节
dec ecx ; 减少计数器
jnz scan_loop ; 如果还有字节，继续扫描
mov eax, -1 ; 没有找到空闲位
ret
found_potential_byte:
mov bl, [esi+eax] ; 获取包含至少一个空闲位的字节
mov ecx, 0 ; 初始化位索引
bit_loop:
test bl, 1 ; 测试最低位
jz found_bit ; 如果是0，找到了空闲位
shr bl, 1 ; 移动到下一位
inc ecx ; 增加位索引
cmp ecx, 8 ; 检查是否已经检查了8位
jb bit_loop ; 如果小于8，继续
; 不应该到达这里，如果字节不是0xFF
inc eax ; 以防万一，移动到下一个字节
jmp scan_loop
found_bit:
; 计算绝对位索引
shl eax, 3 ; eax * 8 (字节到位)
add eax, ecx ; 添加位索引
; 设置位
mov edx, eax ; 复制绝对位索引
shr edx, 3 ; 除以8获得字节索引
mov bl, 1 ; 准备位掩码
mov cl, BYTE [eax & 7] ; 获取位索引(0-7)
shl bl, cl ; 移位掩码
or BYTE [esi+edx], bl ; 设置位
ret
权限检查
assembly
; Intel语法 - 检查用户是否有特定权限
; 参数: AL = 用户权限掩码, BL = 所需权限
check_permission:
test al, bl ; 测试用户是否有所有所需权限
jz permission_denied ; 如果有一些位未设置，则权限被拒绝
; 用户有权限
mov eax, 1 ; 返回成功(1)
ret
permission_denied:
xor eax, eax ; 返回失败(0)
ret
6. SIMD向量逻辑指令
现代处理器支持SIMD(单指令多数据)指令，可以并行处理多个数据元素。
6.1 x86 SSE/AVX逻辑指令
assembly
; Intel语法 - SSE2向量逻辑指令(128位XMM寄存器)
; 加载数据
MOVDQA XMM0, [data1] ; 加载16字节对齐数据
MOVDQA XMM1, [data2] ; 加载16字节对齐数据
; 向量按位与
PAND XMM0, XMM1 ; XMM0 = XMM0 AND XMM1(16个并行字节操作)
; 向量按位或
POR XMM0, XMM1 ; XMM0 = XMM0 OR XMM1
; 向量按位异或
PXOR XMM0, XMM1 ; XMM0 = XMM0 XOR XMM1
; 向量按位与非
PANDN XMM0, XMM1 ; XMM0 = (~XMM0) AND XMM1
; AVX指令(256位YMM寄存器)
VPAND YMM0, YMM1, YMM2 ; YMM0 = YMM1 AND YMM2(32个并行字节)
VPOR YMM0, YMM1, YMM2 ; YMM0 = YMM1 OR YMM2
VPXOR YMM0, YMM1, YMM2 ; YMM0 = YMM1 XOR YMM2
VPANDN YMM0, YMM1, YMM2 ; YMM0 = (~YMM1) AND YMM2
6.2 ARM NEON逻辑指令
assembly
; ARM NEON逻辑指令
; 加载数据
VLD1.8 {D0,D1}, [R0] ; 加载128位(16字节)到Q0
VLD1.8 {D2,D3}, [R1] ; 加载128位(16字节)到Q1
; 向量按位与
VAND Q0, Q0, Q1 ; Q0 = Q0 AND Q1
; 向量按位或
VORR Q0, Q0, Q1 ; Q0 = Q0 OR Q1
; 向量按位异或
VEOR Q0, Q0, Q1 ; Q0 = Q0 XOR Q1
; 向量按位位清除(AND NOT)
VBIC Q0, Q0, Q1 ; Q0 = Q0 AND NOT Q1
; ARM64 NEON语法
AND V0.16B, V0.16B, V1.16B ; 16个并行字节的按位与
ORR V0.16B, V0.16B, V1.16B ; 16个并行字节的按位或
EOR V0.16B, V0.16B, V1.16B ; 16个并行字节的按位异或
BIC V0.16B, V0.16B, V1.16B ; 16个并行字节的按位位清除
6.3 RISC-V向量扩展逻辑指令
assembly
# RISC-V向量扩展(V)逻辑指令
# 设置向量长度和类型
vsetvli t0, a0, e8 # 设置向量长度，8位元素
# 加载向量
vle8.v v0, (a1) # 从内存加载向量到v0
vle8.v v1, (a2) # 从内存加载向量到v1
# 向量按位与
vand.vv v2, v0, v1 # v2 = v0 AND v1
# 向量按位或
vor.vv v2, v0, v1 # v2 = v0 OR v1
# 向量按位异或
vxor.vv v2, v0, v1 # v2 = v0 XOR v1
# 向量按位非
vnot.v v2, v0 # v2 = NOT v0
7. 高级逻辑指令优化技巧
7.1 使用多个寄存器保存临时掩码
assembly
; Intel语法 - 使用预定义掩码提高效率
section .data
mask_low_byte dd 0x000000FF
mask_high_byte dd 0xFF000000
section .text
process_data:
; 预加载常用掩码
mov r8d, 0x000000FF ; 低字节掩码
mov r9d, 0xFF000000 ; 高字节掩码
; 现在在处理循环中使用这些掩码
process_loop:
mov eax, [esi]
; 提取低字节
mov ebx, eax
and ebx, r8d ; 使用预加载的掩码
; 提取高字节
mov ecx, eax
and ecx, r9d ; 使用预加载的掩码
shr ecx, 24 ; 右移到低位
; 处理...
add esi, 4
dec edi
jnz process_loop
ret
7.2 位字段压缩和解压缩
assembly
; Intel语法 - 将多个小字段压缩成一个整数
; 假设: CL=字段1(3位), DL=字段2(5位), BL=字段3(7位)
pack_fields:
xor eax, eax ; 清零结果
; 添加第一个字段(3位)
mov al, cl ; 复制字段1
and al, 0x07 ; 确保只有3位
; 添加第二个字段(5位)
mov ah, dl ; 复制字段2
and ah, 0x1F ; 确保只有5位
shl ax, 5 ; 在结果中为字段2腾出空间
or al, dl ; 组合字段2
; 添加第三个字段(7位)
shl eax, 7 ; 在结果中为字段3腾出空间
mov cl, bl ; 复制字段3
and cl, 0x7F ; 确保只有7位
or al, cl ; 组合字段3
ret
; 解压缩字段
unpack_fields:
; 假设EAX包含压缩值
; 提取字段3(7位)
mov ebx, eax
and ebx, 0x7F ; BL = 字段3
; 提取字段2(5位)
mov ecx, eax
shr ecx, 7
and ecx, 0x1F ; CL = 字段2
; 提取字段1(3位)
mov edx, eax
shr edx, 12
and edx, 0x07 ; DL = 字段1
ret
7.3 位图快速扫描
通过跳过全0或全1块加速位图搜索。
assembly
; Intel语法 - 快速在位图中查找第一个设置的位
; 参数: ESI = 位图指针, EDI = 位图大小(双字)
find_first_set_bit:
xor ecx, ecx ; 初始化双字索引
xor eax, eax ; 初始化位索引
; 首先按双字(32位)块扫描
dword_scan:
cmp ecx, edi ; 检查是否已扫描所有双字
jae not_found ; 如果是，未找到设置的位
mov edx, [esi + ecx*4] ; 加载当前双字
test edx, edx ; 检查是否有任何设置的位
jnz found_dword ; 如果有，处理这个双字
inc ecx ; 下一个双字
jmp dword_scan ; 继续扫描
found_dword:
; 现在找到这个双字中第一个设置的位
; 使用BSF指令查找
mov eax, ecx ; 保存双字索引
shl eax, 5 ; 乘以32(双字中的位数)
bsf edx, edx ; 在双字中查找第一个设置的位
add eax, edx ; 添加到结果
ret ; 返回绝对位索引
not_found:
mov eax, -1 ; 返回-1表示未找到
ret
7.4 无分支掩码生成
不使用分支生成掩码。
assembly
; Intel语法 - 基于条件生成掩码(无分支)
; 如果ECX>=EDX，则返回全1掩码，否则返回全0掩码
generate_mask:
xor eax, eax ; 假设结果为0
cmp ecx, edx ; 比较值
sbb eax, eax ; 如果CF=1(ECX<EDX)，EAX=0，否则EAX=0xFFFFFFFF
ret
; 基于条件生成掩码(符号位)
; 如果ECX为负，则返回全1掩码，否则返回全0掩码
generate_sign_mask:
mov eax, ecx
sar eax, 31 ; 将符号位复制到所有位
ret
8. 逻辑指令特殊场景
8.1 硬件端口和IO操作
在系统编程中使用逻辑指令处理硬件寄存器。
assembly
; Intel语法(x86) - 硬件I/O端口操作
; 假设使用特权级别
; 读取端口值，修改特定位，然后写回
in al, 0x60 ; 从键盘控制器读取状态
or al, 0x80 ; 设置位7
out 0x60, al ; 写回修改后的值
; 操作PIC中断控制器
mov al, 0x20 ; EOI命令
out 0x20, al ; 发送到PIC
8.2 内存映射寄存器操作
操作内存映射的硬件寄存器。
assembly
; Intel语法 - 操作内存映射寄存器
section .data
GPIO_BASE equ 0xFED00000 ; 示例GPIO寄存器基地址
GPIO_DATA equ GPIO_BASE ; 数据寄存器
GPIO_DIR equ GPIO_BASE+4 ; 方向寄存器
section .text
; 将GPIO引脚3设置为输出
mov ebx, [GPIO_DIR]
or ebx, (1 << 3) ; 设置位3
mov [GPIO_DIR], ebx
; 将GPIO引脚3设置为高电平
mov ebx, [GPIO_DATA]
or ebx, (1 << 3) ; 设置位3
mov [GPIO_DATA], ebx
; 将GPIO引脚3设置为低电平
mov ebx, [GPIO_DATA]
and ebx, ~(1 << 3) ; 清除位3
mov [GPIO_DATA], ebx
8.3 条件执行优化
在X86上实现类似ARM条件执行的优化。
assembly
; Intel语法 - 创建条件掩码进行类ARM条件执行
; 条件:如果ECX>=EDX，设置EAX为1，否则设置为2
; 传统方式使用分支:
cmp ecx, edx ; 比较ECX和EDX
jl less_than ; 如果小于，跳转
mov eax, 1 ; ECX>=EDX情况
jmp done
less_than:
mov eax, 2 ; ECX<EDX情况
done:
; 无分支优化版本:
xor eax, eax ; 清零EAX
cmp ecx, edx ; 比较ECX和EDX
setge al ; 如果ECX>=EDX则AL=1，否则AL=0
mov ebx, 2 ; 默认值2
neg eax ; 如果ECX>=EDX则EAX=0xFFFFFFFF，否则EAX=0
and eax, -1 ; 如果ECX>=EDX则EAX=-1，否则EAX=0
xor ebx, 1 ; EBX = 3 (2 XOR 1)
and eax, ebx ; 如果ECX>=EDX则EAX=3，否则EAX=0
xor eax, 2 ; 如果ECX>=EDX则EAX=1，否则EAX=2
9. 位掩码和位字段实际应用
9.1 状态标志实现
使用位来跟踪多个布尔状态。
assembly
; Intel语法 - 位标志定义和操作
section .data
; 定义标志位常量
FLAG_READ equ 0x01 ; 位0 = 读取权限
FLAG_WRITE equ 0x02 ; 位1 = 写入权限
FLAG_EXEC equ 0x04 ; 位2 = 执行权限
FLAG_HIDDEN equ 0x08 ; 位3 = 隐藏标志
FLAG_SYSTEM equ 0x10 ; 位4 = 系统标志
user_flags db 0 ; 用户标志存储
section .text
; 设置读写权限
mov al, [user_flags]
or al, FLAG_READ | FLAG_WRITE ; 组合标志
mov [user_flags], al
; 检查是否有执行权限
mov al, [user_flags]
test al, FLAG_EXEC
jz no_exec_permission
; 清除隐藏标志
mov al, [user_flags]
and al, ~FLAG_HIDDEN
mov [user_flags], al
; 检查是否有系统权限或执行权限
mov al, [user_flags]
test al, FLAG_SYSTEM | FLAG_EXEC
jz no_system_or_exec
9.2 位字段打包和提取
实现紧凑的数据结构。
assembly
; Intel语法 - 使用位字段实现紧凑的文件属性
; 8位文件属性格式:
; 位0-2: 文件类型(0-7)
; 位3-5: 用户权限(0-7)
; 位6: 是否隐藏
; 位7: 是否系统文件
; 创建文件属性
create_attributes:
; 参数: AL=文件类型, BL=用户权限, CL=隐藏标志, DL=系统标志
; 清除输出
xor ebx, ebx
; 设置文件类型(位0-2)
and eax, 0x07 ; 确保在范围内
or ebx, eax
; 设置用户权限(位3-5)
mov eax, edx
and eax, 0x07 ; 确保在范围内
shl eax, 3 ; 移到正确位置
or ebx, eax
; 设置隐藏标志(位6)
test ecx, ecx
jz skip_hidden
or ebx, 0x40 ; 设置位6
skip_hidden:
; 设置系统标志(位7)
test esi, esi
jz skip_system
or ebx, 0x80 ; 设置位7
skip_system:
mov eax, ebx ; 返回结果
ret
; 提取文件属性
extract_attributes:
; 参数: AL=打包的属性
; 返回: BL=文件类型, CL=用户权限, DL=隐藏标志, SIL=系统标志
; 提取文件类型(位0-2)
mov ebx, eax
and ebx, 0x07 ; 提取位0-2
; 提取用户权限(位3-5)
mov ecx, eax
shr ecx, 3
and ecx, 0x07 ; 提取位3-5
; 提取隐藏标志(位6)
mov edx, eax
shr edx, 6
and edx, 0x01 ; 提取位6
; 提取系统标志(位7)
mov esi, eax
shr esi, 7 ; 提取位7
ret
9.3 位图实现
使用位图跟踪分配状态。
assembly
; Intel语法 - 位图分配跟踪实现
section .data
bitmap times 128 db 0 ; 1024位的位图(可跟踪1024项)
bitmap_size equ 1024 ; 位图大小(位)
section .text
; 设置位(标记为已分配)
; 参数: EDI = 位索引
set_bit:
mov eax, edi
shr eax, 3 ; 除以8得到字节索引
mov ecx, edi
and ecx, 7 ; 得到位索引(0-7)
mov edx, 1
shl edx, cl ; 创建位掩码
or [bitmap + eax], dl ; 设置位
ret
; 清除位(标记为未分配)
; 参数: EDI = 位索引
clear_bit:
mov eax, edi
shr eax, 3 ; 除以8得到字节索引
mov ecx, edi
and ecx, 7 ; 得到位索引(0-7)
mov edx, 1
shl edx, cl ; 创建位掩码
not edx ; 翻转掩码
and [bitmap + eax], dl ; 清除位
ret
; 测试位(检查是否已分配)
; 参数: EDI = 位索引
; 返回: EAX = 1如果设置，0如果未设置
test_bit:
mov eax, edi
shr eax, 3 ; 除以8得到字节索引
mov ecx, edi
and ecx, 7 ; 得到位索引(0-7)
mov edx, 1
shl edx, cl ; 创建位掩码
mov al, [bitmap + eax] ; 加载字节
test al, dl ; 测试位
setnz al ; 如果位已设置，则设置AL=1，否则AL=0
movzx eax, al ; 零扩展到EAX
ret
10. 调试逻辑指令
10.1 跟踪标志位变化
监控逻辑操作如何影响处理器标志。
assembly
; Intel语法 - 记录标志位状态的调试函数
; 将当前标志位状态打印到调试接口
print_flags:
pushfd ; 将标志压栈
pop eax ; 弹出到EAX
push eax ; 保存标志副本
; 检查零标志(ZF)
bt eax, 6 ; 测试位6(ZF)
jc zf_set
; 输出"ZF=0\n" - 平台特定的调试输出
jmp next1
zf_set:
; 输出"ZF=1\n" - 平台特定的调试输出
next1:
; 检查进位标志(CF)
pop eax ; 恢复标志
push eax ; 再次保存
bt eax, 0 ; 测试位0(CF)
jc cf_set
; 输出"CF=0\n" - 平台特定的调试输出
jmp next2
cf_set:
; 输出"CF=1\n" - 平台特定的调试输出
next2:
; 检查符号标志(SF)
pop eax
push eax
bt eax, 7 ; 测试位7(SF)
jc sf_set
; 输出"SF=0\n" - 平台特定的调试输出
jmp next3
sf_set:
; 输出"SF=1\n" - 平台特定的调试输出
next3:
; 检查奇偶标志(PF)
pop eax
bt eax, 2 ; 测试位2(PF)
jc pf_set
; 输出"PF=0\n" - 平台特定的调试输出
jmp done
pf_set:
; 输出"PF=1\n" - 平台特定的调试输出
done:
ret
10.2 位图可视化
创建位图的可视化表示。
assembly
; Intel语法 - 创建位图的字符表示
; 参数: ESI = 位图指针, EDI = 位图大小(字节), EBX = 输出缓冲区
visualize_bitmap:
xor ecx, ecx ; 初始化字节计数器
byte_loop:
cmp ecx, edi ; 检查是否已处理所有字节
jae visual_done ; 如果是，完成
mov al, [esi + ecx] ; 加载当前字节
; 处理这个字节的8个位
mov edx, 8 ; 8个位/字节
bit_loop:
rol al, 1 ; 旋转位到进位标志
jc bit_one ; 如果设置，打印"1"
; 打印"0"
mov BYTE [ebx], '0'
jmp bit_next
bit_one:
; 打印"1"
mov BYTE [ebx], '1'
bit_next:
inc ebx ; 增加输出指针
dec edx ; 减少位计数
jnz bit_loop ; 如果还有位，继续
; 在每个字节之后添加空格
mov BYTE [ebx], ' '
inc ebx
; 每8个字节添加换行
inc ecx ; 增加字节计数
test ecx, 7 ; 检查是否是8的倍数
jnz byte_loop ; 如果不是，继续
; 添加换行
mov BYTE [ebx], 10 ; 换行符
inc ebx
jmp byte_loop ; 继续下一个字节
visual_done:
; 添加字符串终止符
mov BYTE [ebx], 0
ret
11. 总结
逻辑指令是汇编语言中不可或缺的一部分，为位级操作和底层系统编程提供了强大的工具。它们允许程序员直接操作单个位，实现高效的数据结构，优化算法，操作硬件，以及进行各种系统级任务。
本文涵盖了从基本的逻辑运算(AND, OR, XOR, NOT)到高级位操作技术的广泛内容，包括位移和旋转，位测试和操作，以及实际应用场景。我们探讨了在x86/x64, ARM和RISC-V等主要架构上的实现，以及SIMD向量逻辑指令如何通过并行处理提供额外的性能优势。
掌握逻辑指令对于以下领域尤为重要：
- 系统编程和设备驱动程序开发
- 嵌入式系统和微控制器编程
- 密码学和安全应用
- 图形和游戏开发
- 高性能计算和优化
- 位操作算法实现
通过有效地使用逻辑指令，程序员可以编写更高效、更紧凑和更优化的代码，充分利用处理器的位级操作能力。
扫一扫
6052
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
