汇编开发(二)：数据传输,地址和算法

最新推荐文章于 2022-04-30 09:59:03 发布
最新推荐文章于 2022-04-30 09:59:03 发布
阅读量1.1k 收藏 6
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mazaiting/article/details/88054066
版权
1. 数据传输指令
1). 操作数类型
[label:] mnemonic [operands][; comment]

指令可以有零个，一个，两个或者三个操作数。此处忽略label和comment， 如下：

mnemonic
mnemonic [destination]
mnemonic [destination],[source]
mnemonic [destination],[source-1],[source-2]

操作输的基本类型：

  • 立即数： 使用数字文本表达式
  • 寄存器： CPU中的寄存器
  • 内存： 直接引用内存地址
2). 直接内存操作数
操作数描述
reg88位普通用途的寄存器：AH, AL, BH, BL, CH, CL, DH, DL
reg1616位普通用途的寄存器：AX, BX, CX, DX, SI, DI, SP, BP
reg3232位普通用途的寄存器：EAX, EBX, ECX, EDX, ESI, EDI, ESP, EBP
reg任何普通用途的寄存器
sreg16位段寄存器：CS, DS, SS, ES, FS, GS
imm8,16,32位立即数
imm88位字节立即数
imm1616位字立即数
imm3232位双字立即数
reg/mem88位操作数，可以是8位普通寄存器或内存字节
reg/mem1616位操作数，可以是16位普通寄存器或内存字节
reg/mem3232位操作数，可以是32位普通寄存器或内存字节
mem8,16,32内存操作数
3). MOV 指令
  • 功能：MOV指令从源操作数赋值数据到目标操作数中。
  • 格式：
MOV destination,source

  • 操作数规则

    • 两个操作数必须是相同的大小
    • 两个操作数不能是内存操作数
    • 指令指针寄存器(IP, EIP, RIP)不能作为目标操作数
MOV reg,reg
MOV mem,reg
MOV reg,mem
MOV mem,imm
MOV reg,imm
  • 覆盖值
.data
    oneByte BYTE 78h            ; 定义一个8bit变量
    oneWord WORD 1234h          ; 定义一个16bit变量
    oneDword DWORD 12345678h    ; 定义一个32bit变量

.code
main PROC                   ; 定义主函数开始位置
    mov eax, 0              ; 为eax寄存器赋值 -- EAX = 0000 0000h
    mov al, oneByte         ; 为al赋值         -- EAX = 0000 0078h
    mov ax, oneWord         ; 为ax赋值         -- EAX = 0000 1234h
    mov eax, oneDword       ; 为eax赋值            -- EAX = 1234 5678h
    mov ax, 0               ; 为ax赋值         -- EAX = 1234 0000h
4). 整数0和符号的扩展
  • 问题
    主要原因：占用字节空间大的寄存器低字节赋值时，高字节为做更改
    解决方法：第一种用MOVZX指令代替，第二种用MOVSX代替
COMMENT &
    第一种情况是将小位数的数赋值给大位数的寄存器时，未赋值的高字节未置空
    第二种情况是将小位数的负数赋值给大位数的寄存器时，为赋值的高字节未置F
&
.data
    count WORD 10           ; 定义变量
    signedVar SWORD -16     ; 定义负数

.code
main PROC                   ; 定义主函数开始位置
    mov ecx, 100000         ; 为ecx寄存器赋值，此时ECX = 000186A0
    mov cx, count           ; 为ecx寄存器赋值，此时ECX = 0001000A
    
    mov cx, signedVar       ; 为ecx寄存器赋值，此时ECX = 0001FFF0，解决方法之一：可在此之前将ecx设置为FFFF FFFFh
  • MOVZX 指令

功能：赋值源操作数的内容到目标操作数，为16位或32位的值进行0的扩展。这个指令仅被使用在无符号整型中, 作用域：

MOVZX reg32,reg/mem8
MOVZX reg32,reg/mem16
MOVZX reg16,reg/mem8

示例：

COMMENT &
    MOVZX 解决0扩展问题
&
.data
    byte1 BYTE 9Bh          ; 定义字节变量
    word1 WORD 0A69Bh       ; 定义字变量

