二进制及汇编先导内容

作者: yjtuuige | 来源:发表于2022-01-25 22:04 被阅读0次

一、语言

1. 机器语言

目前主流的电子计算机，只认识 0 和 1，计算机是基于基本 二进制 的方式进行计算。

机器语言，指的是 二进制指令，是 输入给计算机 使用的。

# 目前主流的电子计算机 
状态：0 和 1 
# 最早的程序员：穿孔卡带 
加 0100 0000 
减 0100 1000 
乘 0100 1000 0100 1000 
除 0100 1000 1100 1000

2. 汇编语言

用 助记符 的方式，来 代替二进制 指令。
加减乘除：INC、DEC、MUL、DIV

编译器：把人能够理解的 汇编助记符，转换成机器能够理解的 二进制指令。

加 INC -编译器-> 0100 0000 
减 DEC 0100 1000 
乘 MUL 0100 1000 0100 1000 
除 DIV 0100 1000 1100 1000

3. C 语言

加 A+B -编译器-> 0100 0000 
减 A-B 0100 1000 
乘 A*B 0100 1000 0100 1000 
除 A/B 0100 1000 1100 1000 1234

二、进制

1. 进制：

1 进制：一进一，结绳记事。1 1
2 进制：二进一，计算机
8 进制：八进一。8 个符号组成：0 1 2 3 4 5 6 7
10 进制：十进一。10 个符号组成：0 1 2 3 4 5 6 7 8 9
16 进制：16 进一。16 个符号组成：0 1 2 3 4 5 6 7 8 9 a b c d e f
进制，远远没有大家想的那么复杂。查数

测试

# 一进制 1~20 
1
1 1 
1 1 1 
1 1 1 1 ..... 

# 三进制 1~20 
十进制: 0 1 2 3 4 5 6 7 8 9 10 
三进制: 0 1 2 10 11 12 20 21 22 100 101 102 100 101 102 110 111 112 120 121 122 

# 二进制
0 1 10 11 100 101 110 111 1000 

# 七进制 1~20 
0 1 2 3 4 5 6 10 11 12 13 14 15 16 20 21 22 23 24 25 26 

# 一组符合：逢几进几

问题：1 + 1 = 3 对吗？可以使用进制角度来解答这个问题。
- 十进制：0 1 2 3 4 5 6 7 8 9
- 自定义的十进制：0 2 4 7 8 a b r d f ，可以自己随便定义。
- 加密解密：进制的加密

2. 进制怎么运算

运算的本质就是查数

# 八进制计算下面的结果 
2+3=5 
2*3=6 
4+5=11 
4*5=24 

# 运算的本质就是查数 
0 1 2 3 4 5 6 7 10 11 12 13 14 15 16 17 20 21 22 23 24 25 26 27 

# 八进制计算下面的结果 参照下图乘法表，加法表
277+333 = 
276*54 = 
237-54 = 
234/4 =

八进制的乘法表

八进制的加法表：

# 八进制计算
# 运算的本质就是查数 
277 
333 + 
-------- 
632 

276
54 * 
-------- 
1370 

1666 + 
-------- 
20250 

# 减法的本质其实就是加法！ 237-54 = 237 + (-54) 
-------- 
# 除法的本质，除数乘以那个数最接近结果即可！ 
234
4 
---- 
47

结论：无论是什么进制，本身都是有一套完美的运算体系的，我们都可以通过列表的方式，将它计算出来！

3. 二进制

计算机使用二进制 0、1（电子状态），物理极限：摩尔定律，硬操作；追求语言的极限，并发语言，软操作。

量子计算机：可以实现量子计算的机器。

传统的计算机：集成电路 0、1 ，硅晶片。
量子计算机的单位：昆比特（量子比特），量子的两态来表示。
光子：正交偏振方向。
磁场：电子的自旋方向。

扩展

21世纪，计算力快到尽头了，量子计算机，提高计算机的计算力。
量子比特、量子叠加态、量子纠缠、量子并行原理…
2019 年，Google 研究人员展示其最新 54 比特量子计算机，该计算机只用 200 秒，便可计算完毕当前世界最大的超级计算机，需 1 万年进行的运算。
2020 .6.18，量子体积 64 的量子计算机，霍尼韦尔还表示，将在一年之内，得到至少 10 个有效量子比特，相当于 1024 个量子体积。量产！
电子计算机 -> 量子计算机

电子计算机，二进制计算（0、1）

二进制：0 写到 1111

0 1 10 11 100 101 110 111 1000 1001 1010 1011 1100  1101 1110 1111

二进制这么写很麻烦！二进制能否简写？可以简写：16 进制
```
0 1 2 3 4 5 6 7 8 9 a b c d e f
```
错误方式：2 进制转换为 10 进制，然后再计算！
为什么要学习理解二进制？
- 寄存器、内存、位，底层的每一个位，都是有含义的；
- 汇编入门理解的基础；
- 汇编高级：了解程序的深层，操作系统的内核。

