（注：部分答案解析由gpt生成，仅供参考）

单选题

第一章

A. bit     B. 字节    C. 字长       D. 字

A PC机的最小信息单位是比特(bit)，常用来表示一位二进制数字（0或1）。字节(byte)是计算机中常用的数据单位，一个字节由8个比特组成。字长(word)是指一个CPU可以一次处理的二进制数的位数。字是在汇编、编程等场合中用来表示数据长度的单位。

A. 8      B. 3     C. 12     D. 13

一个CPU的寻址能力是8KB，即CPU可以寻址的内存空间大小为8KB。一个字节是8位，因此8KB等于8 x 1024字节，即8192字节。CPU的地址总线宽度决定了CPU可以寻址的内存空间大小，因此，地址总线宽度为log2(8192) = 13位。因此，答案为D。

A. 11                   B. 12                   C. 13                   D. 14

一个CPU的寻址能力为16KB，即CPU可以寻址的内存空间大小为16KB。因为CPU使用地址总线来寻址内存，所以地址总线的宽度就是CPU可以寻址的最大内存空间大小的二进制位数。16KB的二进制表示为2^14，所以地址总线的宽度为14位，答案为D。

A.0~3ff H           B. 1~400 H           C.  0~fffff H    D.  1~100000H

1MB的存储器地址编号从0到0xFFFFF H，因为1MB等于1024KB，而1KB等于1024字节，所以1MB等于1024 x 1024字节，即1,048,576字节。每个字节需要一个地址编号，因此1MB的存储器地址编号从0到1,048,575，用16进制表示即为0x00000到0xFFFFF H。选项A、B、D的地址范围都小于1MB，不符合实际情况。

A. 2^40     B. 2^30      C. 2^20               D. 2^10

1TB是1万亿字节（10^12 bytes），而1个字节是8位（即1 byte = 8 bits），因此1TB等于8 x 10^12 bits。在计算机中，2的幂次方是常用的计量单位，因此将8 x 10^12 bits转换为2的幂次方，可以得到1TB等于2^40 bytes。因此，答案是A. 2^40。

A. 2^40      B. 2^30      C. 2^20     D. 2^10

1MB是指1兆字节，其中1兆等于2的20次方，即2^20，因此1MB等于2^20个Byte，答案为C。

A. 0~3ff H                   B. 1~400 H          C.  0~fffff H           D.  1~100000H

1KB的存储器共有1024个存储单元，每个存储单元占用1个字节，因此总共有1024个地址编号。由于地址编号是从0开始的，因此该存储器的地址编号从0到1023，用十六进制表示为0x000到0x3FF。因此，选项A是正确的答案。选项B、C、D的地址编号范围都超出了1KB存储器的地址编号范围。

A. 1024                B. 8×1024                  C. 1000               D. 8000 

1KB的存储器可以存储1024个字节，1个字节等于8个bit，因此1KB的存储器可以存储1024×8=8192个bit。因此，答案为B 。

A. 2^40     B. 2^30      C. 2^20               D. 2^10

1GB是2的30次方Byte，即2^30 Byte。因为1GB等于1024MB，1MB等于1024KB，1KB等于1024Byte，所以1GB等于1024*1024*1024 Byte，即2^30 Byte。

A. 16                   B. 20           C. 10                   D. 5

8086的数据总线宽度为16根，每次可以传输16位数据，即2个字节。要读取20字节的数据，需要进行10次读取，每次读取2个字节。因此，答案为C. 10。

A. 32                   B. 20           C. 10                   D. 5

8386的数据总线宽度为32根，每次可以传输32位（4字节）的数据。要读取20字节的数据，需要进行5次传输，即 20字节 ÷ 4字节/次 = 5次。因此，答案为D。

A. 二进制          B. 八进制          C. 十进制          D. 十六进制

A 在存储器中，数据和程序通常以二进制形式存放。这是因为计算机中的所有数据和指令都是以二进制形式表示的，即由0和1组成的二进制数。计算机的存储器只能存储二进制数，因此数据和程序都需要以二进制形式存储在存储器中。虽然在编程中也可以使用其他进制表示数据和指令，但最终都需要转换为二进制形式才能在计算机中执行。因此，二进制是计算机中最基本的数制。