.code
main PROC                   ; 定义主函数开始位置
    ; 寄存器->寄存器
    mov bx, 0A69Bh          ; 为bx赋值         ebx = 7EFD A69Bh 
    movzx eax, bx           ; 将bx的值赋值给eax， eax = 76AB 342Bh -> eax = 0000 A69Bh
    movzx edx, bl           ; 将bl的值赋值给edx， edx = 00F9 1005h -> edx = 0000 009Bh
    movzx cx, bl            ; 将bl的值赋值给cx， ecx = 0000 0000h -> ecx = 0000 009Bh
3110861-cf1be8e094104e1a.png
图1.png
  • MOVSX 指令

功能：赋值源操作数的内容到目标操作数，为16位或32位的值进行符号的扩展。这个指令仅被使用在有符号整型中, 作用域：

MOVSX reg32,reg/mem8
MOVSX reg32,reg/mem16
MOVSX reg16,reg/mem8

示例：

COMMENT &
    MOVZX 解决符号扩展问题
&
.data
    byteVal BYTE 10001111b          ; 定义字节变量

.code
main PROC                   ; 定义主函数开始位置
    ; 内存 -> 寄存器
    movsx ax, byteVal       ; 将byteVal的值赋值给ax寄存器，ax = 342Bh -> ax = FF8Fh
    ; 寄存器->寄存器
    mov bx, 0A69Bh          ; 为bx赋值，bx = E000h -> bx = A69Bh
    movsx eax, bx           ; 将bx的值赋值给eax， eax = 76AB FF8Fh -> eax = FFFF A69Bh
    movsx edx, bl           ; 将bl的值赋值给edx， edx = 0035 1005h -> edx = FFFF FF9Bh
    movsx cx, bl            ; 将bl的值赋值给cx， cx = 0000h -> cx = FF9Bh
3110861-8d04effd52829f0d.png
图2.png
5). LAHF和SAHF--EFlags状态
COMMENT &
    LANF加载EFLAGS值到AH，SANF保存AH值
&
.data
    saveflags BYTE ?        ; 定义保存flag的变量
    newflags BYTE ?         ; 定义新的flag的值

.code
main PROC                   ; 定义主函数开始位置
    lahf                    ; 加载flag到ah     eax = 76AB462Bh
    mov saveflags, ah       ; 将ah的数值保存到flag中 saveflags = 70

    mov saveflags, 100      ; 赋值 saveflags = 100
    mov ah, saveflags       ; 赋值 eax = 76AB642Bh
    sahf                    ; 保存
6). XCHG指令

功能：交换两个操作数的内容。形式：

XCHG reg,reg
XCHG reg,mem
XCHG mem,reg

注：XCHG不接立即数操作数。

COMMENT &
    XCHG，交换数值
&
.data
    val1 WORD 10        ; 定义变量1
    val2 WORD 20        ; 定义变量2

.code
main PROC                   ; 定义主函数开始位置
    ; 交换val1 和 val2的数值
    mov ax, val1            ; 将val1的值存入ax中
    xchg ax, val2           ; 交换ax与val2的值
    mov val1, ax            ; 将ax的值放入val1中
7). 直接偏移操作数

功能： 为数组变量名添加一个移位。

COMMENT &
    直接偏移操作数，访问数组元素
&
.data
    arrayB BYTE 10h, 20h, 30h, 40h, 50h ; 定义字节数组元素
    arrayW WORD 100h, 200h, 300h        ; 定义字数组元素
    arrayD DWORD 10000h, 20000h         ; 定义双字数组元素

.code
main PROC                   ; 定义主函数开始位置， eax = 76AB342Bh
    mov al, [arrayB + 3]        ; 访问BYTE数组第4个元素， eax = 76AB3440h
    mov ax, [arrayW + 2 * 2]    ; 访问WORD数组第3个元素， eax = 76AB0300h
    mov eax, [arrayD + 4 * 1]   ; 访问DWORD数组第2个元素， eax = 00020000h
8). 综合示例
.486        ; 定义32位程序可以接受32位的寄存器和地址
.model flat, stdcall    ; 选择程序的内存模式为平坦模式，stdcall调用习惯
.stack 4096             ; 设置运行的堆栈大小为4096字节
ExitProcess PROTO, dwExitCode: DWORD    

COMMENT &
    直接偏移操作数，访问数组元素
&
.data
    val1 WORD 1000h
    val2 WORD 2000h
    arrayB BYTE 10h, 20h, 30h, 40h, 50h ; 定义字节数组元素
    arrayW WORD 100h, 200h, 300h        ; 定义字数组元素
    arrayD DWORD 10000h, 20000h         ; 定义双字数组元素


