8086 CPU 寄存器简介

引子

打算写几篇稍近底层或者说是基础的博文，浅要介绍或者说是回顾一些基础知识，

自然，还是得从最基础的开始，那就从汇编语言开刀吧，

从汇编语言开刀的话，我们必须还先要了解一些其他东西，

像CPU ，内存这些知识点还是理解深刻一点的比较好，

所以这一篇博文就绕着80x86 CPU 中寄存器的基础部分下手，至于其他的一些将会在后续的博文中介绍。

同时在这里说明一下，本篇博文介绍的算是比较详细的了，而且介绍的知识点也是比较多的，所以造成博文长度过长，

如果有兴趣想了解这一块的话，还请自行斟酌好阅读比例，建议分3 次以上阅览。

读者定位

本博文主要将介绍的是8086 CPU 中的寄存器，既然是8086 CPU 寄存器简介的话，

自然，面向的是初级一些的读者，其中不会涉及太多难点，同时，所有的介绍，我也会尽可能的从基础开始，

然后循序渐进的介绍，同时也会尽量的将知识点介绍详细，

介绍的过程中也会涉及到一些汇编程序代码，当然，采用的是最简单的方式介绍而已，

本篇博文也就是回顾一些基础知识，读者主要定位于想对8086 CPU 有所了解，

希望对整个程序设计的底层有所了解的朋友，而且读者最好是拥有一定的计算机基础和汇编语言基础。

开头

首先浅要介绍一下Intel CPU 的发展史吧：

Intel CPU 系列，最初是4 位微处理器4004，然后到到8 位微处理器的8008 ，

再到8 微微处理器8080,以及稍后的16 位微处理器8086，

由8086 开始，Intel 进入现在所谓的x86 时代。

Intel 8086 为16 位CPU ，而因为在8086 之前的CPU 都是8 位CPU，这样也就造成了很多的外设也只支持8 位，

因此Intel 紧接着就退出了8 位的8088 CPU，因此Intel 8088 也就可以看做是8086 的8 位版本；如果是但从汇编语言的角度上来说，8086 和8088 是没有区别的，即8086 上跑的程序可以不加修改的移植到8088 ，

8088 上跑的程序也可以不加修改的移植到8086 上，

当然，还是有些特殊的地方是不同的，而这些基本上在这里可以忽略掉，

在8088 CPU 之后，Intel 又推出了80186 ，80286 ，这两款CPU 均是16 位CPU ，

而对于80186 来说，其与8086 的区别可以简单的看做是80186 多了几条指令而已，

而80286 则不同，80286 的地址总线数目有了变化，

在8086 , 8088 , 80186 上，CPU 的地址总线都是20 根，即可最大寻址220即达到1MB 的寻址能力，而对于80286 CPU 来说，其地址总线数目达到了24 根，从而最大寻址能力为224即16MB，

由于支持更多的物理内存寻址，因此80286 便开始成为了多任务，多用户系统的核心。

而后来，Intel 又推出了80386 ，80386 为32 位微处理器，Intel 80x86 家族的32 位微处理器始于80386；

同时80386 也完全兼容先前的8086/8088，80186，80286，并且80386 全面支持32 位数据类型和32 位操作，

并且80386 的数据总线根数和地址总线根数均达到了32 根，从而可以最大物理寻址为232 即4GB 。而之后的80486 也是32 位微处理器，而后又出来了Pentium 和Pentium Pro 等等第五代微处理器，这些处理器虽然也是32 位微处理器，但是他们的数据总线和地址总线都有所扩展，

比如Pentium 的数据总线达到64 位，而Pentium Pro 的地址总线位数达到了36 位。

好，关于Intel CPU 的介绍就到这里了，下面就要开始回归中心，看CPU 中的寄存器了，

首先，从学习的角度来说，从8086/8088 CPU 下手是不错的选择，而我这里选择的也是8086 CPU 而已，

说实在的，像80386 CPU 我也还没有研究过，像奔腾这些，呵呵，扯更远了，

说到底也就只能拿8086 出来晒晒而已，当然，从8086 开始也是学习的最佳路径。

说了这么久，到底寄存器是什么呢？其实很简单，寄存器就是个存储信息的单元或者说是器件又或者说是容器而已，

就比如内存也是一个存储介质或者说是存储单元而已，其实寄存器从理解上来说和内存差不多，

只不过寄存器（这里讨论的寄存器都是CPU 中的寄存器，不包括外设上的寄存器）位于CPU 内部，而内存位于CPU 外部，