A.64KB     B.1MB     C.1GB      D.不确定

B 8086CPU的地址总线宽度为20位，可以寻址的地址数量为2的20次方，即1MB。

A.64KB    B.1024KB   C.16MB      D.4096MB

 80386CPU的地址总线宽度为32根，可以寻址的物理地址空间大小为2的32次方，即4GB。因此，80386CPU的寻址能力为D. 4096MB。

A.4       B.8     C.16      D.32

 80386 CPU 的数据总线宽度为 32 位。 

从内存中读取 1024 个字节的数据，每次读取的数据宽度为 1 字节，因此需要读取 1024 次。 

80386 CPU 的数据总线宽度为 32 位，每次可以传输 4 个字节，因此每次可以读取 4 个字节的数据。所以，需要读取 1024 次，即需要传输 1024 * 1 字节的数据，共计 1024 * 1 / 4 = 256 次。

A.1    B.8    C.16     D.32

 8086是16位处理器，一个字单元可以存储16个bit，因此答案是C.16。

A. 1024，1024    B. 8192，1024     C. 8192，8192     D. 1024，8192

一个1KB的存储器包含1024个存储单元，因为1KB等于1024字节。每个字节由8个二进制位组成，因此一个1KB的存储器可以存储8 x 1024 = 8192个二进制位。因此，答案是选项D，即一个1KB的存储器包含1024个存储单元，可以存储8192个二进制位。

第2~3章

075A：0110  B8  00  00  FF  07  00  B8  4C — CD  21  F3  69  20  8A  03  A1 

那么，字型数据 00B8H对应的地址为（ ）。

A. 076A：11    B. 076A：16       C. 076B：0        D. 无法确定

C cs+ip 075a+0110=076b，第0个

A、 12340H~1234FH                    B、 01234H~F1234H          C、 12340H~2233FH            D、 12340H~FFFFFH

8086CPU中的偏移地址是一个16位的值，需要与段地址相加才能得到物理地址。因此只有通过变化偏移地址进行寻址时，物理地址的范围取决于段寄存器的值。

在这个问题中，给定的地址是1234H，仅通过变化偏移地址寻址，这意味着使用的是DS寄存器（或ES、SS、CS）作为段寄存器。因为在实模式下，段寄存器的值左移4位作为段地址，再加上偏移地址，就可得到物理。

偏移地址变化的范围为0~FFFFH，因此：

物理地址的限为12340H （段地址为1234H，加上偏移地址0H）；

物理地址上限为2233FH （地址为1234H，加上偏移地址FFFFH）。

因此，选项C：12340H~2233FH是正确的。

         A. 0     B. 12000H      C. 10000H      D. 1FFFFH

C 1010+0~FFFF=1010~1100F

A、 AX               B、 BL              C、 CS             D、 DI

下列寄存器中，B. BL 是8位寄存器。

A、 AX              B、 BL               C、 CH              D、 DL

下列寄存器中，A. AX 是16位寄存器。

A、 AX寄存器不能分为两个8位的寄存器

B、 BP寄存器不能分为两个8位的寄存器

C、 CS可以分为两个8位的寄存器

D、 PSW是一个通用寄存器，可以存放一般性的数据

下列说法正确的是：B

B、 BP寄存器不能分为两个8位的寄存器

BP寄存器（Base Pointer）是一个16位寄存器，不能分为两个8位的寄存器。它通常用于存储堆栈帧的基址。

A、 AX寄存器可以分为两个8位的寄存器。AX寄存器是一个16位寄存器，但可以分为AH（高位）和AL（低位）两个8位寄存器。

C、 CS寄存器不能分为两个8位的寄存器。CS寄存器（Code Segment）是一个16位寄存器，用于存储当前执行指令的代码段的起始地址。

D、 PSW（Program Status Word）并非通用寄存器，它是一种特殊的寄存器，用于存储程序的状态信息，如标志位等。它不能用于存放一般性的数据。

A、 MOV  AX,1000                      B、 MOV  AL,BL

C、 MOV  AL,1000                     D、 MOV   DS,AX