.code
main PROC                   ; 定义主函数开始位置
    ; MOVZX 指令示范            
    mov bx, 0A69Bh              
    movzx eax, bx               ; eax = 0000 A69Bh
    movzx edx, bl               ; edx = 0000 009Bh
    movzx cx, bl                ; cx = 009Bh

    ; MOVSZ 指令示范
    mov bx, 0A69Bh
    movsx eax, bx               ; eax = FFFF A69Bh
    movsx edx, bl               ; edx = FFFF FF9Bh
    mov bl, 7Bh
    movsx cx, bl                ; cx = 007Bh

    ; 内存 -> 内存 数值交换
    mov ax, val1                ; ax = 1000h
    xchg ax, val2               ; ax = 2000h, val2 = 1000h
    mov val1, ax                ; val1 = 2000h

    ; 直接偏移地址（BYTE数组）
    mov al, arrayB              ; al = 10h
    mov al, [arrayB + 1]        ; al = 20h
    mov al, [arrayB + 2]        ; al = 30h

    ; 直接偏移地址（WORD数组）
    mov ax, arrayW              ; ax = 100h
    mov ax, [arrayW + 2]        ; ax = 200h

    ; 直接偏移地址（DWORD数组）
    mov eax, arrayD             ; eax = 0001 0000h
    mov eax, [arrayD + 4]       ; eax = 0002 0000h


    INVOKE ExitProcess, 0   ; 退出程序
main ENDP           ; 函数结束位置, ENDP 之前的内容，要与PROC 
END main            ; 设置了函数的入口与出口
2. 加与减
1). INC与DEC指令
  • 作用域：
INC reg/mem
DEC reg/mem
  • 示例代码：
COMMENT &
    加减运算
&
.data
    myWord WORD 1000h
    
.code
main PROC                   ; 定义主函数开始位置
    inc myWord              ; myWord变量自加        myWord = 1001h
    mov bx, myWord          ; 将bx值设置为myWord  bx = 1001h
    dec bx                  ; bx值进行自减   bx = 1000h
2). ADD 指令
  • 使用方法: ADD dest,source 
COMMENT &
    加减运算
&
.data
    var1 DWORD 10000h
    var2 DWORD 20000h
    
.code
main PROC                   ; 定义主函数开始位置
    mov eax, var1           ; 将var1的值赋值给eax, eax = 10000h
    add eax, var2           ; 将var2的值与eax的值相加, eax = 30000h
3). SUB 指令
  • 使用方法：SUB dest,source 
COMMENT &
    加减运算
&
.data
    var1 DWORD 10000h
    var3 DWORD 30000h
    
.code
main PROC                   ; 定义主函数开始位置
    mov eax, var3           ; 将var3的值赋值给eax, eax = 30000h
    sub eax, var1           ; 将eax的值减去1000h, eax = 20000h
4). NEG 指令
  • 使用方法：NEG reg/mem 
COMMENT &
    加减运算
&
.data
    var1 DWORD 10000h
    var3 DWORD 30000h
    
.code
main PROC                   ; 定义主函数开始位置
    mov eax, var3           ; 将var3的值赋值给eax, eax = 30000h
    sub eax, var1           ; 将eax的值减去1000h, eax = 20000h
    neg eax                 ; eax由20000h取反+1为FFFE0000
5). 实现算术表达式
  • 示例代码：
COMMENT &
    加减运算
&
.data
    Rval DWORD ?
    Xval DWORD 26
    Yval DWORD 30
    Zval DWORD 40
    
.code
main PROC                   ; 定义主函数开始位置
    ; Rval = -Xval + (Yval - Zval)
    ; 第一步： -Xval
    mov eax, Xval
    neg eax                     ; eax = -26
    ; 第二步：（Yval - Zval)
    mov ebx, Yval       
    sub ebx, Zval               ; ebx = -10
    ; 第三步：计算Rval
    add eax, ebx
    mov Rval, eax               ; Rval = -36