三、数据宽度

计算机是有内存限制的，不可能无穷大，所以，被迫给数据定义宽度。

C、C++、Java 都需要定于数据的类型，因为计算机底层，需要给这些数据定义宽度。
```
位：0 1
字节：0~0xFF
字：0~0xFFFF
双字：0~0xFFFFFFF
```
在计算机中，每一个数据都需要给它定义类型，即定义宽度（在内存中的宽度）。

四、有符号数无符号数

数据都是有宽度的，每个数据代表什么意思呢？二进制
```
0 1 0 1 0 1 0 1
```

1. 规则：二进制解码增加一个规则

无符号数规则：数字是什么，就是什么。
```
1 0 0 1 1 0 1 0 十六进制：0x9A 十进制 154
```
有符号数规则：最高位是符号位：1 (负数) 0（正数）
```
1 0 0 1 1 0 1 0 如何转换？
```

2. 原码反码补码（之后要用它来计算）

编码规则

有符号数的编码规则
- 原码：最高位符号位，其它的位，取本身绝对值即可。
- 反码：
  - 正数：反码和原码相同；
  - 负数：符号位一定是 1，其余位，对原码取反。
- 补码：
  - 正数：补码和原码相同；
  - 负数：符号位一定是 1，反码 +1
测试

# 按 8 位计算
# 正数：都是一样的。 
1
#原码 0 0 0 0 0 0 0 1 
#反码 0 0 0 0 0 0 0 1 
#补码 0 0 0 0 0 0 0 1 

# 按 8 位计算 
# 负数 
-1
#原码 1 0 0 0 0 0 0 1 
#反码 1 1 1 1 1 1 1 0 
#补码 1 1 1 1 1 1 1 1 
-7
#原码 1 0 0 0 0 1 1 1 
#反码 1 1 1 1 1 0 0 0 
#补码 1 1 1 1 1 0 0 1

3+5=8
0 1  2  3  4  5
0 1 10 11 100 101

二进制的标志位
2 10
4 100
8 1000

结论：

正数的原码、反码、补码相同；
负数的反码，符号位为 1，其余位，对原码取反；
负数的补码，是负数的反码 +1；
如果看到一个二进制数，一定要了解它是一个有符号数，还是无符号数。

3. 寄存器：

八个寄存器地址：EAX、ECX、EDX、EBX、ESP、EBP、ESI、EDI；
寄存器（寄存器中存值的指令）：mov 寄存器名称，值；
正数存入寄存器，则存入寄存器的，是该正数的二进制的原码；
负数存入寄存器，则存入寄存器的，是该负数的二进制的补码。

五、位运算

计算机现在可以存储所有的数字(整数，浮点数，字符)，通过位进行运算。

位运算

例如：2*8 最高效计算方式（2<<3）；
很多底层的调试器。需要通过位来判断 CPU 的状态。

1. 与运算 (and &)

两个都为 1，结果为 1，否则为 0。

1011 0001 
1101 1000 
----------- 与运算
1001 0000

2. 或运算（or |）

只要有一个 1，结果为 1，两个都不是 1 时，为 0。

1011 0001
1101 1000
----------- 或运算
1111 1001

3. 异或运算（xor ^）

不相同，则为 1。

1011 0001 
1101 1000 
----------- 异或运算
0110 1001

4. 非运算（单目运算符 not ~）

0 的非运算是 1，1 的非运算是 0，即取反。

1101 1000 
---------- 非运算
0010 0111

通过位运算，实现加、减、乘、除

5. 位运算（移动位）

十进制：左移一位（*2），右移一位（/2）
```
0000 0001 1
0000 0010 2
0000 0100 4
0000 1000 8
```

左移：(shl <<)

0000 0001 # 所有二进制位全部左移若干位，高位丢弃，低位补 0
0000 0010

右移：(shr >>)

0000 0001 # 所有二进制位全部右移若干位，低位丢弃，高位补 0 或 1（符号位决定）
0000 0000

int a = 10; 
printf("%d\n",a>>2);

二进制、位运算=> 加、减、乘、除

6. 位运算的加减乘除

计算机只认识 0、1；
基本数学是建立在加、减、乘、除（都可以转换为加法）
测试 1：用二进制计算 4+5

0000 0100
0000 0101
---------（加法：计算机是不会相加的）
0000 1001
# 计算机的实现过程
# 第1步：异或：如果不考虑进位，异或就可以直接出结果。
0000 0100
0000 0101
------------
0000 0001
# 第2步：与运算（判断进位，如果与运算结果为0，没有进位）
0000 0100
0000 0101
-------------
0000 0100
# 第3步：将与运算的结果，左移一位，0000 1000 得到进位的结果