错误的指令是：

C、 MOV AL,1000

这指令试图将立即数1000移动到AL寄存器中，但是AL是一个8位寄存器，无法容纳1000这个16位的立即数。正确的写法应该是使用合适的寄存器大小或者有效的立即数。

八位寄存器AL的取值范围是0到255(FFFF H)

A、 MOV  AX,100               B、 MOV  BX,AL

C、 MOV  AL,100              D、 ADD  AL,BL

B MOV BX,AL 是错误的指令。由于BX是一个16位寄存器，而AL是一个8位寄存器，无法直接将AL的值移动到BX中。正确的方式应该是使用AX寄存器作为中介，将AL的值先移动到AX，再将AX的值移动到BX。

正确的指令应该是 MOV AX,AL，然后 MOV BX,AX。首先将AL的值移动到AX，然后将AX的值移动到BX

A、 MOV  AX,100               B、 MOV  BX,AL

C、 MOV  100，AL            D、 ADD  AL,1234H

A、 MOV AX,100

这条指令将立即数100移动到AX寄存器中，这是有效的。

mov ax,2000H

mov bx,3000h

add ax,bx

sub bx,bx

jmp bx

A、 5                 B、 6                 C、 7                 D、 不确定

指令执行的过程中，CPU会不断地修改IP的值以指向下一条要执行的指令。

执行第 1 条 mov ax, 2000H 指令时，会将下一条要执行的指令地址存储在IP寄存器中，此时IP指向的地址为第2条指令的地址，即 mov bx, 3000h。

执行第 2 条 mov bx, 3000h 指令时，会将下一条要执行的指令地址存储在IP寄存器中，此时IP指向的地址为第3条指令的地址，即 add ax, bx。

执行第 3 条 add ax, bx 指令时，会将下一条要执行的指令地址存储在IP寄存器中，此时IP指向的地址为第4条指令的地址，即 sub bx, bx。

执行第 4 条 sub bx, bx 指令时，会将下一条要执行的指令地址存储在IP寄存器中，此时IP指向的地址为第5条指令的地址，即 jmp bx。

执行第 5 条 jmp bx 指令时，会将下一条要执行的指令地址存储在IP寄存器中，此时IP指向的地址为 bx 中存储的地址，即第2条指令的地址，即 mov bx, 3000h。然而此时bx的值已经为0，因此程序将会无限循环，不再修改IP的值了。

因此，执行这5条指令后，CPU会修改IP 6 次。

A、 CS               B、 DS               C、 SS               D、 ES

代码段寄存器是 CS（Code Segment Register），CS寄存器中存储着当前程序代码所在的段地址，用于指向CPU需要执行的程序代码段。程序从CS寄存器指向的第一条指令开始，然后按顺序执行指令直到程序结束。

A、 AX              B、 BP               C、 IP                D、 DS

指令指针寄存器是 IP (Instruction Pointer)。IP寄存器中存储着下一条要执行的指令的地址。CPU执行完一条指令后，会自动去IP寄存器中读取下一条指令的地址，然后继续执行。

A、 T                 B、 A                 C、 E                 D、 R

用R命令查看、改变CPU寄存器的内容 用D命令查看内存中的内容 用E命令改写内存中的内容 用U命令将内存中的机器指令翻译成为汇编指令 用T命令执行一条机器指令 用A命令以汇编指令的格式在内存中写入一条机器指令

A、 T                 B、 A                 C、 D                D、 R

D

A、 T                 B、 E                 C、 D                D、 R

B

A、 T                 B、 E                 C、 D                D、 R

在debug中，执行CS、IP指向的内存单元处的指令是 T 命令。T命令可以单步执行一条指令，执行完后CPU暂停，等待用户的下一个命令。当执行完当前指令后，可以用R命令查看寄存器的值，L命令查看当前指令执行后的内存状态。

A、 45AB9H               B、 4D6B9H                C、 C259H                  D、 47CB9H

假设存储单元的地址线有16根，那么物理地址应该是 `45A0H` 左移4位得到的，即 `45A00H`。加上偏移量 `7CB9H` 得到真实的物理地址为 `45A0H + 7CB9H = 4D69H`。因此，选项B `4D6B9H` 是正确的。