6). 标志位测试
.code
main PROC                   ; 定义主函数开始位置
    ; ZF 零标志位示例
    mov cx, 1
    sub cx, 1                   ; ZF = 1
    mov ax, 0FFFFh
    inc ax                      ; ZF = 1

    ; SF 符号标志位示例
    mov cx, 0
    sub cx, 1                   ; SF = 1
    mov ax, 7FFFh
    add ax, 2                   ; SF = 1

    ; CF 进位标志位示例
    mov al, 0FFh
    add al, 1                   ; CF = 1, al = 00h

    ; OF 溢出标志位示例
    mov al, +127
    add al, 1                   ; OF = 1
    mov al, -128
    sub al, 1                   ; OF = 1
3. 数据相关的运算符和指令
1). OFFSET 操作数

功能：获取偏移地址

COMMENT &
    数据相关的运算符和指令运算
&
.data
    bVal BYTE ?
    wVal WORD ?
    dVal DWORD ?
    dVal2 DWORD ?
    myArray WORD 1, 2, 3, 4, 5
    
.code
main PROC                   ; 定义主函数开始位置
    ; OFFSET 偏移
    mov esi, OFFSET bVal    ; ESI = 00904000h
    mov esi, OFFSET wVal    ; ESI = 00904001h
    mov esi, OFFSET dVal    ; ESI = 00904003h
    mov esi, OFFSET dVal2   ; ESI = 00904007h
    mov esi, OFFSET myArray + 4 ; ESI = 0090400Fh
2). ALIGN 指令

功能：对齐字节大小，将小字节内存向大字节内存靠拢

.data
    ; ALIGN 对齐
    bVal1 BYTE ?            ; 00404000h
    ALIGN 2
    wVal1 WORD ?            ; 00404002h
    bVal2 BYTE ?            ; 00404004h
3). PTR 操作数

功能：将大字节的变量转换为小字节的变量，将小字节的数组拼接为打字节的变量

.data
    myDouble DWORD 12345678h
    wordList WORD 5678h, 1234h

.code
main PROC                   ; 定义主函数开始位置
    ; PTR 指针
    mov ax, WORD PTR myDouble   ; ax = 5678h
    mov ax, WORD PTR [myDouble + 2] ; ax = 1234h
    mov eax, DWORD PTR wordList ; eax = 12345678h
4). TYPE 操作数

功能：返回变量的所占用的字节大小

.data
    bVal BYTE ?
    wVal WORD ?
    dVal DWORD ?

.code
main PROC                   ; 定义主函数开始位置
    ; TYPE 获取变量所占内存大小
    mov eax, TYPE bVal      ; eax = 0000 0001h
    mov eax, TYPE wVal      ; eax = 0000 0002h
    mov eax, TYPE dVal      ; eax = 0000 0004h
5). LENGTHOF 操作数

功能：获取数组长度

.data
    byte1 BYTE 10, 20, 30
    array1 WORD 30 DUP(?), 0, 0
    array2 WORD 5 DUP(3 DUP(?))
    array3 DWORD 1, 2, 3, 4
    digitStr BYTE "12345678", 0

.code
main PROC                   ; 定义主函数开始位置
    ; LENGTHOF 计算数组长度
    mov eax, LENGTHOF byte1 ; eax = 0000 0003h
    mov eax, LENGTHOF array1 ; eax = 0000 0020h
    mov eax, LENGTHOF array2 ; eax = 0000 000Fh
    mov eax, LENGTHOF array3 ; eax = 0000 0004h
    mov eax, LENGTHOF digitStr ; eax = 0000 0009h
6). SIZEOF 操作数

功能：计算变量所占用的位数

.data
    intArray WORD 32 DUP(0)

.code
main PROC                   ; 定义主函数开始位置
    ; SIZEOF 计算所占用的字节位数
    mov eax, SIZEOF intArray    ; eax = 0000 0040h
7). LABEL 指令

**功能：设置别名，使用内存地址访问之后定义的变量 **

.data
    val16 LABEL WORD
    val32 DWORD 12345678h
    LongValue LABEL DWORD
    val1 WORD 5678h
    val2 WORD 1234h
.code
main PROC                   ; 定义主函数开始位置
    ; LABEL 地址访问
    mov ax, val16           ; ax = 1234h
    mov dx, [val16 + 2]     ; dx = 5678h
    mov eax, LongValue      ; eax = 1234 5678h
4. 间接寻址
1). 间接操作数

功能：使用地址访问对应的地址的数值

  • 保护模式
.data
    byteVal BYTE 10h

.code
main PROC                   ; 定义主函数开始位置
    ; 间接操作
    mov esi, OFFSET byteVal
    mov al, [esi]
  • 使用PTR间接操作