而且，寄存器比内存可是珍贵得多啊，就拿内存和硬盘来比，肯定是内存在使用上珍贵得多，是PC 中的稀有资源，

而寄存器是CPU 中的稀有资源，内存和寄存器相比就像硬盘和内存相比一样。

而对于一个汇编程序员来说，CPU 中主要可以使用的也就是寄存器而已，汇编程序员可以使用指令来读写CPU 中的寄存器，

从而可以实现对于CPU 的控制，当然，不同的CPU ，寄存器的个数和结构都是不一样的，

比如8086 CPU 中，寄存器的个数也就14 个而已，

并且8086 CPU 中所有的寄存器的结构为16 位，即一个寄存器中可以存放下2B 即 2 个字节，

而到了80386 CPU 中，寄存器的个数也比8086 增多了，比如在80386 中添加了系统地址寄存器等寄存器，

同时寄存器的结构也变了，比如在80386 中绝大多数的寄存器为32 位，而有些寄存器则是16 位。8086 CPU 中寄存器总共为14 个，且均为16 位。

即AX，BX，CX，DX，SP，BP，SI，DI，IP，FLAG，CS，DS，SS，ES共14 个。

而这14 个寄存器按照一定方式又分为了通用寄存器，控制寄存器和段寄存器。

通用寄存器：

AX，BX，CX，DX 称作为数据寄存器：

AX (Accumulator)：累加寄存器，也称之为累加器；

BX (Base)：基地址寄存器；

CX (Count)：计数器寄存器；

DX (Data)：数据寄存器；

SP 和BP 又称作为指针寄存器：

SP (Stack Pointer)：堆栈指针寄存器；

BP (Base Pointer)：基指针寄存器；

SI 和DI 又称作为变址寄存器：

SI (Source Index)：源变址寄存器；

DI (Destination Index)：目的变址寄存器；

控制寄存器：

IP (Instruction Pointer)：指令指针寄存器；

FLAG：标志寄存器；

段寄存器：

CS (Code Segment)：代码段寄存器；

DS (Data Segment)：数据段寄存器；

SS (Stack Segment)：堆栈段寄存器；

ES (Extra Segment)：附加段寄存器；

通用寄存器

从上面可以知道，在8086 CPU 中，通用寄存器有8 个，分别是AX，BX，CX，DX，SP，BP，SI，DI ，至于为什么给它们取名做通用寄存器，那是因为，这些个寄存器每一个都有自己专门的用途，

比如CX 作为计数寄存器，则是在使用LOOP 指令循环时用来指定循环次数的寄存器，

如果它们每一个都只有一个专用的作用，那就它们只能称之为专用寄存器了，

正是因为这些个寄存器还可以用来传送数据和暂存数据，所以才称它们为通用寄存器。

下面就按顺序来一一介绍这几个通用寄存器了：

数据寄存器（AX，BX，CX，DX）：

数据寄存器有AX，BX，CX，DX 四个组成，

由于在8086 之前的CPU 为8 位CPU，所以为了兼容以前的8 位程序，

在8086 CPU 中，每一个数据寄存器都可以当做两个单独的寄存器来使用，

由此，每一个16 位寄存器就可以当做2 个独立的8 位寄存器来使用了。

AX 寄存器可以分为两个独立的8 位的AH 和AL 寄存器；

BX 寄存器可以分为两个独立的8 位的BH 和BL 寄存器；

CX 寄存器可以分为两个独立的8 位的CH 和CL 寄存器；

DX 寄存器可以分为两个独立的8 位的DH 和DL 寄存器；

除了上面 4 个数据寄存器以外，其他寄存器均不可以分为两个独立的8 位寄存器；

注意在上面标志中的“独立”二字，这两个字表明AH 和AL 作为8 位寄存器使用时，

可以看做它们是互不相关的，也就是看做两个完全没有联系的寄存器X 和Y 即可，

比如指令MOV AH , 12H ，CPU 在执行时根本就不会知道AL 中是什么鬼东西，因为它只认识AH 。下面给出一幅16 位数据寄存器的结构图：

表示16 位寄存器AX 可以表示成两个8 位寄存器，

其中AH 表示高位的8 位寄存器，AL 表示低位的8 位寄存器。

AX 寄存器：

如上所说，AX 的另外一个名字叫做累加寄存器或者简称为累加器，其可以分为 2 个独立的8 位寄存器AH 和AL；

在写汇编程序时，AX 寄存器可以说是使用率最高的寄存器（不过，总共才那么14 个寄存器，哪一个不经常使用咯？），

既然AX 是数据寄存器的话，那么理所当然，其可以用来存放普通的数据，由于其是16 位寄存器，