A. DS、SI     B. CS、IP     C. SS、SP      D. ES、DI

B 8086CPU中，任意时刻，CPU将 CS、IP 指向的内容当作指令来执行，即指令指针寄存器 (IP) 存储下一条指令在代码段内的偏移地址，代码段寄存器 (CS) 存储代码段的基地址。CPU 从代码段基地址加上偏移地址，得到指令的物理地址，然后从内存中读取指令并执行。

A. R命令可以修改寄存器的内容。     B. E命令可以修改内存单元的内容。

C. T命令每次只执行一条指令。       D. D命令可以查看内存单元的内容。

C 

A. mov ax,bx     B. mov ax,[bx]     C. mov ds,0      D. mov ax,0

对于8086CPU，错误的指令是 C. mov ds,0。在8086CPU中，DS作为一个寄存器用来存储数据段的地址，通常情况下应该将其设置为一个非零的值，而不是直接将其清零。其他三个指令都是合法的：A. mov ax,bx 表示将BX寄存器中的值拷贝到AX寄存器中；B. mov ax,[bx] 表示将BX所指定的内存单元中的值读入AX寄存器中；D. mov ax,0 表示将AX寄存器中的值清零。

mov ax, 0095h mov ah, 95h add al, ah

A. 9680H    B. 968AH     C. 962AH      D. 952AH

指令的执行过程如下：

1、将0095h赋值给AX寄存器，此时AX的值为0095h； 2、将95h赋值给AH寄存器，此时AX的值为9595h； 3、将AL寄存器和AH寄存器的值相加(95h + 95h = 12Ah)，将结果存储在AL寄存器中，此时AX的值变为952Ah。

因此，选项D是正确答案。

A. 是16位结构的CPU，其能够一次性处理传输暂时存储的信息的最大长度是16bit

B. 采用“段地址×16 + 偏移地址 = 物理地址”的方式生成存储单元的地址

C. 执行push指令和pop指令时，8086CPU从SS:SP中得到栈顶的地址

D. 在编程时，可将长度为1KB的一组地址连续，起始地址为32的倍数的内存单元当成栈空间来使用。

选项 D 中的错误在于“起始地址为32的倍数”，而实际上应该是“起始地址为16的倍数”。

在编程时，可以将一些内存单元用作堆栈空间。可以使用任何一个 16 位寄存器（如 SS）来存储堆栈的段地址，然后使用 SP 寄存器来跟踪堆栈指针。对于 8086 CPU，堆栈指针 SP 应该总是指向一个偶数地址。因此，堆栈的大小应该是偶数，并且堆栈的起始地址应该是 16 的倍数。因此，选项 D 中的“起始地址为32的倍数”是错误的。

正确的说法是：在编程时，可将长度为 1KB 的一组地址连续，起始地址为 16 的倍数的内存单元当成栈空间来使用。

A.0158H    B.014AH    C.0058H    D.004AH

正确答案是 D，即 004AH。因为“add al,85H”指令的含义是将 al 寄存器的值加上 85H，即 al=al+85H。计算 00C5H+85H=00CAH，而 al 只是 ax 的低 8 位，因此在 ax 中保持不变的是高 8 位 ah 的值（为 00H），而低 8 位 al 的值改变为 0CAH。因此，ax 的值为 0CA00H，即 004AH

A.用mov、add、sub等指令通过偏移地址访问data段中的数据前，应将data段的段地址放在ds中。

B.一个段，可以既是数据段，又是桟段。

C.一个段，不可以既是代码段，又是数据段。

D.一个段中的内容对CPU来说是指令还是数据，关键在于对相关寄存器的设置。

C.一个段，不可以既是代码段，又是数据段。是错误的说法。

在汇编语言中，一个段可以既是数据段，也可以是代码段。但是，同一时刻一个段只能是数据段或者代码段，不能同时是两种类型。

A.64Byte    B.64Kbit   C.1MB    D.64KB

 8086PC机一个段的最大长度为64KB (D)

A.任意时刻，SS:SP指向栈顶元素。