inc BYTE PTR [esi]
2). 数组
.data
    arrayW WORD 1000h, 2000h, 3000h

.code
main PROC                   ; 定义主函数开始位置
    ; 数组
    mov esi, OFFSET arrayW
    mov ax, [esi]           ; ax = 1000h
    add esi, 2
    mov ax, [esi]           ; ax = 2000h
    add esi, 2
    mov ax, [esi]           ; ax = 3000h
3). 索引操作数
  • 表现形式
constant[reg]
[constant + reg]

示例：

.data
    arrayB BYTE 10h, 20h, 30h

.code
main PROC                   ; 定义主函数开始位置
    ; 索引操作数
    mov esi, 0
    mov al, arrayB[esi]     ; al = 10h
  • 添加位移
.data
    arrayW WORD 1000h, 2000h, 3000h

.code
main PROC                   ; 定义主函数开始位置
    ; 添加位移
    mov esi, OFFSET arrayW
    mov ax, [esi]           ; ax = 1000h
    mov ax, [esi + 2]       ; ax = 2000h
    mov ax, [esi + 4]       ; ax = 3000h
  • 使用16位寄存器
mov al,arrayB[si]
mov ax,arrayW[di]
mov eax,arrayD[bx]
  • 索引操作数中的比例因子
.data
    arrayD DWORD 100h, 200h, 300h, 400h

.code
main PROC                   ; 定义主函数开始位置
    ; 索引操作数中的比例因子
    mov esi, 3 * TYPE arrayD
    mov eax, arrayD[esi]        ; eax = 0000 0400h
4). 指针

概念：一个变量存储另一个变量的地址

.data
arrayB BYTE 10h,20h,30h,40h
ptrB DWORD arrayB
  • TYPEDEF 操作数

功能：用户可自定义类型名

PBYTE TYPEDEF PTR BYTE
5. JMP 和 LOOP 指令
1). JMP 指令

  • 功能

    一种非传统的传递，类似于C语言中的goto语句

  • 语法

JMP destination
  • 创建循环
top:
.
.
jmp top
2). LOOP 指令
  • 功能

一种非传统的传递，类似于C语言中的循环语句

  • 语法
LOOP destination
  • 循环
 mov ax,0
 mov ecx,5
L1:
 inc ax
 loop L1

每次循环为ax自加1，ecx进行自减，循环结束时，ax=5，ecx=0

  • 循环内部修改ECX的值
.data
count DWORD ?
.code
    mov ecx,100     ; 设置循环计数
top:
    mov count,ecx   ; 保存循环计数
    .
    mov ecx,20      ; 修改ECX
    .
    mov ecx,count   ; 恢复循环计数
    loop top
  • 嵌套循环
.data
    count DWORD ?
.code
    mov ecx,100     ; 设置外层循环计数
L1:
    mov count,ecx   ; 保存外层循环计数
    mov ecx,20      ; 设置内层循环计数
L2:
    .   
    .
    loop L2         ; 重复内层循环
    mov ecx,count   ; 恢复外层循环计数
    loop L1         ; 重复外层循环
3). 数组和
.486        ; 定义32位程序可以接受32位的寄存器和地址
.model flat, stdcall    ; 选择程序的内存模式为平坦模式，stdcall调用习惯
.stack 4096             ; 设置运行的堆栈大小为4096字节
ExitProcess PROTO, dwExitCode: DWORD    


COMMENT &
    数组求和
&
.data
    intArray DWORD 10000h, 20000h, 30000h, 40000h

.code
main PROC                   ; 定义主函数开始位置
    mov edi, OFFSET intArray    ; 获取数组偏移地址
    mov ecx, LENGTHOF intArray  ; 设置循环计数
    mov eax, 0                  ; 存储数组元素之和
L1:
    add eax, [edi]              ; 将数组元素值加入eax
    add edi, TYPE intArray      ; 获取下一个数组元素地址
    LOOP L1                     ; 循环

    INVOKE ExitProcess, 0   ; 退出程序2
main ENDP           ; 函数结束位置, ENDP 之前的内容，要与PROC 
END main            ; 设置了函数的入口与出口
4). 字符串复制
 .486       ; 定义32位程序可以接受32位的寄存器和地址
.model flat, stdcall    ; 选择程序的内存模式为平坦模式，stdcall调用习惯
.stack 4096             ; 设置运行的堆栈大小为4096字节
ExitProcess PROTO, dwExitCode: DWORD    