自然也就可以存放16 位数据，但是因为其又可以分为2 个独立的8 位寄存器AH 和AL ，

所以，在AH 和AL 中又可以独立的存放2 个8 位的数据，

可以有以下代码（即将AX 当做普通的寄存器使用，即可以用来暂存数据）：

MOV AX,1234H;向寄存器AX 传入数据1234H

MOV AH,56H;向寄存器AX 的高8 位寄存器AH 中传入数据56H

MOV AL,78H;向寄存器AX 的低8 位寄存器AL 中传入数据78H

3 条语句的执行过程如下：

而既然AX 又被称作为累加器，自然其还有一点点特殊的地方的：

AX 寄存器还具有的特殊用途是在使用DIV 和MUL 指令时使用，

DIV 在8086 CPU 中是除法指令，而在使用除法的时候有两种情况，即除数可以是8 位或者是16 位的，而且除数可以存放在寄存器中或者是内存单元中，而至于被除数的话，自然，应该由AX 来代替了，

当除数是8 位时，被除数一定会是16 位的，并且默认是放在AX 寄存器中，

而当除数是16 位时，被除数一定是32 位的，因为AX 是16 位寄存器，自然，放不下32 位的被除数，所以，在这里还需要使用另一个16 位寄存器DX ，

其中DX 存放32 位的被除数的高16 位，而AX 则存放32 位的被除数的低16 位，

同时，AX 的作用还不仅仅是用来保存被除数的，当除法指令执行完成以后，

如果除数是8 位的，则在AL 中会保存此次除法操作的商，而在AH 中则会保存此次除法操作的余数，当然，如果除数是16 位的话，则AX 中会保存本次除法操作的商，而DX 则保存本次除法操作的余数。上面介绍的是AX 寄存器在除法操作中的应用，下面还需要介绍一下AX 在乘法操作中的应用，

当使用MUL 做乘法运算时，两个相乘的数要么都是8 位，要么都是16 位，

如果两个相乘的数都是8 位的话，则一个默认是放在AL 中，

而另一个8 位的乘数则位于其他的寄存器或者说是内存字节单元中，

而如果两个相乘的数都是16 位的话，则一个默认存放在AX 中，

另一个16 位的则是位于16 的寄存器中或者是某个内存字单元中。

同时，当MUL 指令执行完毕后，如果是8 位的乘法运算，则默认乘法运算的结果是保存在AX 中，

而如果是16 位的乘法运算的话，则默认乘法运算的结果有32 位，

其中，高位默认保存在DX 中，而低位则默认保存在AX 中。

AX 寄存器在DIV 指令中的使用：

MOV DX,0H ;设置32 位被除数的高16 位为0H

MOV AX,8H ;设置32 位被除数的低16 位为8H

MOV BX,2H ;设置16 位除数为2H

DIV BX ;执行计算

4 条语句的执行过程如下：

AX 寄存器在MUL 指令中的使用：

MOV AX,800H ;设置16 位乘数为800H MOV BX,100H ;设置16 位乘数为100H

MOV DX,0H ;清空用来保存乘法结果的高16 位MUL BX ;执行计算

4 条语句的执行过程如下：

BX 寄存器：

首先可以明确的是，BX 作为数据寄存器，表明其是可以暂存一般的数据的，

即在某种程度上，它和AX 可以暂存一般性数据的功能是一样的，

其同样为了适应以前的8 位CPU ，而可以将BX 当做两个独立的8 位寄存器使用，即有BH 和BL，除了暂存一般性数据的功能外，BX 作为通用寄存器的一种，BX 主要还是用于其专属功能–寻址（寻址物理内存地址）上，

BX 寄存器中存放的数据一般是用来作为偏移地址使用的，何为偏移地址呢？

既然是偏移地址的话，当然得有一个基地址了，而这个基地址其实就是段地址，这里就涉及到了段寄存器，当然，在介绍BX 寄存器的时候，我不会去介绍段寄存器，上面提到BX 的主要功能是用在寻址上，

那么，其是如何寻址的呢？

对于寻址这个话题，我会在我的下一篇博文中作出详细的介绍，

而这里，我只点一下，在8086 CPU 中，CPU 是根据<段地址：偏移地址> 来进行寻址操作的，

而BX 中存放的数据表示的是偏移地址的话，自然，便可以通过<段地址：[BX]> 的方式来完成寻址操作了。

为了介绍BX 在寻址当中的作用，下面我给出一副示意图：