B.retf指令不会引起栈空间超界。

C.push和pop实质上是一种内存传送指令。

D.8086CPU的栈机制，没有对避免栈空间超界提供支持。                  

 B 栈空间自主管理

A.SS=1000H、SP=FFFEH               B.SS=0H、SP=FFFEH

C.SS=1000H、SP=0                       D.SS=2000H、SP=0

 而栈是空的，SP应该指向栈底的下一个位置20000，  D.SS=2000H、SP=0

A、 MOV AX,BX 

B、 MOV BX,AX 

C、 PUSH AX

POP BX

D、 MOV CX,AX 

MOV AX,BX

    MOV BX,CX 

XCHG是x86汇编语言中的一个指令，用于交换两个寄存器或内存单元的值。其作用是将两个操作数（可以是寄存器或内存单元）的值进行交换。

例如，执行指令"XCHG AX, BX"会交换AX和BX寄存器中的值。在执行该指令后，AX中包含原来BX的值，而BX中包含原来AX的值。

可以使用 MOV AX, BX 和 XCHG AX, BX 指令组合完成和 XCHG AX, BX 相同的功能，指令序列为：

MOV CX, AX MOV AX, BX MOV BX, CX

这个指令序列将 AX 和 BX 的值互换，实现了 XCHG AX, BX 相同的功能。

A、 CS               B、 DS               C、 SS               D、 ES

 堆栈是一种数据结构，用来存储程序中的临时数据和返回地址等信息。而堆栈段(segment)是指堆栈所在段，即存放堆栈的物理内存区域。堆栈段由堆栈段地址（Segment Address）和堆栈段偏移地址（Stack Offset）组成。堆栈的段地址由堆栈段寄存器（Stack Segment Register）来存储。

因此，答案是C、SS（Stack Segment Register）。

A、 BP              B、 SP               C、 SS               D、 IP

 堆栈指针（Stack Pointer）寄存器是用来指示当前堆栈的栈顶地址的寄存器。它指向当前堆栈顶部的下一个空闲单元。在访堆栈时，堆栈指针先减1，然后将数据压入堆栈中；在取出数据时，先从堆栈中取出数据，然后堆栈指针再加1。

因此，堆栈指针寄存器的名称是B、SP（Stack Pointer）。

A、 加1            B、 减1            C、 加2            D、 减2

 执行一次PUSH指令，SP寄存器将减2（D）。因为在8086CPU中，每个栈元素占用两个字节，所以在执行PUSH指令时，先将栈顶指针SP减去2，然后将数据写入到栈顶位置。

A、 加1            B、 减1            C、 加2            D、 减2

 执行一次POP指令，SP寄存器将加2（C）。因为在8086CPU中，每个栈元素占用两个字节，所以在执行POP指令时，先将栈顶元素弹出并写入到目标操作数中，然后将栈顶指针SP加上2，指向下一个栈元素。

A、 操作对象是字                                          B、 堆栈的长度是没有限制

C、 任何时刻，SS:SP指向栈顶元素            D、 堆栈位于内存中

B  个堆栈最大只能设置为64KB

A、 POP  AX             B、 POP  126CH                C、 PUSH  AL           D、 PUSH  AX,BX

 A  

A、 1MB           B、 1KB             C、 64KB           D、 64MB

 8086系统中，一个堆栈最大只能设置为64KB，因为8086只有16位的寻址能力，每个内存地址最大只能表示64KB的内存空间，而堆栈是存储在内存中的，所以一个堆栈的大小最大只能是64KB。所以答案是C、64KB。

A、MOV  SS,20000H

MOV  SP,21001H

B、MOV  AX,2000H

MOV  SS,AX

MOV  SP,1001H

C、 MOV  AX,2000H

MOV  SS,AX

MOV  SP,1002H

D、 MOV  AX,2000H

MOV  SS,AX

MOV  SP,1000H

 C SS需要用通用寄存器中转,栈空指向栈顶下一位置

A、 1FFFH                   B、1998H           C、 2002H                   D、1FFEH

PUSH指令将寄存器或内存单元中的数据压入堆栈中，同时SP的值减2，指向下一个空闲的堆栈单元。