COMMENT &
    数组求和
&
.data
    source BYTE "This is the source string", 0
    target BYTE SIZEOF source DUP(0)

.code
main PROC                   ; 定义主函数开始位置
    mov esi, 0              ; 索引寄存器
    mov ecx, SIZEOF source  ; 循环计数
L1:
    mov al, source[esi]     ; 从源字符串获取一个字符， mov指令不能够有两个内存操作数
    mov target[esi], al     ; 存储到目标字符串对应位置
    inc esi                 ; 移动到下一个字符串
    LOOP L1                 ; 循环

    INVOKE ExitProcess, 0   ; 退出程序
main ENDP           ; 函数结束位置, ENDP 之前的内容，要与PROC 
END main            ; 设置了函数的入口与出口
5). 数组求和——64位
; 数组求和

ExitProcess PROTO

.data
intArray QWORD 1000000000000h, 2000000000000h, 3000000000000h, 4000000000000h

.code
main PROC
    mov rdi, OFFSET intArray        ; 设置偏移地址
    mov rcx, LENGTHOF intArray      ; 初始化循环计数
    mov rax, 0                      ; 数组之和
L1:
    add rax, [rdi]                  ; 加入当前位置的数组值
    add rdi, TYPE intArray          ; 移动得到下一个数组元素
    LOOP L1                         ; 重复执行，直到rcx=0
    mov ecx, 0                      ; 退出程序并返回

    call ExitProcess                ; 退出程序