上面的示意图表示：可以令BX = 2，然后通过DS : [BX] 来访问到内存中段地址为DS，且偏移量为2 的内存单元了。

上面介绍的这种寻址方式是BX 在寻址中最最简单的应用了，而对于稍微复杂的寻址方式，

还可以依赖于SI，DI，BP 等寄存器来一起完成，当然，这会是下一篇博文将要介绍的内容了。

BX 寄存器在寻址中的使用：

MOV BX,5H

MOV AH,11H

MOV AH,[BX] ;设置AX 的值为偏移地址为BX 中的值时所代表的内存单元

3 条语句的执行过程如下：

从上图可以看出，在偏移地址为 5 时的内存单元中的数据位BBH，

而从这幅图上面就可以看出，确实通过[BX] 找到了偏移地址为5 处的内存单元，并且将内存单元移入了AH 中。

CX 寄存器：

CX 寄存器作为数据寄存器的一种呢，其同样具有和AX，BX 一样的特点，即可以暂存一般性的数据，同时还可以将其当做两个独立的8 位寄存器使用，即有CH 和CL 两个8 位寄存器，

当然，CX 也是有其专门的用途的，CX 中的C 被翻译为Counting 也就是计数器的功能，

当在汇编指令中使用循环LOOP 指令时，可以通过CX 来指定需要循环的次数，

而CPU 在每一次执行LOOP 指令的时候，都会做两件事：

一件就是令CX = CX – 1，即令CX 计数器自动减去1；

还有一件就是判断CX 中的值，如果CX 中的值为0 则会跳出循环，而继续执行循环下面的指令，

当然如果CX 中的值不为0 ，则会继续执行循环中所指定的指令。

CX 寄存器在循环中的使用（输出5 个白底蓝字的A）：

MOV AX,0B800H

MOV DS,AX ;使用80x25 彩色字符模式，内存地址0xB8000 - 0xBFFFFF

MOV BX,0 ;从0xB8000 开始

MOV CX,5H ;循环5 次

MOV DX,41H ;A 的16 进制为41H

MOV AX,01110001B ;显示白底蓝字

s: MOV [BX],DX ;显示ASCII 字符

ADD BX,1

MOV [BX],AX ;设置字符显示属性

ADD BX,1

LOOP s

语句的执行过程如下：

DX 寄存器：

DX 寄存器作为数据寄存器的一种，同样具有和AX，BX，CX 一样的特点，即可以暂存一般性的数据，

同时还可以将其当做两个独立的8 位寄存器使用，极有DH 和DL，

同时，DX 作为一个通用寄存器的话，自然其还有其他的用途，而关于DX 在其他方面的用途，

其实在前面介绍AX 寄存器时便已经有所介绍了，

即当在使用DIV 指令进行除法运算时，如果除数为16 位时，被除数将会是32 位，而被除数的高16 位就是存放在DX 中，

而且执行完DIV 指令后，本次除法运算所产生的余数将会保存在DX 中，

同时，在执行MUL 指令时，如果两个相乘的数都是16 位的话，

那么相乘后产生的结果显然需要32 位来保存，而这32 位的结果的高16 位就是存放在DX 寄存器中。DX 寄存器在DIV 指令中的使用（即2293812 / 256 = 8960 余数为52）：

MOV DX,0023H ;32 位被除数的高16 位

MOV AX,0034H ;32 位被除数的低16 位

MOV BX,100H ;16 的除数

DIV BX

语句的执行过程如下：

可以看到在语句结束以后，AX = 2300H 即十进制的8960，而DX = 34H即十进制的52 和我们的结果是一致的。

DX 寄存器在MUL 指令中的使用则各位可以参考在AX 中MUL 运算的使用，这里就不贴出来了。

指针寄存器（BP，SP）：

BP 寄存器：

8086 CPU 中的指针寄存器包括两个，即SP 和BP ，在这里呢，我先只对BP 寄存器做介绍，

因为SP 寄存器实质上必须和SS 段寄存器一起使用，所以，我将会把SP 寄存器留到后面和SS 段寄存器一起作介绍。

BP (Base Pointer)也就是基指针寄存器，它和其他的几个用来进行寻址操作所使用的寄存器（还有BX，SI，

DI）没有太大的区别，

关于SI 和DI 寄存器的下面请见下文。

首先，BP 寄存器作为通用寄存器的一种，说明其是可以暂存数据的，而后，BP 又不是数据寄存器，

也就意味着其不能分割成2 个独立的8 位寄存器使用，

而后当以[…] 的方式访问内存单元而且在[…] 中使用了寄存器BP 的话，