执行指令"PUSH AX"后，将将AX寄存器的值压入堆栈中，同时SP的值减2。因此，最终SP的值应该是2000H-2=1FFEh。所以答案是D、1FFEH。

1000:0000   89 85 4C ED 38 7B F8 10 -29 8D 44 9D 3E 75 A8 20

若DS=1000H，AX=0，那么汇编指令“MOV   AL,[0008H]”执行完后AX 的值为

A、 0H         B、 2900H               C、 0029H                  D、 0010H

 在debug中，用“d 1000：0  0f”查看内存，结果如下。 1000:0000   89 85 4C ED 38 7B F8 10 -29 8D 44 9D 3E 75 A8 20

若DS=1000H，AX=0，那么汇编指令“MOV   AL,[0008H]”执行完后AX 的值为 D、 0010H。

汇编指令“MOV AL, [0008H]”是将偏移地址为0008H的数据读入AL寄存器中。由于DS=1000H，因此要访问的内存单元地址应该为DS:0008H，也就是10008H。根据给出的内存内容，可以知道10008H处存储的数值为10H，因此执行完“MOV AL, [0008H]”指令后，AL的值为10H，而AX寄存器的高位则保持不变，即为00H。

因此，AX的值为0010H。

1000:0000   89 85 4C ED 38 7B F8 10 -29 8D 44 9D 3E 75 A8 20

DS=1000H，AX=0，那么汇编指令“MOV   AX,[0008H]”执行完后AX 的值为

A、 1029H                 B、 298DH                 C、 2910H                  D、 8D29H

 C  

1000:0000   89 85 4C ED 38 7B F8 10 -29 8D 44 9D 3E 75 A8  20

1000:0010   79 87 C4 EF 25 66 F7 40 -A9 BD C4 5D 6E 7F A1 2B

1000:0020   81 15 4D ED 83 B7 8F 1A -89 7D B6 9C 3E 73 A2 21

执行前DS=0，AX=0，BX=0，那么执行下列汇编指令，完后AX 的值为（      ）

MOV  AX,1002H

MOV  DS,AX

MOV  AX,[0]

A、 8589H                 B、 8779H                  C、 1581H                  D、 8985H

C  DS:IP 1000:20 

1000:0000   89 85 4C ED 38 7B F8 10 -29 8D 44 9D 3E 75 A8  20

1000:0010   79 87 C4 EF 25 66 F7 40 -A9 BD C4 5D 6E 7F A1 2B

1000:0020   81 15 4D ED 83 B7 8F 1A -89 7D B6 9C 3E 73 A2 21

执行前DS=0，AX=0，BX=0，那么执行下列汇编指令，完后AX 的值为（      ）

MOV  AX,1000H

MOV  DS,AX

MOV  AX,[0]

A、 8589H                 B、 8779H                  C、 1581H                  D、 8985H

 A

B sp-2

A.栈空的时候，SP的值为FFFeH         B.栈满的时候，SP的值为0

C.这段栈空间的大小为4KB              D.使用这段栈空间，有可能会出现栈越界

 D. 使用这段栈空间，有可能会出现栈越界：由于栈是向下生长的，在使用栈的过程中，如果向栈中压入的数据超出了栈的大小，就会出现栈溢出（stack overflow）的情况，从而导致程序异常终止。因此，在使用这段栈空间时，有可能会出现栈越界的问题。

A.0      B.20000H       C.10000H         D.20010H

B 

A.逻辑地址     B.偏移地址    C.物理地址     D.段地址

CPU传递到地址总线上的地址是物理地址。

在使用分段机制的8086处理器中，CPU产生的地址有两个部分，一个是段地址，另一个是偏移地址，它们通过一定的计算得出最终的物理地址。但是，当CPU需要访问内存时，会将最终得到的物理地址直接传递到地址总线上，由内存控制器根据物理地址来确定要访问的实际内存单元。因此，CPU传递到地址总线上的地址是物理地址。

A.可将BX当成两个8位寄存器，在偏移地址范围为0~255时，可以用“mov ax,[bl]”来实现将内存中的数据读到ax中