# 第4步：异或（将第一步异或得到的结果和进位的结果进行异或，得到4+5的结果）
0000 0001
0000 1000
-----------
0000 1001
# 第5步：（计算机确认结果，判断是否还有进位）与运算（判断进位，将第一步异或得到的结果和进位的结果进行与运算）
0000 0001
0000 1000
----------
0000 0000 （与运算结果为0，没有进位）
# 所以最终的结果，就是与运算为0的结果的上一个异或运算

测试 2：用二进制计算 4-5

# 计算机是怎么操作的！ 
4+(-5) 

0000 0100 
1111 1011 
---------- （4+(-5)：计算机是不会直接减的） 
1111 1111
# 计算机的实现过程
0000 0100 
1111 1011
----------- 1.异或(如果不考虑进位，异或就可以直接出结果。) 
1111 1111 

0000 0100 
1111 1011 
----------- 2.与（判断进位，如果与运算结果为0，没有进位。） 
0000 0000 

最终结果 1111 1111 16进制：ff  10进制：-1

乘法：x*y，就是 y 个 x 相加，还是加法；
除法：x/y，本质就是减法，就是 x 能减去多少个 y。

计算机只会做加法！

机器语言就是位运算，都是电路来实现的，这就是计算机的最底层的本质；
通过机器语言，来实现加法计算器，设计电路。

六、汇编语言环境说明

通过指令，来代替二进制编码。

通过汇编指令，可以给计算机发一些操作，让计算机执行；
编译器的发展，底层的大佬，几乎都是最原始的 IDE；
在学习汇编之前，需要先掌握环境的配置（1、Vc6（程序到汇编的理解），2、OD！3、抓包工具、4、加密解密工具）
学汇编不是为了写代码，是理解程序的本质。

《汇编语言》 16 位的汇编，32 位 64位（本质架构区别不大，寻址能力增加。）
建议直接学习 32 位汇编！
汇编入门：了解汇编和程序的对应关系，程序的本质即可。

汇编：寄存器，内存，汇编指令。

1. 通用寄存器

寄存器：
存储数据：CPU > 内存 > 硬盘
32 位：CPU 8 位、16 位、32 位
64 位：CPU 8 位、16 位、32 位、64 位

通用寄存器：可以存储任意的东西

# 32 位的通用寄存器只有 8 个（存值的范围：0~FFFF FFFF）
EAX
ECX
EDX
EBX
ESP
EBP
ESI
EDI

存值的范围 0 ~ FFFFFFFF
对于二进制来说，直接修改值

计算机向寄存器存值。

# mov 指令
mov 存的地址,存的数 
mov 存的地址1,存的地址2 （把地址2的值，写入到地址1）
# 可以将数字写入到寄存器，也可以将寄存器中的值，写到另一个寄存器。

可以将数字写入到寄存器，也可以将寄存器中的值，写到另一个寄存器。
计算机本质：计算力！

不同的寄存器

#8个F FFFF  FF 
32位  16位  8位
EAX   AX    AL
ECX   CX    CL
EDX   DX    DL
EBX   BX    BL
ESP   SP    AH
ENP   NP    CH
ESI   SI    DH
EDI   DI    BH

8 位：L（低 8 位），H（高 8 位）

除了通用寄存器，其他的寄存器，每一位都有自己特定的功能。

2. 内存

寄存器很小，不够用，数据需要放到内存（内存条）；
每个应用程序进程，都有 4 GB 的内存空间（虚拟内存）。

程序真正运行的时候，才会用到物理内存。
```
1B  = 8bit
1KB = 1024B
1MB = 1024KB
1GB = 1024MB
```
4 G 的内存，4096 MB => 需要换算成位，就是可以存储的最大容量。
计算机中内存地址很多，空间很大。

3. 内存地址

存一个数：占用的大小，数据宽度！存到哪里？
计算机中内存地址很多，空间很大，每个空间分配一个地址，名字。

给内存起的编号，就是内存地址。 32 位： 8 个 16进制的值（FFFFFFFF）。
32 位：寻址能力（4 GB），FFFFFFFF+1 = 100000000，最大的值；
位是怎么限制内存大小的：
- 100000000 内存地址 * 8 = 位：800000000；
- 转换为 10 进制/8：4,294,967,296，字节按照规则/1024, 最终发现就是 4 GB。
64 位，寻址能力绰绰有余！
所以每个内存地址都有一个编号，通过这些编号向里面存值。

内存如何存值？

数据宽度：byte word dword
地址的位置：0xFFFFFFFF

不是任意的地址都可以写东西的，需申请使用，只有程序申请过的内存地址，才可以使用。

# 汇编如何向内存中写值 
mov 数据宽度 内存地址，1 
mov byte ptr ds:[0x19FF70],1 
# 传递的值的大小一定要和数据宽度相等。

内存地址的多种写法

汇编向内存中写值

ds:[0x19FF70+4] # 内存地址偏移
ds:[eax] # 寄存器
ds:[eax+4] # 寄存器偏移
# 数组 []
ds:[reg+reg*{1,2,4,8}] # 数组
ds:[reg+reg*{1,2,4,8}+4] # 数组偏移