那么如果在指令中没有明确或者说是显示的给出段地址时，

段地址则使用默认的SS 寄存器中的值（BX，SI，DI 会默认使用DS 段寄存器），

比如DS:[BP] 则在这里明确给出了段地址位于DS 中，

所以，这里代表的内存单元即是段地址为DS ，偏移量为BP 寄存器中的值的内存单元，

而如果单单是使用[BP] 的话，则代表的内存单元是段地址为SS，偏移量为BP 寄存器中的值的内存单元。

并且BP 寄存器主要适用于给出堆栈中数据区的偏移，从而可以方便的实现直接存取堆栈中的数据，

至于堆栈的话，会在后面的博文中介绍。

在8086 CPU 中，只有 4 个寄存器可以以[…] 的方式使用，这四个寄存器分别是BX，SI，DI，BP。

下面的Demo 是BX 寄存器在寻址中的使用：

MOV BP,0

MOV AX,[BP] ;将SS:[BP] 代表的内存单元移入AX 中

MOV AX,CS:[BP] ;将CS:[BP] 代表的内存单元移入AX 中

语句的执行过程如下：

变址寄存器（SI，DI）：

首先，变址寄存器和上面介绍的指针寄存器（也就是BP 和SP），它们的功能其实都是用于存放某个存储单元地址的偏移，

或者是用于某组存储单元开始地址的偏移，即作为存储器指针使用，当然，由于变址寄存器和指针寄存器都是属于通用寄存器，

所以它们也可以保存算术结果或者说是具有暂存数据的功能，但是因为它们不是数据寄存器，所以无法分割成2 个独立的8 位寄存器使用，

关于变址寄存器和指针寄存器的详细使用，笔者将会在下一篇博文中作出最详细的介绍，

SI (Source Index) 是源变址寄存器，DI (Destination Index) 即是目的变址寄存器，

8086 CPU 中的SI 寄存器和DI 寄存器其实和BX 寄存器的功能是差不多的，

只不过SI 寄存器和DI 寄存器均不是数据寄存器，所以它们不能够拆分为 2 个独立的8 位寄存器，而这也就是SI 寄存器和DI 寄存器与BX 寄存器所不同的地方，

既然，SI，DI 两个寄存器的功能和BX 差不多，自然，SI 和DI 中也是可以暂存一般性数据的，

同时，通过使用SI 和DI 寄存器也是可以用来完成寻址操作的。

比如下面的代码就是可行的：

MOV SI,0 ;初始化偏移地址为0

MOV AX,[SI] ;将段地址为DS 偏移地址为SI 的内存单元中的值移入AX 中

MOV AX,DS:[SI] ;将段地址为DS 偏移地址为SI 的内存单元中的值移入AX 中

MOV AX,SS:[SI] ;将段地址为SS 偏移地址为SI 的内存单元中的值移入AX 中

MOV DI,0 ;初始化偏移地址为0

MOV AX,[DI] ;将段地址为DS 偏移地址为DI 的内存单元中的值移入AX 中

MOV AX,DS:[DI] ;将段地址为DS 偏移地址为DI 的内存单元中的值移入AX 中

MOV AX,SS:[DI] ;将段地址为SS 偏移地址为DI 的内存单元中的值移入AX 中

其他寄存器（CS，IP，SS，SP，DS，ES）

由于段寄存器总是和其他一些像指针寄存器，变址寄存器，控制寄存器一起使用，

所以在这里，我并不会单独介绍段寄存器，而是将段寄存器和一些其他的常用寄存器搭配介绍。

由于下面的介绍中会涉及到很多关于段和栈的概念，而段和栈的介绍又都必须关系到物理内存，

所以在介绍段寄存器以及其他一些呈协作关系的寄存器之前，还是先来介绍一下这几个基本的概念比较好。8086 CPU 访问内存（物理地址）：

当CPU 需要访问一个内存单元时，需要给出内存单元的地址，

而每一个内存单元在物理内存空间中都有一个唯一的地址，

即可以通过这个地址定位到内存单元，而这个地址即为物理地址。

CPU 通过地址总线将一个内存单元的物理地址送入存储器，

而后CPU 便可以通过这个物理地址来访问这个物理地址所指向的内存单元了。

那么这个物理地址在CPU 中是如何形成的呢？

首先，我们知道8086 CPU 的地址总线是20 根，

即每次都可以传输20 位的地址，从而寻址能力有220也就是1MB 的大小，

但是8086 CPU 的寄存器只有16 位，也就是在8086 CPU 的内部，

一次性处理，传输，暂存的地址都只能是16 位，