B.可以用“byte ptr”实现将SI当成两个8位寄存器使用

C.可将AX、BX、CX、DX当成8个8位寄存器使用

D.AX、ah、al是不同的寄存器，指令“add al,bl”的执行不会影响AX的值

B 可以用“byte ptr”实现将SI当成两个8位寄存器使用。

在x86汇编语言中，可以使用“byte ptr”、“word ptr”、“dword ptr”等关键字作为指令操作数的前缀，以确定所需访问的数据类型。因此，可以使用“byte ptr”将SI寄存器视为单独的8位寄存器来使用。

例如，在8086处理器中，MOV AL，[SI]指令可以用来从存储在DS：SI处的内存单元中读取一个字节。如果想要让SI寄存器被当作两个8位寄存器来处理，可以这样编写指令：

这样就可以通过指定“BYTE PTR”前缀，让SI寄存器被视为两个独立的8位寄存器，分别对应着存储在DS：SI和DS：SI+1处的内存单元。

A.8086CPU有20根地址总线，它的寻址能力为1MB

B.一个物理地址可以对应多个段地址与偏移地址

C.因为段寄存器是16位，所以一个段最大为64KB

D.CPU内部有一个能合成20位地址的地址加法器

B选项与8086CPU寻址相关的说法是错误的。一个物理地址只能对应唯一的段地址与偏移地址。

A选项是正确的，8086CPU有20根地址总线，它的寻址能力为1MB。

C选项是正确的，因为8086CPU在实模式下采用分段机制，每个段最大可以寻址64KB的空间。

D选项是正确的，CPU内部有一个能合成20位地址的地址加法器，用于将段地址和偏移地址组合成物理地址。

以下说法是错误的：

B.一个物理地址可以对应多个段地址与偏移地址。

每个物理地址都只会对应唯一的一个段地址和偏移地址。由于8086CPU使用了分段寻址机制，因此同一个物理地址可能会被不同的段地址和偏移地址组合得到。但是反过来，一个物理地址只有唯一的一个值。

A、C、D三个选项的说法均正确：

A. 8086CPU有20根地址总线，它的寻址能力为1MB。其中，20根地址总线可以寻址2^20个内存单元，即1MB的内存空间。

C. 因为段寄存器是16位，所以一个段最大为64KB。由于使用分段机制时，一个段的大小由段寄存器的值决定，因此，使用16位的段寄存器时，一个段的大小最大为64KB。

D. CPU内部有一个能合成20位地址的地址加法器。在8086CPU中，物理地址由段地址和偏移地址组成，这两个部分经过地址加法器相加后形成20位物理地址。这个地址加法器可以将分段寻址的地址转换为实际物理地址。

mov sp,0

push ss

A.0      B.0fffeh       C.2        D.内存ss：0处的数据的值

 B

执行 mov sp, 0 指令后，SP寄存器的值被赋为0。

接着执行 push ss 指令，将SS寄存器中的值压入栈中。由于在8086CPU中，栈是向下生长的，所以压栈会使SP的值减2。因此，此时SP的值为-2（0xFFFF FFFEH）。

选项B：0fffeh即为上述计算得到的结果，因此答案为B。

A.此处用于存储系统时间，一直在自动更新

B.debug存在延时，第二次查看即可看到用e命令写入的数据

C.此处处于ROM空间，不可以被改变

D.此处处于显存空间，当屏幕刷新时，此处的数据被更新了

 C

A.4FC0：00E0    B.4CE0：2EE0    C.40CE：0F00    D.40C0：F0E0

 B 加起来

mov ax,017ch

add al,0b4h

A.0130H     B.0230H     C.012FH     D.022FH

A 只看低位 7c+b4

第4~6章

A.编译、加载、连接、执行        B.加载、编译、连接、执行

C.连接、编译、加载、执行        D.编译、连接、加载、执行

正确的答案是 D. 编译、连接、加载、执行。

下面是每个步骤的解释：

编译：首先，源程序需要通过编译器进行编译，将高级语言的源代码翻译成机器语言的目标代码。编译过程将源代码转化为可执行的二进制文件。

连接：连接器将编译生成的目标代码与其他必要的库函数或模块进行