main ENDP
END
mazaiting
关注
汇编分析参数传递中的地址传递与值传递的区别(指针，引用，值传递）
bobopeng
08-06 3027
1.指针 .text:00401020 mySwap proc near ; CODE XREF: j_mySwapj .text:00401020 .text:00401020 var_44 = byte ptr -44h .text:00401020 var_4 = dword ptr -4 .text:0
学习汇编语言 LLVM编译器 数据结构 算法 操作系统 单片机 linux 面试.zip
最新发布
01-15
网络与通信：数据传输、信号处理、网络协议、网络与通信硬件、网络安全网络与通信是一个非常广泛的领域，它涉及到计算机科学、电子工程、数学等多个学科的知识。 云计算与大数据：包括云计算平台、大数据分析、人工...
汇编程序，复制自身到指定地址
05-27
用80x86汇编语言编写，实现程序将自身复制到指定地址
【汇编语言】通用数据处理指令——数据传送类指令
PKM of bk
06-28 1594
通用数据处理指令——数据传送类指令 一、MOV指令 1.数据长度 2.传送方式 3.常见错误 二、XCHG指令 1.数据长度 2.空操作指令NOP（no-operation） 三、LEA指令 1.LEA与OFFSET的作用 2.地址传送程序 3.用LEA指令实现运算功能
第4章 数据传递.寻址和算术运算
weixin_30588827的博客
03-21 148
Mov操作规则: 　　1.两个操作数的尺寸必须一致 　　2.两个操作数不能同时为内存操作数 　　3.目的操作数不能是CS,EIP和IP 　　4.立即数不能自己送至寄存器 MovZx(零扩展传送)指令:无符号整数使用 　　eg: 　　mov bl,11111111b 　　mov eax,bl 　　MOVSX(符号扩展传送)前面补0 LAHF:将EFLAGS的低字节复制到...
汇编地址的值与它在内存地址中的高低位排列是反过来的
hutao1101175783的专栏
07-27 431
如0000ffff 在内存中高低位反过来，是ffff0000特别注意一点，他是以1字节（8）位为单位反过来。例如：例如一个值为0x12345678,那么它在内存中的布局是0x78563412，切记！！！！！...
利用汇编语言实现BCH解码校验算法
07-19
BCH编码是一种重要的纠错编码技术，被广泛应用于数据传输过程中，以提高数据传输的可靠性。BCH编码通过添加冗余信息，能够在接收端检测并纠正一定数量的错误，这在无线通信等容易受干扰的环境中尤为重要。BCH码具有...
asm.rar_ASM算法_单片机_单片机 汇编_单片机汇编
09-24
- 输入/输出：控制GPIO端口进行数据传输。 4. 单片机汇编的挑战 虽然ASM语言提供了直接访问硬件的能力，但也带来了编写复杂和易出错的代码的风险。开发者需要对单片机硬件有深入理解，才能编写出高效且可靠的程序...
adler32算法汇编.rar
04-03
Adler-32算法是一种广泛应用于数据校验的算法，主要用在文件完整性检查和数据传输的准确性验证中。这个算法是由Mark Adler开发的，并且被包含在了 zlib 库中，是CRC（Cyclic Redundancy Check）的替代品，尽管它的...
易语言adler32算法汇编源码，源码利用易语言的置入代码实现
04-30
Adler32算法是一种常用的校验和算法，广泛应用于数据完整性检查，例如在文件传输或压缩中防止数据错误。本压缩包包含的“adler32.e”文件是易语言实现的Adler32算法的汇编源码，对于学习易语言编程以及理解Adler32...
hjr-汇编：指令操作地址和数据
hjr的博客
05-15 946
声明，下面都是瞎猜的，一定是片面的，可能有错误的 汇编语言是由很多指令组成的 指令用来操作地址与数据 指令由操作码和操作数组成，操作码就是你要进行的操作，操作数就是你要操做的数据或者地址 指令操作数据的方式是寻址 寻址就是，读或者取寻到的地址里的数据 操作码可以是加减乘除，传送等 数据就是我们常说的数字 关于地址与数据可以看这篇博文 hjr教程-汇编（一）：地址与数据 下面简...
汇编语言（六）——操作数
图像学习之旅
02-07 1万+
0.前言 x86 的指令格式为： [label:] mnemonic [operands][ ;comment ] 指令包含的操作数个数可以是：0 个，1 个，2 个或 3 个。这里，为了清晰起见，省略掉标号和注释： mnemonic mnemonic [destination] mnemonic [destination] , [source] mnemonic [destination] , [source-1] , [source-2] 操作数有 3 种基本类型： ...
汇编语言学习笔记
chenxiuli0810的专栏
03-05 4258
恋恋风辰 https://www.cnblogs.com/secondtonone1/p/6617884.html 汇编语言学习笔记(一) 一：变量类型 汇编语言变量基本类型如下： sdword ：表示32位整数 dword：表示32位无符号整数 sword：表示16位整数 word：表示16位无符号整数 sbyte：表示8位整数 byte：用于表示字节，大小为8位 变...
【汇编语言学习01】寻址方式
天 下
02-05 2397
寻址方式：说明操作数所在地址的方法。 指令 = 操作码 + 操作数 汇编语言 = 助记符 + 符号或符号地址 数据存储采用 "高高低低" 的规则 1、立即数寻址: mov ax,123H       ; 源操作数为一个立即数 2、寄存器寻址: mov ax,bx            ; 两个操作数都为寄存器 3、直接寻址: mov ax,
常用汇编指令
fan_mvp的专栏
02-21 1610
<br />NOT ;非<br />AND ;与<br />OR ;或<br />;时钟用于将CPU的内部操作和其他系统部件同步<br />;控制单元(CU)协调执行机器指令时隔各个步骤地次序<br />;算数逻辑单元(ALU) 执行加减的算数运算以及NOT,OR,AND之类的逻辑运算<br />;内存储器 用于存储指令和数据，处理完毕后存入存储器<br />;数据总线　用于CPU和内存之间传送数据<br />;控制总线 用于控制所有的设备的动作进行同步<br />;地址总线 用于存放指令和数据的地址<
EAX、ECX、EDX、EBX寄存器的作用
热门推荐
tiger_ibm的专栏
04-02 1万+
一般寄存器:AX、BX、CX、DX AX:累积暂存器，BX:基底暂存器，CX:计数暂存器，DX:资料暂存器 索引暂存器:SI、DI SI:来源索引暂存器，DI:目的索引暂存器 堆叠、基底暂存器:SP、BP SP:堆叠指标暂存器，BP:基底指标暂存器 EAX、ECX、EDX、EBX：為ax,bx,cx,dx的延伸，各為32位元 ESI、EDI、ESP、EBP：為si,di,
汇编语言----串操作指令
qq_44418229的博客
04-30 5181
串操作指令，指令包括：MOVS，LODS，STOS，CMPS，SCAS，REP
汇编中参数传递的两种方法
hairi1234的博客
01-02 7772
汇编中参数的传递过程两种方法： 直接传给寄存器：lea（直接加载地址，一般对数组） 使用寄存器完成内存间传输： MOV AX,DATA MOV DS,AX
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值