即8086 CPU 不能完整的保存下一个物理地址（物理地址为20 位），

如果单单以最简单的方式（即直接用16 位寄存器来保存物理地址）的话，那么，寻址能力只有216，也就是64KB，

如果真以如此简单的方式的话，那么地址总线还需要20 根干嘛呢？而且，难不成我们以后的内存就是64KB 了吗？

当然不是的，8086 CPU 在这里采取了一定的措施从而使其寻址能力达到1MB 。

8086 CPU 在内部通过两个16 位的地址进行合成从而形成一个20 位的物理地址，由此，8086 CPU 的寻址能力便可以达到1MB 。

那么8086 CPU 又是如何将两个16 位的地址合成为一个20 位的物理地址的呢？

当CPU 在访问内存时，其会使用一个16 位的基地址，然后再使用一个16 位的偏移地址，

通过将基地址和偏移地址传入8086 CPU 的地址加法器中进行合成即可以构造出20 位的物理地址。

至于合成的方式如下：

基地址其实是通过一个16 位的段地址来形成的，将一个段地址左移4 位即形成了基地址，

而至于偏移地址的话，自然不必多说，为16 位，通过将基地址和偏移地址相加便形成了20 位的物理地址。

下面给出一幅示意图来表示物理地址的合成：

段：

至于段的话，其实在物理内存中是没有段这一概念的，事实上，段的概念来自于CPU ，

因为CPU 拥有段寄存器，既然在CPU 中拥有了段寄存器，自然，在CPU 中就肯定有段的概念了，

其实段也就是在编程时，我们将若干个地址连续的内存单元看做是一个段，

然后通过将一个段地址左移4 位形成基地址，再通过这个基地址来定位这个段的起始地址，

然后，再通过偏移地址便可以精确定位到段中的内存单元了，由于段的起始地址是一个段地址左移 4 位，所以很明显，段的起始地址肯定是16 的倍数，而且由于一个段内部，只能通过偏移地址来定位，

而偏移地址为16 位，所以一个段的长度也就是216也就是64KB 的大小。

在编程时，可以讲一段内存定义成为一个段，而这里，我们又可以引出数据段，代码段，栈段这三种类型的段。

何为数据段呢？其实就是我们自个儿定义一段内存（当然段起始地址肯定是16 的倍数，并且段长度<= 64KB），

然后我们在这个段里头存放我们所需要使用的数据，这就是数据段；

何为代码段呢？其实也很简单，也是我们自己在编程的时候定义一段内存，然后这段内存用来存放我们的代码（也就是指令），

既然是存放的代码，自然就称之为代码段；

何为栈段呢？至于栈段的话，有接触过数据结构的朋友应该是很清楚栈的，而这里我们也就是在内存中分配出一个段，

然后将这个段当做栈来使用，对于栈的介绍，详见下文；

这里呢，顺便还点出几个关于段寄存器的内容，当然下文还会详细介绍的，

首先，对于任何一个段来说，均有段地址，而这些段地址是存放在段寄存器中（段寄存器的作用也在于此），但是对于不同的段，它们默认的段地址存放在不同的段寄存器中，像

数据段来说，它的段地址存放在DS （Data Segment）寄存器中，

代码段的段地址存放在CS （Code Segment）寄存器中，

栈段的段地址存放在SS （Stack Segment）寄存器中。

下面给出一幅在段中寻址的示意图：

上面的示意图中，通过将段地址左移四位，然后与偏移地址相加便可以得到20 位的物理地址了。

栈：

8086 CPU 中提供了对栈的支持，并且其还提供了相应的指令来以栈的方式访问内存空间。

什么是栈？

通过上面在段中的介绍，栈其实就是一个段，再说白一点，也就是一块内存，当然，这块内存是一块连续的内存。

既然栈是一个段的话，那么当然就可以以使用段的方式来使用栈，当然，除了像段一样的使用栈以外，

栈还提供了其特殊的访问方式（如果和段一模一样的话，那还需要栈干吗呢？），

众所周知，栈是先进后出类型的数据结构，在8086 CPU 中也是如此，

可以通过”PUSH“指令将数据压入栈中，然后再通过”POP“指令将栈顶的元素取出来。

下面给出一幅示意图来描述栈：

即通过PUSH 10 来将元素10 放入栈中，因为，先前栈中没有任何数据，所以，10 就会作为栈顶元素存在，

然后再在栈中压入元素20 ，此时，栈顶中的元素就是20 了，然后再使用POP 指令将栈顶元素取出，此时取出的栈顶元素是20 ，取出20 后，栈中便只剩下10 了，自然10 就成为了栈顶，

最后再通过POP 指令将栈顶10 取出，此时，栈便变成了空栈了。

好了，在介绍段寄存器之前的基础知识介绍就到这里了，下面开始正式介绍段寄存器以及与它们协作使用的寄存器。

CS 寄存器和IP 寄存器：

经过前面对段的介绍，相信各位朋友对段寄存器应该也有一定的了解了，

下面将要介绍的是一组非常非常重要的寄存器，即CS:IP 。

CS:IP 两个寄存器指示了CPU 当前将要读取的指令的地址，其中CS 为代码段寄存器，而IP 为指令指针寄存器。

什么叫做指示了CPU 当前将要读取的指令呢？在8086 CPU 中，为什么CPU 会自动的执行指令呢？这些指令肯定是存放在内存中的，但是CPU 怎么知道这些指令存放在内存的那个位置呢？

比如，我有下面的两条指令要执行：

MOV AX,1234H

MOV BX,AX

而假设这两条指令在内存中存放为：

很显然，1000H:0000H 指向的是MOV AX，1234H 的首地址，

如果CPU 要读取到我的指令的话，很显然，必须要知道地址1000H:0000H ，

然后CPU 就可以根据这个首地址，将汇编指令MOV AX，1234H所对应的机器码读入到CPU 的指令寄存器中，

最后便可以在CPU 中进行处理了。

但关键是CPU 如何知道我的1000H:0000H 这个首地址？

其实这就需要使用到CS:IP 这个寄存器组了。

当我们运行一个可执行文件时，很明显，我们需要另外一个程序来将这个可执行文件加载到内存当中，

关于这个加载可执行文件的程序，我们在这里不管他，点一下即可，

一般是通过操作系统的外壳程序（也就是传说中的Shell 程序），

Shell 将可执行文件加载到内存中以后，就会设置CPU 中的两个寄存器，

即设置CS:IP 两个寄存器指向可执行文件的起始地址，此后CPU 便从这个起始地址开始读取内存中的指令，并且执行，

比如我们在写汇编程序时，通常会使用START 标记，其实这个标记就是用来标记起始地址的，

当将一个汇编程序编译，连接成可执行文件以后，再通过操作系统的Shell 程序将可执行文件加载到内存中以后，

这个START 所标记处的地址就是整个可执行文件的起始地址了。

也就是说，当一个可执行文件加载到内存中以后，CS:IP 两个寄存器便指向了这个可执行文件的起始地址，

然后CPU 就可以从这个起始地址开始往下读取指令，

当读取完指令后，CS:IP 将会自动的改变，基本上是改变IP ，从而指向下一条要读取的指令，这样就可以执行这个可执行文件了。

最后再对CS:IP 总结一下：

1你想让CPU 执行哪行指令，你就让CS:IP 指向保存有指令的那块内存即可。

2任何时候，CS:IP 指向的地址中的内容都是CPU 当前执行的指令。

下面我们来看一个Demo，并详细观察其执行的过程：

ASSUME CS:CODES

CODES SEGMENT

START:

MOV AX,1234H

MOV BX,AX

MOV AH,4CH

INT 21H

CODES ENDS

END START

语句的执行过程如下：

从上面的截图中可以看出，当我使用Shell （在DOS 下也就是Command 命令解释器）将可执行文件加载进内存后，

可以看到，整个程序的起始地址为0C54H : 0000 H ，并且，可以看到CS 的地址为0C54H ，IP 的地址为0000H，

这正好吻合我们上面对CS:IP 的分析，很明显，CPU 将会读取MOV AX ，1234H到CPU

中并且执行，

然后我们继续向下看：

可以看到，我们单步执行后，AX 中的值编成了1234H ，而IP 寄存器中的值变成了0003H，

对于AX 中的值的改变，我们是能够理解的，但是IP 中的值为什么会从0000H 变到0003H 呢？

从最上面的一幅关于指令在内存中的存放可以看出MOV AX ，1234H在内存中需要 3 个内存单元存放，

也就是CPU 为了执行MOV AX ，1234H这条指令，已经将内存中相对应的 3 个内存单元读入内存中了，

执行完这条指令后，自然，CPU 就要将偏移地址向下移动 3 个单元，从而使得CS:IP 指向下一条需要执行的指令了，

为了更深刻的理解，我们再来继续看执行过程，

从最上面的一幅关于指令在内存中的存放可以看出MOV BX ，AX在内存中只占 2 个内存单元，

这也就是为什么IP 这一次只向下移动了 2 个单元的缘故。

关于CS: IP 的遐想：

从上面关于CS:IP 的介绍中，我们可以大胆的猜想，我们只需要通过手动的改变CS:IP 所指向的内存地址，

让CS:IP 指向我们另外的代码，那么我们就可以让CPU 执行我们自己指定的代码了。

即可以通过修改CS:IP 来达到我们想要让CPU 干什么它就干什么的目的。

上面的虽然是遐想，但是大家要相信，我们写的是汇编，不是JAVA 也不是NET ，

所以我们还真的可以达到上面的目的，也就是说我们的遐想其实是可以实现的，当然这还是有一定的限制的，

关于这个遐想呢，可能会在我后续的博文中有所介绍，不过感兴趣的当然可以自己去尝试了，蛮有味的哦。

SS 寄存器和SP 寄存器：

根据前面对栈的介绍，相信各位对栈也肯定是有一定了解了的，更何况，估计大家也是职场打滚多年的，要是栈都没用过的话，那也确实蛮悲剧的，所以，我在这里也不会对栈做十分详细的介绍了，

但是，最基本的介绍还是要的，毕竟在底层的话，不像高级语言那么方便，可以直接一个Stack 就OK 的，

在底层涉及的是栈在内存中的具体实现。

不知道，大伙有没有注意笔者在本篇博文的上面介绍关于栈的知识时，我并没有提到如何找到这个栈，

我只提到了一个栈就是先进后出操作，同时可以使用”PUSH“和”POP“指令，

然后就是稍微带了一下SS 这个寄存器的介绍，

我们虽然在内存中是可以方便的定义一个栈了，但是，我们为什么要定义这么一个栈呢？

自然，是为了操作方便，同时提供给CPU 使用的，

既然CPU 要使用的话，自然，CPU 又必须根据一定的方式找到这个栈，

而这就需要使用SS 和SP 寄存器了。

同时，一个栈也就是一块内存区域，通过上面的介绍，我们也知道了如果要在一块内存中精确地定位到内存单元的话（寻址），

我们必须要有基地址（也就是段地址左移 4 位）和偏移地址，自然，要在一个栈中寻址的话，也需要段地址和偏移地址，

而对于一个栈来说，我们使用的最多的是什么呢？

当然是栈顶了，因为只有栈顶可以用来存取数据，所以对于一个栈来说，我们只需要有栈顶的段地址和偏移地址即可，

而对于栈顶的段地址，其是存放在段寄存器SS 中的，而对于栈顶的偏移地址，其则是存放在SP 寄存器中的。

记住，在任何时刻，SS:SP 都是指向栈顶元素。

其实关于栈的使用还是比较简单的，但是要注意的是8086 CPU 并不会保证我们对栈的操作会不会越界。

所以我们在使用栈的时候需要特别注意栈的越界问题。

当使用PUSH指令向栈中压入1 个字节单元时，SP = SP - 1；即栈顶元素会发生变化；

而当使用PUSH指令向栈中压入 2 个字节的字单元时，SP = SP – 2 ；即栈顶元素也要发生变化；

当使用POP指令从栈中弹出 1 个字节单元时，SP = SP + 1；即栈顶元素会发生变化；

当使用POP指令从栈中弹出 2 个字节单元的字单元时，SP = SP + 2 ；即栈顶元素会发生变化；

下面通过一个Demo 来介绍栈的使用：

ASSUME CS:CODES

CODES SEGMENT

START:

MOV AX,1000H ;首先是定义好栈的段地址

MOV SS,AX

MOV AX,10H ;再定义好栈的长度（初始时刻的栈顶偏移地址即栈的长度）

MOV SP,AX

MOV AX,0001H

PUSH AX

MOV AX,0002H

PUSH AX

MOV AX,0003H

PUSH AX

MOV AX,0004H

PUSH AX

MOV AX,0005H

PUSH AX

POP AX

POP AX

POP AX

POP AX

POP AX

MOV AH,4CH

INT 21H

CODES ENDS

END START

然后我们来看栈在内存中的结构图：

语句的执行过程如下：

首先我们来看尚未执行上述任何指令时栈中的数据情况：

然后我们再来依次执行上述指令：

从上副截图中可以看出已经设置好了SS:SP ，也就是栈已经设置OK 了，

下面开始往栈中压入数据了，

由于我们压入栈中的数据为字数据，即占2 个内存单元，所以，每次SP = SP – 2 ；将5 个字型数据压入栈中后，我们可以来查看栈中的数据了，

因此，在内存中的一个好看点的结构图如下所示：

下面开始进行出栈操作了