单选题

第一章

PC机的最小信息单位是（）。

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

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

一个CPU的寻址能力是8KB，那么它的地址总线的宽度为（）位。

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

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

1个CPU的寻址能力为16KB，那么它的地址总线的宽度为（）位。

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

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

1MB的存储器的地址编号从（）到（）

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

L'adresse mémoire de 1 Mo est numérotée de 0 à 0xFFFFF H, car 1 Mo équivaut à 1024 Ko et 1 Ko équivaut à 1024 octets, donc 1 Mo équivaut à 1024 x 1024 octets, soit 1 048 576 octets. Chaque octet a besoin d'un numéro d'adresse, donc le numéro d'adresse mémoire de 1 Mo est de 0 à 1 048 575, qui est de 0x00000 à 0xFFFFF H en notation hexadécimale. Les plages d'adresses des options A, B et D sont toutes inférieures à 1 Mo, ce qui ne correspond pas à la situation réelle.

1 To correspond à ( ) octet.

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

1 To correspond à 1 billion d'octets (10 ^ 12 octets) et 1 octet correspond à 8 bits (c'est-à-dire 1 octet = 8 bits), donc 1 To est égal à 8 x 10 ^ 12 bits. Dans les ordinateurs, la puissance de 2 est une unité de mesure couramment utilisée, donc en convertissant 8 x 10 ^ 12 bits en une puissance de 2, vous pouvez obtenir 1 To égal à 2 ^ 40 octets. Par conséquent, la réponse est A. 2^40.

1 Mo correspond à ( ) octet.

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

1 Mo fait référence à 1 mégaoctet, où 1 mégaoctet est égal à 2 à la puissance 20, c'est-à-dire 2 ^ 20, donc 1 Mo est égal à 2 ^ 20 octets, et la réponse est C.

Les numéros d'adresse de la mémoire de 1 Ko sont de ( ) à ( )

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

Il y a 1024 unités de stockage dans 1 Ko de mémoire, et chaque unité de stockage occupe 1 octet, il y a donc 1024 numéros d'adresse au total. Le numéro d'adresse commençant à 0, le numéro d'adresse de cette mémoire est de 0 à 1023, exprimé de 0x000 à 0x3FF en hexadécimal. Par conséquent, l'option A est la bonne réponse. Les plages de numéros d'adresse des options B, C et D sont toutes au-delà de la plage de numéros d'adresse de 1 Ko de mémoire.

La mémoire de 1 Ko peut stocker ( ) bits

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

1 Ko de mémoire peut stocker 1024 octets et 1 octet est égal à 8 bits, donc 1 Ko de mémoire peut stocker 1024 × 8 = 8192 bits. La réponse est donc B.

1 Go est ( B ) Octet.

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

1 Go correspond à 2 puissance 30 octets, c'est-à-dire 2 ^ 30 octets. Parce que 1 Go est égal à 1024 Mo, 1 Mo est égal à 1024 Ko et 1 Ko est égal à 1024 octets, donc 1 Go est égal à 1024*1024*1024 octets, soit 2^30 octets.

La largeur du bus de données de 8086 est de 16, et pour lire 20 octets de données de la mémoire, 8086 doit lire ( ) fois au moins.

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

La largeur du bus de données du 8086 est de 16 et 16 bits de données peuvent être transmis à chaque fois, soit 2 octets. Pour lire 20 octets de données, 10 lectures de 2 octets sont nécessaires. Par conséquent, la réponse est C. 10.

Le 8386 a une largeur de bus de données de 32. Pour lire 20 octets de données de la mémoire, 8386 doit lire ( ) fois au moins.

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

La largeur du bus de données du 8386 est de 32 et 32 bits (4 octets) de données peuvent être transmis à chaque fois. Pour lire 20 octets de données, 5 transferts sont nécessaires, soit 20 octets ÷ 4 octets/temps = 5 fois. La réponse est donc D.

En mémoire, les données et les programmes sont stockés sous la forme de _______.

A. Binaire B. Octal C. Décimal D. Hexadécimal

A En mémoire, les données et les programmes sont généralement stockés sous forme binaire. En effet, toutes les données et instructions d'un ordinateur sont représentées sous forme binaire, c'est-à-dire des nombres binaires composés de 0 et de 1. La mémoire de l'ordinateur ne peut stocker que des nombres binaires, de sorte que les données et les programmes doivent être stockés en mémoire sous forme binaire. Bien que d'autres bases puissent être utilisées pour représenter des données et des instructions dans la programmation, elles doivent toutes être converties sous forme binaire avant de pouvoir être exécutées dans l'ordinateur. Par conséquent, le binaire est le système de numération le plus élémentaire des ordinateurs.

La largeur du bus d'adresse du 8086CPU est de 20 bits et la largeur du bus de données est de 16 bits, de sorte que la capacité d'adressage du 8086CPU est ( ).

A. 64 Ko B. 1 Mo C. 1 Go D. Incertain

La largeur du bus d'adresse du B 8086CPU est de 20 bits et le nombre d'adresses pouvant être adressées est de 2 puissance 20, soit 1 Mo.

La largeur du bus d'adresse du 80386CPU est de 32, et la capacité d'adressage du 80386CPU est ( ).

A.64 Ko B.1024 Ko C.16 Mo D.4096 Mo

La largeur du bus d'adresse du 80386CPU est de 32, et l'espace d'adressage physique qui peut être adressé est de 2 puissance 32, c'est-à-dire 4 Go. Par conséquent, la capacité d'adressage du 80386CPU est D. 4096MB.

Pour lire 1024 octets de données de la mémoire, le processeur 80386 doit lire au moins 256 fois, puis la largeur du bus de données de 80386 est de ( ) bits.

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

La largeur du bus de données du processeur 80386 est de 32 bits.

1024 octets de données sont lus à partir de la mémoire et la largeur de données de chaque lecture est de 1 octet, il doit donc être lu 1024 fois.

La largeur du bus de données du processeur 80386 est de 32 bits et 4 octets peuvent être transmis à chaque fois, de sorte que 4 octets de données peuvent être lus à chaque fois. Par conséquent, il doit être lu 1024 fois, c'est-à-dire qu'il doit transmettre 1024 * 1 octet de données, un total de 1024 * 1/4 = 256 fois.

En 8086, une unité de mot peut stocker ( ) bits.

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

8086 est un processeur 16 bits et une unité de mots peut stocker 16 bits, donc la réponse est C.16.

Combien d'unités de stockage contient une mémoire de 1 Ko ? Combien de bits binaires peuvent être stockés ? ( )

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

Une mémoire de 1 Ko contient 1024 emplacements de mémoire car 1 Ko équivaut à 1024 octets. Chaque octet est composé de 8 bits binaires, donc une mémoire de 1 Ko peut stocker 8 x 1024 = 8192 bits binaires. Par conséquent, la réponse est l'option D, c'est-à-dire qu'une mémoire de 1 Ko contient 1024 cellules de mémoire, qui peuvent stocker 8192 bits binaires.

Chapitre 2 ~ 3

En Debug, vérifier la mémoire avec "d 075A : 110 11F", les résultats sont les suivants :

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

Ensuite, l'adresse correspondant aux données de police 00B8H est ( ).

A. 076A : 11 B. 076A : 16 C. 076B : 0 D. Incertain

C cs+ip 075a+0110=076b, le 0ème

L'adresse de segment donnée est 1234H et la plage d'adressage du 8086CPU est _________ (adresse physique) uniquement en modifiant l'adresse de décalage.

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

L'adresse de décalage dans le 8086CPU est une valeur de 16 bits, qui doit être ajoutée à l'adresse de segment pour obtenir l'adresse physique. Par conséquent, uniquement lorsque l'adressage est effectué en modifiant l'adresse de décalage, la plage de l'adresse physique dépend de la valeur du registre de segment.

Dans cette question, l'adresse donnée est 1234H, qui n'est adressée qu'en changeant l'adresse de décalage, ce qui signifie que le registre DS (ou ES, SS, CS) est utilisé comme registre de segment. Parce qu'en mode réel, la valeur du registre de segment est décalée vers la gauche de 4 bits en tant qu'adresse de segment, et l'adresse de décalage peut être ajoutée pour obtenir le physique.

La plage de changement d'adresse de décalage est de 0 à FFFFH, donc :

L'adresse physique est limitée à 12340H (l'adresse de segment est 1234H, plus l'adresse de décalage 0H) ;

La limite supérieure de l'adresse physique est 2233FH (l'adresse est 1234H, plus l'adresse de décalage FFFFH).

Par conséquent, l'option C : 12340H~2233FH est correcte.

Étant donné l'adresse de segment 101H, uniquement en changeant l'adressage d'adresse de décalage, le 8086CPU peut adresser l'unité de mémoire dont l'adresse est ().

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

C 1010+0~FFFF=1010~1100F

Parmi les registres suivants, ( ) est un registre 8 bits.

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

Parmi les registres suivants, B. BL est un registre 8 bits.

Parmi les registres suivants, ( ) est un registre 16 bits

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

Parmi les registres suivants, A. AX est un registre 16 bits.

Laquelle des déclarations suivantes est correcte ( )

A. Le registre AX ne peut pas être divisé en deux registres 8 bits

B. Le registre BP ne peut pas être divisé en deux registres 8 bits

C, CS peut être divisé en deux registres 8 bits

D. PSW est un registre à usage général qui peut stocker des données générales

Laquelle des affirmations suivantes est correcte : B

B. Le registre BP ne peut pas être divisé en deux registres 8 bits

Le registre BP (Base Pointer) est un registre 16 bits et ne peut pas être divisé en deux registres 8 bits. Il est généralement utilisé pour stocker l'adresse de base du cadre de pile.

A. Le registre AX peut être divisé en deux registres 8 bits. Le registre AX est un registre 16 bits, mais il peut être divisé en deux registres 8 bits, AH (haut) et AL (bas).

C. Le registre CS ne peut pas être divisé en deux registres 8 bits. Le registre CS (Code Segment) est un registre de 16 bits utilisé pour stocker l'adresse de début du segment de code de l'instruction en cours d'exécution.

D. PSW (Program Status Word) n'est pas un registre à usage général, c'est un registre spécial utilisé pour stocker les informations d'état du programme, telles que les bits d'indicateur, etc. Il ne peut pas être utilisé pour stocker des données générales.

Dans les instructions suivantes, la mauvaise instruction est ( ).

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

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

La mauvaise commande est :

C、 MOV AL,1000

Cette instruction essaie de déplacer la valeur immédiate 1000 dans le registre AL, mais AL est un registre 8 bits et ne peut pas contenir la valeur immédiate 16 bits 1000. La bonne façon de l'écrire devrait être d'utiliser une taille de registre appropriée ou une valeur immédiate effective.

La plage de valeurs du registre à huit bits AL est de 0 à 255 (FFFF H)

Dans les instructions suivantes, la mauvaise instruction est ( ).

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

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

B MOV BX,AL est une instruction erronée. Comme BX est un registre 16 bits et AL est un registre 8 bits, il n'est pas possible de déplacer directement la valeur de AL dans BX. La manière correcte devrait être d'utiliser le registre AX comme intermédiaire pour déplacer d'abord la valeur de AL vers AX, puis de déplacer la valeur de AX vers BX.

L'instruction correcte doit être MOV AX, AL, puis MOV BX, AX. Déplacez d'abord la valeur de AL vers AX, puis déplacez la valeur de AX vers BX

Parmi les instructions suivantes, l'instruction correcte est ( ).

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

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

A、 MOV AX,100

Cette instruction déplace la valeur immédiate 100 dans le registre AX, ce qui fonctionne.

Après l'exécution des 5 instructions suivantes, combien de fois le CPU modifie-t-il l'IP ? ( )

mov hache, 2000H

boîte de mouvement, 3000h

ajouter hache, bx

sous-bx, bx

etc.

A, 5 B, 6 C, 7 D, incertain

Lors de l'exécution de l'instruction, le CPU modifiera constamment la valeur de IP pour pointer sur la prochaine instruction à exécuter.

Lorsque la première instruction mov ax, 2000H est exécutée, l'adresse de la prochaine instruction à exécuter sera stockée dans le registre IP. A ce moment, l'adresse pointée par IP est l'adresse de la deuxième instruction, à savoir mov bx, 3000h.

Lorsque la deuxième instruction mov bx, 3000h est exécutée, l'adresse de la prochaine instruction à exécuter sera stockée dans le registre IP. A ce moment, l'adresse pointée par IP est l'adresse de la troisième instruction, à savoir add ax, bx.

Lorsque la troisième instruction add ax, bx est exécutée, l'adresse de la prochaine instruction à exécuter sera stockée dans le registre IP. A ce moment, l'adresse pointée par IP est l'adresse de la quatrième instruction, à savoir sub bx, bx.

Lorsque la quatrième sous-instruction bx, bx est exécutée, l'adresse de la prochaine instruction à exécuter sera stockée dans le registre IP. A ce moment, l'adresse pointée par IP est l'adresse de la cinquième instruction, à savoir jmp bx.

Lors de l'exécution de la cinquième instruction jmp bx, l'adresse de la prochaine instruction à exécuter sera stockée dans le registre IP. A ce moment, l'adresse pointée par IP est l'adresse stockée dans bx, qui est l'adresse de la deuxième instruction , à savoir mov bx, 3000h . Cependant, la valeur de bx est déjà 0 à ce moment, donc le programme bouclera à l'infini et ne modifiera plus la valeur de IP.

Ainsi, après avoir exécuté ces 5 instructions, le CPU modifiera l'IP 6 fois.

Le registre de segment de code est ()

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

Le registre de segment de code est CS (Code Segment Register) Le registre CS stocke l'adresse de segment où se trouve le code de programme actuel et est utilisé pour pointer vers le segment de code de programme que la CPU doit exécuter. Le programme commence par la première instruction pointée par le registre CS, et les instructions sont exécutées séquentiellement jusqu'à la fin du programme.

Le registre de pointeur d'instruction est ()

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

Le registre du pointeur d'instruction est IP (Instruction Pointer). L'adresse de la prochaine instruction à exécuter est stockée dans le registre IP. Une fois que le CPU a exécuté une instruction, il ira automatiquement au registre IP pour lire l'adresse de l'instruction suivante, puis poursuivra son exécution.

En débogage, la commande ( ) est utilisée pour afficher et modifier le contenu des registres de la CPU.

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

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

在debug中，查看内存中的内容是（）命令。

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

D

在debug中，修改内存中的内容是（）命令。

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

B

在debug中，执行CS、IP指向的内存单元处的指令是（）命令。

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

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

存储单元45A0：7CB9H的物理地址为（）

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

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

8086CPU中，任意时刻，CPU将（）指向的内容当作指令来执行。

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

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

下列关于Debug的说法，错误的是（）。

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

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

C

对于8086CPU，错误的指令是（）。

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寄存器中的值清零。

以下指令执行后，寄存器ax的值为（）。

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

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

Le processus d'exécution de la commande est le suivant :

1. Attribuez 0095h au registre AX et la valeur de AX est 0095h ;
2. Attribuez 95h au registre AH et la valeur de AX est 9595h ;
3. Ajoutez les valeurs du registre AL et du registre AH ( 95h + 95h = 12Ah), stocker le résultat dans le registre AL, et la valeur de AX devient 952Ah à ce moment.

Par conséquent, l'option D est la bonne réponse.

Concernant le 8086CPU, laquelle des affirmations suivantes est fausse ( ).

A. Il s'agit d'un processeur avec une structure de 16 bits et la longueur maximale des informations stockées temporairement pouvant être traitées et transmises en même temps est de 16 bits.

B. Utilisez la méthode "adresse de segment × 16 + adresse de décalage = adresse physique" pour générer l'adresse de l'unité de stockage

C. Lors de l'exécution de l'instruction push et de l'instruction pop, le 8086CPU obtient l'adresse du haut de la pile de SS:SP

D. Lors de la programmation, un groupe d'adresses continues d'une longueur de 1 Ko et une unité de mémoire dont l'adresse de début est un multiple de 32 peuvent être utilisés comme espace de pile.

L'erreur dans l'option D réside dans "l'adresse de départ est un multiple de 32", mais elle devrait en fait être "l'adresse de départ est un multiple de 16".

Lors de la programmation, certains emplacements de mémoire peuvent être utilisés comme espace de pile. Tout registre 16 bits (tel que SS) peut être utilisé pour stocker l'adresse de segment de la pile, et le registre SP peut être utilisé pour garder une trace du pointeur de pile. Pour la CPU 8086, le pointeur de pile SP doit toujours pointer vers une adresse paire. Par conséquent, la taille de la pile doit être un nombre pair et l'adresse de départ de la pile doit être un multiple de 16. Par conséquent, "l'adresse de départ est un multiple de 32" dans l'option D est erronée.

L'énoncé correct est : Lors de la programmation, un groupe d'unités de mémoire d'une longueur de 1 Ko et d'adresses continues et dont l'adresse de début est un multiple de 16 peut être utilisé comme espace de pile.

A ce moment, la valeur de ax est 00C5H, quelle est la valeur de ax après avoir exécuté "add al,85H" ? ( )

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

La bonne réponse est D, qui est 004AH. Parce que la signification de l'instruction "add al,85H" est d'ajouter 85H à la valeur du registre al, c'est-à-dire al=al+85H. Calculez 00C5H+85H=00CAH, et al n'est que les 8 bits inférieurs de ax, donc ce qui reste inchangé dans ax est la valeur des 8 bits supérieurs ah (00H), tandis que la valeur des 8 bits inférieurs al passe à 0CAH. Par conséquent, la valeur de ax est 0CA00H, soit 004AH

En ce qui concerne le concept de "segment" en langage assembleur, lequel des énoncés suivants est faux ( ).

A. Avant d'utiliser mov, add, sub et d'autres instructions pour accéder aux données du segment de données via l'adresse de décalage, l'adresse de segment du segment de données doit être placée dans ds.

B. Un segment peut être à la fois un segment de données et un segment de stub.

C. Un segment ne peut pas être à la fois un segment de code et un segment de données.

D. Que le contenu d'un segment soit une instruction ou des données pour la CPU, la clé réside dans le réglage des registres pertinents.

C. Un segment ne peut pas être à la fois un segment de code et un segment de données. C'est une fausse déclaration.

En langage assembleur, un segment peut être à la fois un segment de données et un segment de code. Cependant, un segment ne peut être qu'un segment de données ou un segment de code en même temps, et ne peut pas être les deux types en même temps.

La longueur maximale d'un segment de 8086PC est ( ).

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

La longueur maximale d'un segment de 8086PC est de 64 Ko (D)

La déclaration suivante concernant le mécanisme de pile du 8086CPU est fausse ( ).

A. À tout moment, SS:SP pointe vers l'élément supérieur de la pile.

L'instruction B.retf ne fera pas dépasser les limites de l'espace de la pile.

C.push et pop sont essentiellement une instruction de transfert de mémoire.

D. Le mécanisme de pile du 8086CPU ne permet pas d'éviter le dépassement de l'espace de pile.

Gestion autonome de l'espace B stack

Définissez l'espace mémoire de 10000H à 1FFFFH comme segment de pile, et la pile d'état initial est vide.À ce moment, les valeurs de SS et SP sont ( ).

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

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

Et la pile est vide, SP doit pointer vers la position suivante 20000 en bas de la pile, D.SS=2000H, SP=0

完成同指令XCHG AX ,BX 相同功能的指令或指令序列是（）

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。

Par conséquent, le nom du registre de pointeur de pile est B, SP (Stack Pointer).

Exécutez une instruction PUSH, le registre SP ( )

A, plus 1 B, moins 1 C, plus 2 D, moins 2

Exécutez une instruction PUSH et le registre SP sera décrémenté de 2 (D). Parce que dans le 8086CPU, chaque élément de pile occupe deux octets, donc lors de l'exécution de l'instruction PUSH, soustrayez d'abord 2 du pointeur supérieur de pile SP, puis écrivez les données en haut de la pile.

Exécutez une instruction POP, le registre SP ( )

A, plus 1 B, moins 1 C, plus 2 D, moins 2

Exécutez une instruction POP, le registre SP sera incrémenté de 2 (C). Parce que dans le 8086CPU, chaque élément de la pile occupe deux octets, donc lorsque l'instruction POP est exécutée, l'élément supérieur de la pile est d'abord sauté et écrit dans l'opérande cible, puis le pointeur supérieur SP de la pile est ajouté pour pointer vers l'élément de pile suivant.

Concernant la pile 8086CPU, laquelle des déclarations suivantes est incorrecte ( )

A. L'objet opération est un mot B. La longueur de la pile est illimitée

C. A tout moment, SS:SP pointe vers l'élément supérieur de la pile D. La pile est en mémoire

Les piles B ne peuvent être définies que sur un maximum de 64 Ko

L'instruction suivante est correcte ( )

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

UN

Dans le système 8086, quelle est la valeur maximale d'une pile ? ()

A、 1 Mo B、 1 Ko C、 64 Ko D、 64 Mo

Dans le système 8086, une pile ne peut être définie que sur un maximum de 64 Ko, car le 8086 n'a qu'une capacité d'adressage de 16 bits, et chaque adresse mémoire ne peut représenter qu'un maximum de 64 Ko d'espace mémoire, et la pile est stockée en mémoire. , donc la taille d'une pile Le maximum ne peut être que de 64 Ko. La réponse est donc C, 64 Ko.

Si vous souhaitez définir l'espace entre 20000h et 21001h sous forme de pile, la pile d'état initial est vide, vous devez sélectionner le segment de programme ().

A、MOV SS,20000H

MOVSP,21001H

B、MOV AX,2000H

MOV SS, AXE

MOV SP,1001H

C、 MOUVEMENT AXE, 2000H

MOV SS, AXE

MOUV SP,1002H

D、 MOUVEMENT AXE, 2000H

MOV SS, AXE

MOUV SP, 1000H

C SS doit utiliser des registres à usage général pour le transfert, et la pile vide pointe vers la position suivante en haut de la pile

Soit la valeur initiale de SP soit 2000H, après avoir exécuté la commande "PUSH AX", la valeur de SP est ()

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

L'instruction PUSH pousse les données du registre ou de l'unité de mémoire dans la pile, et en même temps, la valeur de SP est décrémentée de 2, pointant vers l'unité de pile libre suivante.

Après l'exécution de l'instruction "PUSH AX", la valeur du registre AX sera poussée sur la pile et la valeur de SP sera décrémentée de 2. Par conséquent, la valeur finale de SP devrait être 2000H-2=1FFEh. La réponse est donc D, 1FFEH.

En debug, vérifier la mémoire avec "d 1000:0 0f", le résultat est le suivant.

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

Si DS=1000H, AX=0, alors la valeur de AX après l'exécution de l'instruction d'assemblage "MOV AL,[0008H]" est

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

En debug, vérifier la mémoire avec "d 1000:0 0f", le résultat est le suivant. 1000:0000 89 85 4C ED 38 7B F8 10 -29 8D 44 9D 3E 75 A8 20

Si DS=1000H, AX=0, alors la valeur de AX après l'exécution de l'instruction d'assemblage "MOV AL, [0008H]" est D, 0010H.

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

因此，AX的值为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 AX,[0008H]”执行完后AX 的值为

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

C

在debug中，用“d 1000：0 0f”查看内存，结果如下。

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

在debug中，用“d 1000：0 0f”查看内存，结果如下。

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

有以下几条指令（debug下的指令格式）：
      mov ax,1000
         mov ss,ax
         mov sp,0100
         mov ax,5CCA
         push ax
      指令“push ax”执行后，sp的值和修改的内存单元的地址是（   ）。
A. 0100H，1000H：0100H      B. 00feH，1000H：00feH    C. 0100，1000：0100    D. 98，1000：98

B sp-2

如果将10000H~1FFFFH这段内存空间当做是栈空间，假设SS=1000H，则下列说法正确的是（）。

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

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

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

给定段地址为1001h，则8086CPu可以寻址到物理地址为（）的内存单元。

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

B

CPU传递到地址总线上的地址是（）。

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

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

Dans le processeur 8086 utilisant le mécanisme de segmentation, l'adresse générée par le CPU comporte deux parties, l'une est l'adresse de segment et l'autre est l'adresse de décalage.Ils obtiennent l'adresse physique finale grâce à certains calculs. Cependant, lorsque le CPU doit accéder à la mémoire, il transfère directement l'adresse physique finalement obtenue au bus d'adresse, et le contrôleur de mémoire détermine l'unité de mémoire réelle à laquelle accéder en fonction de l'adresse physique. Par conséquent, les adresses que la CPU transmet au bus d'adresses sont des adresses physiques.

Concernant plusieurs registres du 8086CPU, l'énoncé correct est ( ).

A. BX peut être considéré comme deux registres 8 bits. Lorsque la plage d'adresses de décalage est comprise entre 0 et 255, vous pouvez utiliser "mov ax, [bl]" pour lire les données de la mémoire dans ax

B. Vous pouvez utiliser "byte ptr" pour utiliser SI comme deux registres 8 bits

C. AX, BX, CX, DX peuvent être utilisés comme 8 registres 8 bits

D. AX, ah et al sont des registres différents, et l'exécution de l'instruction "add al, bl" n'affectera pas la valeur de AX

B peut utiliser "byte ptr" pour réaliser l'utilisation de SI comme deux registres 8 bits.

Dans le langage d'assemblage x86, des mots clés tels que "byte ptr", "word ptr" et "dword ptr" peuvent être utilisés comme préfixe de l'opérande d'instruction pour déterminer le type de données auquel accéder. Par conséquent, "byte ptr" peut être utilisé pour traiter le registre SI comme un registre 8 bits séparé.

Par exemple, dans le processeur 8086, l'instruction MOV AL,[SI] peut être utilisée pour lire un octet à partir de l'emplacement mémoire stocké dans DS:SI. Si vous voulez que le registre SI soit traité comme deux registres 8 bits, vous pouvez écrire l'instruction comme ceci :
MOV AL, [BYTE PTR SI]
MOV AH, [BYTE PTR SI + 1]
De cette façon, le registre SI peut être considéré comme deux registres 8 bits indépendants en spécifiant le préfixe "BYTE PTR", correspondant aux unités de mémoire stockées à DS : SI et DS : SI+1.

Laquelle des déclarations suivantes relatives à l'adressage 8086CPU est erronée ( ).

A.8086CPU a 20 bus d'adresses et sa capacité d'adressage est de 1 Mo

B. Une adresse physique peut correspondre à plusieurs adresses de segment et adresses de décalage

C. Étant donné que le registre de segment est de 16 bits, la taille maximale d'un segment est de 64 Ko

D. Il y a un additionneur d'adresses à l'intérieur du CPU qui peut synthétiser des adresses 20 bits

L'affirmation selon laquelle l'option B est liée à l'adressage du processeur 8086 est fausse. Une adresse physique ne peut correspondre qu'à une adresse de segment unique et une adresse d'offset.

L'option A est correcte, 8086CPU a 20 bus d'adresses et sa capacité d'adressage est de 1 Mo.

L'option C est correcte, car le 8086CPU utilise un mécanisme de segmentation en mode réel, et chaque segment peut adresser un maximum de 64 Ko d'espace.

L'option D est correcte. Il existe un additionneur d'adresses à l'intérieur de la CPU qui peut synthétiser des adresses 20 bits, qui est utilisé pour combiner les adresses de segment et les adresses de décalage en adresses physiques.

Les affirmations suivantes sont fausses :

B. Une adresse physique peut correspondre à plusieurs adresses de segment et adresses de décalage.

Chaque adresse physique ne correspondra qu'à une adresse de segment et une adresse de décalage uniques. Étant donné que le processeur 8086 utilise un mécanisme d'adressage segmenté, la même adresse physique peut être obtenue en combinant différentes adresses de segment et adresses de décalage. Mais à l'inverse, une adresse physique n'a qu'une seule valeur.

Les trois options A, C et D sont correctes :

A. 8086CPU a 20 bus d'adresses et sa capacité d'adressage est de 1 Mo. Parmi eux, 20 bus d'adresses peuvent adresser 2^20 unités de mémoire, soit 1 Mo d'espace mémoire.

C. Étant donné que le registre de segment est de 16 bits, la taille maximale d'un segment est de 64 Ko. Lors de l'utilisation du mécanisme de segmentation, la taille d'un segment est déterminée par la valeur du registre de segment. Par conséquent, lors de l'utilisation d'un registre de segment de 16 bits, la taille maximale d'un segment est de 64 Ko.

D. Il y a un additionneur d'adresses à l'intérieur du CPU qui peut synthétiser des adresses 20 bits. Dans le 8086CPU, l'adresse physique est composée d'une adresse de segment et d'une adresse de décalage, et ces deux parties sont ajoutées par un additionneur d'adresse pour former une adresse physique de 20 bits. Cet additionneur d'adresses convertit les adresses segmentées en adresses physiques réelles.

Une fois les instructions suivantes exécutées, la valeur de SP est ( ).

mov sp,0

pousser ss

A.0 B.0fffeh C.2 D. Mémoire ss : la valeur de la donnée à 0

B

Après l' exécution de l'instruction mov sp, 0, la valeur du registre SP est affectée à 0.

Exécutez ensuite push ssl'instruction pour pousser la valeur dans le registre SS sur la pile. Étant donné que la pile grandit vers le bas dans le 8086CPU, pousser la pile diminuera la valeur de SP de 2. Par conséquent, la valeur de SP à ce moment est -2 (0xFFFF FFFEH).

Option B : 0fffeh est le résultat du calcul ci-dessus, donc la réponse est B.

Utilisez la commande debug e pour écrire des données sur b810:0010, puis utilisez la commande d pour vérifier et constater qu'il n'y a pas de données nouvellement écrites sur b810:0010, la raison est ( ).

A. Ceci est utilisé pour stocker l'heure système, qui a été automatiquement mise à jour

B. Il y a un retard dans le débogage et vous pouvez voir les données écrites par la commande e lorsque vous la vérifiez pour la deuxième fois

C. Ceci est dans l'espace ROM et ne peut pas être modifié

D. C'est dans l'espace mémoire vidéo. Lorsque l'écran est actualisé, les données ici sont mises à jour

C

Dans 8086CPU, si l'adresse physique d'une certaine unité de mémoire est 4FCE0, son adresse de segment et son adresse de décalage ne doivent pas être ( ).

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

B s'additionne

Une fois les instructions suivantes exécutées, la valeur du registre AX est ( ).

mov hache, 017ch

ajouter al, 0b4h

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

A ne regarde que le bit bas 7c+b4

Chapitre 4 ~ 6

Combien d'étapes un programme source d'assemblage passe-t-il de son écriture à son exécution par le CPU ? ( )

A. Compiler, charger, lier, exécuter B. Charger, compiler, lier, exécuter

C. Lier, compiler, charger, exécuter D. Compiler, lier, charger, exécuter

La bonne réponse est D. Compiler, lier, charger, exécuter.

Voici une explication de chaque étape :

Compilation : Tout d'abord, le programme source doit être compilé par un compilateur, qui traduit le code source du langage de haut niveau en code objet du langage machine. Le processus de compilation convertit le code source en binaires exécutables.

Lien : l'éditeur de liens relie le code objet compilé à d'autres fonctions ou modules de bibliothèque nécessaires pour générer le fichier exécutable final. L'éditeur de liens résout la relation de référence entre les différents modules et génère toutes les informations de symbole et d'adresse requises par le fichier exécutable.

Chargement : le fichier exécutable est chargé en mémoire et le système d'exploitation est chargé de lire le fichier du disque dur à l'emplacement approprié de la mémoire. Pendant le processus de chargement, le système d'exploitation alloue de l'espace mémoire pour le fichier exécutable et charge les instructions et les données du programme dans les adresses mémoire correspondantes.

Exécution : Une fois le programme chargé en mémoire, la CPU commence à exécuter le programme. La CPU exécute les instructions du programme une par une dans l'ordre des instructions, lit les données de la mémoire dans le registre pour le calcul, puis réécrit le résultat dans la mémoire ou le registre.

Par conséquent, la compilation, la liaison, le chargement et l'exécution sont la séquence correcte d'étapes depuis l'écriture du programme source d'assemblage jusqu'à son exécution finale par le CPU.

En ce qui concerne la compilation et la liaison, la mauvaise déclaration est ( ).

A. Le fichier *.obj généré par la compilation ne peut pas être exécuté directement sous le système d'exploitation

B. Il n'y a pas de directive dans le fichier *.exe généré par la connexion

C. La compilation peut vérifier les erreurs de syntaxe

D. Les connexions peuvent vérifier les erreurs de logique

La mauvaise déclaration est D. .

expliquer:

A. Les fichiers *.obj compilés ne peuvent pas être exécutés directement sous le système d'exploitation : Il s'agit de l'instruction correcte. Le compilateur compile le code source en code objet (fichier *.obj), qui contient des instructions et des données en langage machine, mais n'a pas encore terminé le processus de liaison final, il ne peut donc pas être exécuté directement sous le système d'exploitation.

B. Il n'y a pas de directives dans le fichier *.exe généré par le lien : lorsque l'éditeur de liens lie le code objet dans un fichier exécutable, il peut convertir des directives (telles que celles utilisées pour les points d'entrée et l'initialisation du programme) en instructions machine réelles. Ces directives sont présentes dans l'exécutable final.

C. La compilation peut vérifier les erreurs de syntaxe : il s'agit de l'instruction correcte. Lorsque le compilateur compile le code source, il effectue une analyse lexicale et une analyse syntaxique pour vérifier les erreurs de syntaxe dans le code. Si une erreur de syntaxe est trouvée, le compilateur signalera l'erreur et arrêtera le processus de compilation.

D. Les connexions peuvent détecter des erreurs logiques : il s'agit d'une fausse déclaration. La tâche principale de l'éditeur de liens est de résoudre la relation de référence entre les modules, de combiner le code objet de chaque module et de générer un fichier exécutable. Les éditeurs de liens n'impliquent pas la vérification des erreurs logiques, qui ne sont généralement pas détectées avant l'exécution du programme.

Par conséquent, la déclaration erronée est qu'il n'y a pas de directive dans le fichier *.exe généré par B. connection.

Il y a deux segments définis dans l'ordre suivant dans le programme source :
       un segment
                   db 1,2,3,4,5,6,7,8
         a se termine
         b segment
                   db 1,2,3,4,5,6,7 ,8
         b se termine
      Si l'adresse physique des données "1" dans le segment a est X, alors l'adresse physique des données "1" dans le segment b est ( ).
       A. X B. X+1 C. X+16 D. X+64

C 段最少16B db字节 dw字 dd双字

Debug加载程序后，假设PSP的段地址为SA，偏移地址为0，则程序的起始地址是（）。

A. SA×16H B. SA×16 C. (SA+16H)×16H D. (SA+16)×16

在x86架构的实模式下，PSP（Program Segment Prefix）是程序段前缀，它位于内存段地址的开头，用于存储有关程序的信息。偏移地址为0的位置处于PSP的开始位置。

PSP的段地址为SA，偏移地址为0，表示PSP的物理地址为SA×16（由于段地址乘以16后才是物理地址）。由于偏移地址为0，程序的起始地址即为PSP的物理地址。

因此，答案是 B. SA×16

下列关于汇编语言源程序的说法，错误的是（）

A. 一个汇编语言源程序从写出到执行需经过.编写.asm文件→将.asm文件编译为.obj文件→将.obj文件连接成.exe文件→.exe文件执行。

B. 在汇编语言源程序中，包含三种指令：汇编指令、伪指令、其他符号。

C. 在汇编语言源程序中，不由编译器执行的伪指令有对应的机器指令。

D. 在汇编语言源程序中，汇编指令是有对应机器码的指令，其所对应的机器指令由CPU执行。

错误的说法是 C. 在汇编语言源程序中，不由编译器执行的伪指令有对应的机器指令。

解释：

A. 一个汇编语言源程序从写出到执行的过程通常包括将汇编语言源文件（.asm）编译为目标文件（.obj）和将目标文件连接为可执行文件（.exe），最后执行可执行文件。因此，选项 A 描述了正确的过程顺序。

B. 汇编语言源程序中包含三种指令：汇编指令（对应机器指令）、伪指令（用于汇编过程控制和数据定义等，不生成机器指令）和其他符号（如标签、变量名等）。这是正确的说法。

C. 在汇编语言源程序中，伪指令通常由汇编器或编译器执行，它们不会生成对应的机器指令。伪指令用于提供汇编过程中的指令控制、宏展开和数据定义等功能。因此，错误的说法是伪指令有对应的机器指令。

D. Les instructions d'assemblage sont des instructions avec des codes machine correspondants, et les instructions machine correspondantes sont exécutées par la CPU. C'est la bonne déclaration.

En résumé, il est faux de dire que C. Dans un programme source en langage assembleur, les pseudo-instructions qui ne sont pas exécutées par le compilateur ont des instructions machine correspondantes.

Le compilateur d'assemblage "masm.exe" est stocké dans le répertoire "c.\masm". Un programme source d'assemblage "t1.asm" est stocké dans le répertoire racine du disque c. Après être entré dans le répertoire "c.\masm" sous DOS, comment compiler "t1.asm" de manière simplifiée ? ( )

A. masm t1 B. masm t1 ; C. masm c.\t1 D. masm c.\t1 ;

C

mov hache, 4c00h

Int 21h

Une fois que le CPU a exécuté ces deux instructions, ( ).

Revenez à DOS B. Revenez à DEBUG C. Revenez à COMMOND D. Aucune des trois premières options n'est correcte

Après avoir exécuté ces deux instructions, le CPU reviendra sous DOS.

expliquer:

La fonction de ces deux instructions est d'appeler la fonction système du DOS. Plus précisément, "mov ax, 4c00h" stocke 4c00h (32768 en décimal) dans le registre AX, puis "Int 21h" exécute l'instruction d'interruption, transférant le contrôle au gestionnaire d'interruption DOS, qui est basé sur la valeur dans AX. action.

Dans ce cas, DOS utilise la fonction de sortie avec le code de fonction 4c, et la valeur dans AX est le code de sortie. Étant donné que le code de sortie donné dans l'instruction était 4c00h, le processeur reviendra au DOS avec ce code de sortie comme état de retour.

Par conséquent, la bonne réponse est A. Revenez à DOS.

Laquelle des déclarations suivantes est correcte ( ).

A. Les informations contenues dans le segment de code seront exécutées en tant qu'instructions

B. CS : L'instruction pointée par l'IP doit avoir été exécutée par le CPU

C. En utilisant la commande t de Debug, une seule instruction d'assemblage peut être exécutée à la fois

D. L'association entre le segment et le registre de segment établi par "ASSUME" est gérée par le compilateur

L'instruction correcte est D. L'association entre le segment et le registre de segment établi par "ASSUME" doit être gérée par le compilateur.

expliquer:

R. Toutes les informations du segment de code ne sont pas exécutées en tant qu'instructions. Les segments de code contiennent des instructions et d'autres données telles que des constantes, des variables, etc. Le CPU détermine la prochaine instruction à exécuter en fonction des valeurs de CS (registre de segment de code) et IP (registre de pointeur d'instruction).

B. CS : L'instruction pointée par IP n'est pas nécessairement exécutée par le CPU. CS : L'emplacement pointé par IP est l'adresse de la prochaine instruction à exécuter, mais il n'y a aucune garantie que le CPU ait exécuté l'instruction.

C. Utilisez la commande "t" de Debug pour exécuter les instructions d'assemblage en une seule étape et n'exécutez qu'une seule instruction à la fois.

La commande "t" est utilisée dans l'outil de débogage pour parcourir les instructions d'assemblage. Chaque fois que la commande "t" est exécutée, Debug exécute l'instruction pointée par le CS:IP actuel et met à jour CS:IP à l'adresse de la prochaine instruction. Ainsi, si l'instruction suivante est une instruction de saut inconditionnel (telle que JMP), alors une commande "t" exécutera plusieurs instructions.

Par conséquent, le nombre d'instructions d'assemblage exécutées à l'aide de la commande "t" dépend du flux de contrôle et de la présence d'instructions de saut dans le programme. S'il n'y a pas d'instructions de saut ou seulement des instructions séquentielles dans le programme, alors une seule instruction sera exécutée à chaque fois que la commande "t" est exécutée. Cependant, s'il y a des instructions de saut dans le programme, alors une commande "t" peut exécuter plusieurs instructions.

D. L'instruction "ASSUME" est utilisée pour établir une association entre un segment et un registre de segment. Cette association est gérée par le compilateur et déterminée lors de la compilation. L'instruction "ASSUME" indique au compilateur comment associer le segment aux registres de segment afin de générer correctement les instructions. Par conséquent, l'instruction correcte est que l'association entre le segment et le registre de segment établi par "ASSUME" est gérée par le compilateur.

Après avoir exécuté la commande suivante, le résultat correct est ( ).

mobile, 198

et al, 01010011B

ou al,01010101B

A.al = 57 B.al = 57H C.al = 42 D.al = 42H

Après avoir exécuté la commande suivante, le résultat correct est B. al = 57H.

expliquer:

Tout d'abord, exécutez l'instruction "mov al, 198" pour déplacer le nombre décimal 198 (11000110B) dans le registre AL. À ce moment, la valeur de AL est 11000110B, c'est-à-dire C6H.

Ensuite, exécutez l'instruction "et al, 01010011B" pour effectuer une opération ET au niveau du bit sur la valeur dans AL et 01010011B. L'opération AND au niveau du bit effectuera l'opération AND sur les bits correspondants des deux opérandes, et le résultat est 01000010B, soit 42H.

Enfin, exécutez l'instruction "or al, 01010101B" pour effectuer une opération OU au niveau du bit sur la valeur dans AL et 01000010B. L'opération OU au niveau du bit fera OU les bits sur les bits correspondants des deux opérandes, et le résultat est 01010111B, qui est 57H.

Par conséquent, après l'exécution de ces trois instructions, la valeur de AL est 57H.

Le résultat correct est B. al = 57H.

L'instruction qui doit utiliser DS est ( ).

A. mov ax,[bp] B. inc word ptr [bx] C. add al,cl D. and [bp],al

L'instruction qui doit utiliser DS est A. mov ax,[bp].

expliquer:

En langage assembleur, utilisez DS (registre de segment de données) pour spécifier le segment de données auquel accéder. Les crochets dans l'instruction A. mov ax,[bp] indiquent qu'il faut accéder à une adresse mémoire et non au contenu d'un registre. Dans ce cas, l'adresse mémoire accédée est obtenue en ajoutant la valeur dans BP (Base Pointer Register) à DS. Par conséquent, cette instruction nécessite l'utilisation de DS.

L'instruction B. inc mot ptr [bx] incrémente le mot (données 16 bits) pointé par l'adresse mémoire dans le registre BX, sans impliquer DS.

L'instruction C. add al,cl consiste à additionner les valeurs dans le registre AL et dans le registre CL sans impliquer d'accès mémoire et DS.

L'instruction D. et [bp],al effectue une opération ET bit à bit sur la valeur du registre AL et le mot (données 8 bits) pointé par l'adresse mémoire dans le registre BP, et n'implique pas DS.

Par conséquent, l'instruction qui doit utiliser DS est A. mov ax,[bp].

Le sens de l'instruction mov ax, [bp]est de lire le mot (données de 16 bits) dans le segment de pile (SS) par rapport à l'adresse mémoire pointée par le pointeur de base (BP) dans le registre AX.

Pour cette instruction, deux registres de segment sont impliqués :

Registre de segment de pile (SS) : ce registre stocke l'adresse de segment du segment de pile actuel. Grâce à lui, nous pouvons accéder aux données sur la pile.

Registre de segment de données (DS) : lors de l'utilisation de BP comme pointeur de base, DS est associé à SS par défaut. Par conséquent, dans l'instruction 14 mov ax, [bp], la valeur du registre de segment de données DS est la même que la valeur du registre de segment de pile SS.

Par conséquent, mov ax, [bp]l'instruction utilise le registre de segment de données DS et le registre de segment de pile SS. Il lit un mot (données de 16 bits) à partir de l'adresse mémoire pointée par rapport au pointeur de base et le stocke dans le registre AX.

segments de données

jj 1234h

les données se terminent

Les données 1234h dans la section de données sont stockées dans ( ).

A. 12 34 00 00 B. 34 12 00 00 C. 00 00 12 34 D. 00 00 34 12

La condition de stockage des données 1234h dans la section de données de la mémoire est B. 34 12 00 00.

Dans l'architecture x86, les données sont stockées en unités d'octets et utilisent Little Endian (Little Endian). Par conséquent, pour une donnée 16 bits 1234h, elle est stockée dans la mémoire dans l'ordre de l'octet de poids faible en premier et de l'octet de poids fort en dernier.

Correspondant à la donnée 1234h, sa situation de stockage est :

Octet bas : 34 Octet haut : 12

En raison de l'ordre petit-boutiste des octets, l'octet de poids faible 34 est situé à une adresse mémoire inférieure et l'octet de poids fort 12 est situé à une adresse mémoire supérieure. Les octets restants sont 00 00.

Par conséquent, la condition de stockage des données 1234h en mémoire est 34 12 00 00, option B. 34 12 00 00 est correcte.

Le BIOS est stocké dans lequel des matériels suivants ? ( )

A.RAM B.ROM C.CPU D.CMOS

Le BIOS (Basic Input/Output System) est stocké dans B. ROM (Read Only Memory).

BIOS是计算机系统的基本固件，提供了计算机启动和硬件初始化的功能。它包含了用于操作系统和应用程序的低级别软件和驱动程序。BIOS通常被存储在计算机主板上的ROM芯片中，这种ROM芯片被称为BIOS芯片或固化BIOS（Firmware BIOS）。

选项A.RAM（随机存储器）是指计算机的主内存，用于临时存储程序和数据。BIOS不存储在RAM中。

选项C.CPU（中央处理器）是计算机的主要计算和控制单元，不用于存储BIOS。

选项D.CMOS（互补金属氧化物半导体）是一种用于存储计算机的基本设置和配置信息的特殊类型的RAM。它通常包含了BIOS设置信息，但不存储完整的BIOS程序。因此，CMOS不是BIOS存储的主要位置。

因此，正确答案是B. ROM。

用 [di]、[bp]的方式访问内存时，8086CPU默认的段寄存器依次是（）。

A.ds、es B.ds、ss C.ss、ds D.es、ss

在8086 CPU中，当使用 `[di]` 和 `[bp]` 的方式访问内存时，默认的段寄存器依次是 B. ds（数据段寄存器）和 D. ss（堆栈段寄存器）。

- `[di]` 使用 DI（目的索引寄存器）作为基址指针，并默认使用 DS（数据段寄存器）作为段地址，用于访问数据段中以 DI 寄存器指定的偏移地址处的内存。

- `[bp]` 使用 BP（基址指针寄存器）作为基址指针，并默认使用 SS（堆栈段寄存器）作为段地址，用于访问堆栈段中以 BP 寄存器指定的偏移地址处的内存。

因此，8086 CPU 默认的段寄存器依次是 B. ds、ss。

debug加载.exe文件后，在对寄存器中的值进行改变之前，cx中的值有什么含义？（）

A.循环次数 B.所加载的文件的字节数。

C.是系统默认的值，没有实际意义 D.程序的长度。

Une fois que Debug a chargé le fichier .exe, avant de modifier la valeur dans le registre, la valeur dans CX représente généralement le nombre de cycles (A. numéro de cycle).

Le registre CX est utilisé comme registre de compteur dans de nombreux langages d'assemblage et est souvent utilisé pour implémenter des structures de contrôle de boucle. Dans certaines instructions, la valeur du registre CX est utilisée pour spécifier le nombre d'itérations de la boucle. Après chargement du fichier .exe en Debug, si la valeur du registre CX n'est pas modifiée avant l'exécution du programme, sa valeur initiale représente généralement le nombre de boucles.

Par conséquent, la bonne réponse est A. Le nombre de boucles.

Vérifier la mémoire en debug, l'affichage est le suivant :

073F：0000 CD 20 3E A7 00 EA FD FF-AD DE 4F 03 A3 01 8A 03

073F：0010 A3 01 17 03 A3 01 92 01-01 01 01 00 02 FF FF FF

073FH : Les données de police à 0013H sont ( ).

A.007AH B.03A3H C.A303H D.0317H

C

Pour 8086CPU, l'instruction correcte est ( ).

A.mov ax,[bp+dx] B.mov ax,ds.[bp+bx]

C.mov ax,ss：[si][di] D.mov ax,cs.6[si]

Dans le processeur 8086, l'instruction correcte est A. mov ax,[bp+dx]. Cette instruction utilise le pointeur de base BP et le pointeur d'index DX pour l'accès à la mémoire. Il lira un mot (16 bits) à partir [BP + DX]de l'emplacement mémoire pointé par et chargera sa valeur dans le registre AX.

L'instruction qui peut modifier CX est ( ).

A.jmp B.div C.shl D.jcxz

C

instruction divd'effectuer une opération de division non signée. Il divise un dividende par le diviseur dans un registre et stocke le quotient dans le registre correspondant. La syntaxe est la suivante :

div divisor

où divisorest le diviseur, qui peut être un registre ou un opérande mémoire.

Lorsque l'instruction est exécutée, le dividende est considéré comme un double mot (32 bits) ou mot (16 bits), le bit haut du dividende est dans le registre DX, et le bit bas est dans le registre AX. Le diviseur est divisé par le contenu du registre AX, le quotient est stocké dans le registre AL (ou AX) et le reste est stocké dans le registre AH (ou DX).

shlL'instruction décale la représentation binaire de l'opérande de destination vers la gauche du nombre de bits spécifié et la complète avec des zéros à droite. Le bit décalé est stocké dans le drapeau de retenue CF.

En ce qui concerne l'étiquette, la mauvaise déclaration est ( ).

A. L'étiquette de données indique l'adresse et la longueur de l'unité de mémoire.

B. L'étiquette d'adresse avec ":" derrière elle ne peut être utilisée que dans le segment de code.

C. Utilisez supposer pour lier le segment où se trouve l'étiquette de données dans l'instruction avec un registre de segment, de sorte que l'instruction utilisant l'étiquette de données puisse obtenir l'adresse de segment de l'étiquette de données utilisée à partir du registre de segment.

D. Un ensemble d'étiquettes peut être stocké dans une table d'adressage direct.

Il est faux de dire que D. Un ensemble d'étiquettes peut être stocké dans une table d'adressage direct.

La table d'adressage direct (table d'adressage direct) n'est pas utilisée pour stocker la structure de données de l'ensemble d'étiquettes. La table d'adressage direct est une méthode d'adressage utilisée pour accéder directement aux données en mémoire selon une adresse donnée. Il est couramment utilisé pour accéder à des structures de données telles que des tableaux ou des tables, où les adresses sont utilisées comme index pour obtenir des données à des emplacements spécifiques.

Une étiquette est un symbole utilisé pour identifier un code ou un emplacement de données en langage assembleur. Ils sont souvent utilisés avec des instructions ou des définitions de données pour indiquer le déroulement d'un programme ou l'emplacement des données.

Par conséquent, l'option D est erronée, car la signification et le but de la table d'adresses directes et de l'étiquette sont différents.

En ce qui concerne la PSP, la mauvaise déclaration est ( ).

A. Ce programme définit (CS)*16+(IP)=la première adresse de l'espace mémoire où se trouve la PSP.

supposons cs：code

segment de code

start： mov hache,0

mov es,ax

mot mov ptr es：[200h],0

mov es：[202h],ds

jmp dword ptr es：[200h]

le code se termine

fin début

B. PSP a un total de 256 octets.

C.DOS communique avec les programmes qu'il charge via la PSP.

D. Après avoir utilisé le débogage pour charger un programme dont la fonction est de définir (ds)=(cs), utilisez une commande pour écrire et utilisez la commande T pour exécuter le segment de programme suivant :

mov hache, ds

sous-axe, 10

mov ds, hache

Utilisez ensuite "d ds:0 ff" pour visualiser l'espace mémoire où se trouve la PSP.

D. Après avoir utilisé le débogage pour charger un programme dont la fonction est de définir (ds)=(cs), utilisez une commande pour écrire et utilisez la commande T pour exécuter le segment de programme suivant :

mov hache, ds

sous-axe, 10

mov ds, hache

Utilisez ensuite "d ds:0 ff" pour visualiser l'espace mémoire où se trouve la PSP.

Cette affirmation est fausse. Dans le segment de code donné, la valeur du registre ds est modifiée en ds-10 au lieu de définir ds égal à cs. Par conséquent, l'utilisation de la commande "d ds:0 ff" pour afficher l'espace mémoire où se trouve la PSP n'affichera pas le résultat correct.

Une fois les instructions suivantes exécutées, la valeur de ax est ( ).

mov hache, 6776h

ajouter tout, 90 h

ajouter ah, 90h

A.6806H B.F806H C.F706H D.6706H

C ne porte pas

Quelle est la valeur de al après l'exécution de l'instruction suivante ? ( )

mobile, 01100011b

et al,00111011b

ou al,00111011b

A.00100011B B.00111011B C.01111011B D. Les trois premières options sont toutes incorrectes.

B

Lorsque le programme suivant s'exécute, parmi les instructions du programme source, quelle est la première instruction exécutée par le CPU ? ( )

supposons cs：a

codeg segment

mov hache, 20h

mov hache, 4c00h

int 21h

codesg se termine

un segment

mov bx, 30h

mov hache, 4c00h

int 21h

une se termine

segment b

mov bx, 40h

mov hache, 4c00h

int 21h

b se termine

fin

A.mov ax,20h B.mov bx,30h C.mov bx,40h D. Aucune des options ci-dessus n'est correcte

B

Selon un programme donné, la partie "un segment" est exécutée en premier. Dans la première instruction de la section, la valeur dans le registre bx est fixée à 30h. Par conséquent, la première instruction exécutée par le CPU est mov bx,30h

Pour 8086CPU, l'instruction correcte est ( ).

A.inc mot ptr ds：[0] B.mov es：[0],ds：[0]

C.mov ax,[bx+bp] D.add Cs,ax

b

Disposées par ordre d'adresses de bas en haut, comment les données de mot double 16 sont-elles stockées dans la mémoire ? ( )

A.00 00 10 00 B.00 00 00 10

C.00 10 00 00 D.10 00 00 00

Ce qui ne peut pas apparaître dans un fichier exécutable est ( ).

A. Code machine B. Pseudo-instruction C. Données définies dans le programme source D. Adresse dans l'instruction jmp

Concernant l'utilisation de l'espace mémoire dans le programme, la déclaration incorrecte est ( ).

A. Un espace mémoire sécurisé peut être alloué au programme en définissant un segment

B. DOS et les applications n'utilisent généralement pas l'espace de 0,200 ~ 0,2ff

C. L'utilisation d'un espace mémoire sécurisé n'affectera pas le fonctionnement du système d'exploitation dos et d'autres programmes légaux

D. Lorsque vous utilisez l'instruction mov, vous n'avez pas à vous soucier d'endommager les données système

Parmi les instructions suivantes, les instructions exécutables par le CPU sont ( ).

A.SEGMENT B.ASSUME C.sti D.end

Que lit réellement le processeur lorsqu'il lit des instructions ? ( )

A. Chaînes correspondant aux pseudo-instructions et aux instructions d'assemblage

B. Informations dans un programme source écrit en langage assembleur

C. Information composée d'une série de bits binaires

D. La chaîne correspondant à l'instruction d'assemblage

Pour 8086CPU, la mauvaise instruction est ( ).

A.mov ax,ds B.push [bx] C.inc [bx] D.add bp,2

Pour 8086CPU, les déclarations suivantes concernant les segments sont erronées ( ).

A. L'adresse de début d'un segment doit être un multiple entier de 16

B. Définir un segment dans le programme source Lors de l'exécution du programme, la CPU ne connaîtra pas la taille de ce segment à cause de la définition.

C. Un morceau d'espace mémoire peut être à la fois un segment de code et un segment de données.

D. Le CPU utilise un segment comme pile car l'instruction assume l'associe au registre SS

( ) a la même fonction que "mov al,'d'".

A.mov hache,'d' B.mov al,'a'+3 C.mov al,'A'+3 D.ou al,'d'

En ce qui concerne les instructions en langage assembleur, l'instruction correcte est ( ).

A. Les étiquettes en langage assembleur sont des pseudo-instructions

B. Les instructions de montage doivent avoir les codes machine correspondants

C. Les pseudo-instructions sont reconnues par le compilateur, et le compilateur les convertit en codes machine correspondants

D. "+" est généralement compilé dans une commande d'ajout

Lorsque le programme suivant est en cours d'exécution, après l'exécution de "sub ax,masm", la valeur de ax est ( ).

supposons cs：code

segment de masse

dw 5 dup('a','b','c')

le masme se termine

segment de code

start： mov hache, code

sous-axe, masm

mov hache, 4c00h

int 21h

le code se termine

fin début

A.15 B.1 C.2 D.3

En ce qui concerne l'utilisation du débogage, la mauvaise déclaration est ( ).

A. Après que Debug charge le programme en mémoire, avant d'exécuter des commandes, la valeur de IP doit être zéro

B. Vous pouvez afficher la valeur de certains bits du registre de drapeau via le débogage

C. Après que Debug charge le programme dans la mémoire, avant d'exécuter des commandes, la valeur de CX peut être 1024

La commande DT a le potentiel d'exécuter plus d'une instruction à la fois

En ce qui concerne l'étiquette, laquelle des affirmations suivantes est correcte est ( ).

Les étiquettes d'adresse et les étiquettes de données peuvent être utilisées après jmp
L'étiquette avec ":" derrière est une étiquette d'adresse utilisée dans le segment de code et une étiquette de données utilisée dans le segment de données
Les étiquettes de données utilisées dans le segment de code indiquent uniquement l'adresse de l'unité de mémoire
Les étiquettes d'adresse ne sont pas disponibles dans les instructions et et ou
Les premières options sont fausses

Quel élément n'est pas inclus dans le langage d'assemblage ? ( )

A. Instructions de montage

B. Directive Machines

C. Directives

D. "+", "-", "*", "/" et autres symboles

Pour la compilation, la liaison et l'exécution, la mauvaise instruction est ( ).

A. La directive est exécutée par le compilateur lors de la compilation

B. Compiler avec le compilateur masm, seuls les fichiers objets peuvent être générés

C. Les fichiers exécutables contiennent des informations sur le programme et la description

D. Le programme de commande fourni par DOS peut charger le programme dans le fichier exécutable dans la mémoire

Laquelle des affirmations suivantes est fausse ( ).

A. Dans le programme source du langage assembleur compilé avec masm.exe, end et ends sont des pseudo-instructions

B. Déboguer un programme en débogage, exécuter "mov ax,4c00h" et

Après les deux instructions de "int 21h", "Programme terminé normalement" s'affiche à l'écran, ce qui peut expliquer cela

Lorsque le programme est revenu sous DOS

C. Les instructions pertinentes pour le retour du programme sont exécutées par la CPU

D. Pour le retour du programme, DOS fournit la routine d'interruption correspondante

Écrivez quelques instructions avec debug :

mov hache, 20

mov ds, hache

mov hache,[1]

Après vérification de la mémoire, l'affichage est le suivant :

0：200 80 00 70 00 60 00 ……

Utilisez ensuite la commande t pour exécuter ces instructions. Après l'exécution de "mov ax, [1]", quelle est la valeur de AX ? ( )

A.7000H B.0070H C.1 D.0080H

Après l'exécution de l'instruction suivante, quelle est la valeur de AX ? ( )

mov hache, 20

mov es,ax

mov byte ptr es：[0],80h

mov byte ptr es：[1],00h

mov byte ptr es：[2],70h

mov byte ptr es：[3],00h

mov ax,es：[1]

A.7000H B.0070H C.1 D.0080H

Les instructions telles que "dw", "db" et "dd" dans le programme source en langage assembleur appartiennent à ( ).

A. Instructions de montage B. Pseudo-instructions C. Instructions machine D. Étiquettes

Pour le processus d'exécution du programme, la mauvaise instruction est ( ).

A. Une fois le programme chargé dans la mémoire via la commande, la commande définira CS.IP pour pointer vers la première commande à exécuter en fonction des informations de description dans le fichier exécutable

B. Après avoir chargé le programme dans la mémoire via le débogage, utilisez la commande r pour afficher la valeur de CX, et vous pouvez voir les informations relatives à la longueur du programme

C. Une fois le programme chargé en mémoire via le débogage, DS pointe vers le segment de données du programme et CS pointe vers le segment de code du programme.

D. Utilisez la commande end dans le programme source pour déterminer la valeur du registre IP après le chargement du programme

下列对于程序段前缀（PSP）的描述，错误的是（）。

A.PSP占256个字节的地址空间

B.DOS通过PSP与被加载的程序通信

C.用debug将程序载入内存后，PSP与代码段的段地址一致，偏移地址相差100h

D.用debug将程序载入内存后，可用“d ds：0 ff”查看PSP的全部内容

下面汇编语言源程序中的指令可以通过编译的是（）。

A. mov al,2000 B. push [0] C. add al,100h D. mov dx,1000h

下列说法正确的是（）。

A. Push、pop指令通过修改ss：sp的值来操作栈中的数据

B. 栈空时，ss：sp指向栈底

C. 栈满以后，如果继续向其中压入数据，会覆盖栈顶之后的高地址内存单元

D. 栈满以后，如果继续向其中压入数据，不一定会覆盖其地址比栈顶的地址更低的内存单元

其所传送的数据在内存中的指令是（）。

A. pop ax B. mov ax,bx C. mov ax,0 D. in al,20h

以下程序加载后，在执行前，(ds)=0a21h。对于此时的寄存器与程序的相关情况，错误的说法是（）。

assume cs：code,ds：data

data segment

db ’1975’

data ends

code segment

dw 0123h,0456h,0789h,0abch,0defh,0fedh,0cbah

mov ax,0

mov bx,0

mov cx,8

s： add ax,cs：[bx]

add bx,2

loop s

mov ax,4c00h

int 21h

code ends

end

A. 程序的起始段地址为0a31h

B. (cs)=0a31h，(ip)=0

C. ds的值不是data段的段地址

D. “mov ax,0”的机器码的内存地址是0a31H：0020H

masm和debug默认的进制分别是（）。

A.十六进制和十进制 B.十进制和二进制

C. Décimal et hexadécimal D. Binaire et hexadécimal

Complétez ce programme pour qu'après exécution, (bx)=3. ( )

mov bx,1

mov cx, ___

boucle s1

mov bx, 2

s1： y compris bx

A. 0 B. 1 C. 2 D. 3

Chapitre 7-8 (Modes d'adressage)

Parmi les modes d'adressage suivants, l'adressage indexé de base relatif est ( ).

A. [bx+si+idata] B. [bx+di] C. [bp+si] D. [bx]

Il peut être utilisé comme registre d'adresse décalée dans l'adressage indexé de base ou l'adressage indirect de registre ( ).

A. ax, bx, cx, dx B. ds, es, cs, ss

C. sp，bp，ip，bx D. si，di，bp，bx

Les données décrites par "dd 5 dup (1,2,3,4)" occupent ( ) octets au total lorsque le programme est en cours d'exécution.

A. 4 B. 20 C. 40 D. 80

Pour 8086CPU, la mauvaise instruction est ( ).

A. déplacer la hache,[bp+si] B. déplacer la hache,[bx] C. déplacer la hache,2[si] D. déplacer al,[dx]

Les modes d'adressage suivants appartiennent à l'adressage indexé par adresse de base ( ).

A. [de] B. [bx+date] C. [bx+di] D. [bp+di+date]

Le mode d'adressage adopté par "mov word ptr [bx+si],1" est ( ).

A. Adressage indirect de registre B. Adressage relatif de registre C. Adressage indexé de base D. Adressage indexé de base relatif

Utilisez l'instruction div pour effectuer l'opération de division. Lorsque le diviseur est de 16 bits, le reste est stocké dans ( ).

A.AX B.AH C.AL D.DX

Concernant l'instruction div, la mauvaise instruction est ( ).

A. L'exécution de l'instruction div peut déclencher une interruption

Le diviseur de l'instruction B.div peut être soit 16 bits soit 8 bits

Le dividende de l'instruction C.div est soit stocké dans DX et AX, soit stocké dans AX

Le résultat de l'opération de l'instruction D.div comporte deux parties : le quotient et le reste

若AX=1000H，CL=90H，则执行指令DIV CL之后，AX=（）。

A.401CH B.001CH C.0040H D.1C40H

以下关于8086CPU的div指令的说法，错误的是（）。

A.被除数可以放在寄存器中，也可以放在内存单元中。

B.若结果的商大于al或ax所能存储的最大值，将引发CPU内部的除法溢出错误。

C.可以重写0号中断处理程序，使得程序可以处理除法溢出的情况。

D.可使用div指令编写一个计算32位被除数/8位除数的子程序。

执行以下指令后，AX的值是（）。

mov al,96h

mov bl,12h

mul bl

A. 1152h 　　　　 B. 0a8ch

C. 0a82h 　　　 D. 0f88ch

以下指令执行后，AX的值是多少？（）

mov ah,1

mov al,10h

mov bl,2

mul bl

A.0220H B.2000H C.0020H D.0120H

下列指令中（）可以实现，将AX寄存器中的最低3位清0

A、 OR AX,0FFF8H

B、 AND AX,0FFF8H

C、 AND AX,0FFF7H

D、 AND AX,0FFFBH

下列指令中（）可以实现，将AX寄存器中的D3和D7位置1

A、 XOR AX,08H

B、 OR AX,08H

C、 OR AX,88H

D、 XOR AX,88H

下列指令中（）可以实现，将AX寄存器中的最高3位取反

A、 NOT AX

B、 AND AX,1FFFH

C、 XOR AX,0E000H

D、 OR AX,0E000H

数据段中有如下定义

X1 DB 1,2,3,4,5,6,7,8

X2 DW 1,2,3,4,5,6,7,8

L'erreur dans l'instruction suivante est ( )

A、MOV X1,100

B、 MOUVEMENT AXE,X1

C、 MOV AX,X2

D、 MOV X2 100

La section des données contient les définitions suivantes

X1 DB 1,2,3,4,5,6,7,8

X2 DW 1,2,3,4,5,6,7,8

Laquelle des instructions suivantes est correcte ( )

A、MOV X1,1000

B、 MOUVEMENT AXE,X1

C、 MOV AH,X2

D、 MOV X2,1000

La section des données contient les définitions suivantes

X1 DB 1,2,3,4,5,6,7,8,9,10

X2 DW 100

Après l'exécution du segment de programme suivant, la valeur de DX est ( ).

MOV CX,10

MOV DX,X2

S : MOV BX, CX

MOV AL,X1[BX]

MOUV AH,0

AJOUTER DX,AX

DEC CX

BOUCLES

A、 124 B、 224 C、 155 D、 255

La séquence d'instructions suivante ne peut pas réaliser la fonction d'envoi des données d'octet dans l'adresse mémoire 0:202h à al. ______

A、 mov hache,0

mov ds, hache

mov bx, 202h

mobile,[bx]

B、 mov hache,0

mov ds, hache

mov bp, 202h

mobile,[bp]

C、 mov hache,0

mov ds, hache

mov bx, 200h

mouvement,[bx+2]

D、mouvement hache,0

mov ds, hache

mov bp, 200h

mov al,ds :[bp+2]



Parmi les instructions suivantes, la bonne est ( )

A、MOV AX,[BX+BP] B、MOV AX,[BX+SI]

C、 MOUV AL,[B+DI] D、 MOUV AL,[B+DX]

Dans les instructions suivantes, l'erreur est ( )

A、 MOV AX,[BX+SI] B、 MOV AX,[BX+DI]

C、 MOUV AL,[B+DI] D、 MOUV AL,[B+BP]

Parmi les instructions suivantes, la bonne est ( )

A、 MOV DS :[BP+BX],AH B、 AJOUTER [BX],100

C、 MOUV [SI],AL D、 MOUV [SI],100

Dans les instructions suivantes , l'erreur est ( )

A、 MOV DS :[BP+SI],AH B、AJOUTER UN MOT PTR [BX],100

C、 MOUV [SI],AL D、 MOUV [SI],100

Lequel des segments de programme suivants peut réaliser la conversion de 987*6 ? ( )

A、 MOV AX,987

MOV BX, 6

MUL AXE, BX

MOV AX,987

MOV BX, 6

MULBX

C、 MOV AX,987

MOVBL,6

MUL BL

D、MOV AL,6

MOV BX, 987

MULBX

Lequel des segments de programme suivants peut atteindre 987/30 ? ( )

A、 MOV AX,987

BOITE MOUVEMENT,30

BX DIV

MOVDX,987

MOVBL,30

DIVBL

MOV AX,987

MOVBL,30

DIVBL

D. Aucune des options ci-dessus n'est correcte

Exécutez le segment de programme suivant

MOV AX,87

MOV BX, 6

MULBX

Aller à ( ) s'inscrire pour voir le résultat

A, AX B, BX C, DX D, DX stockent le résultat dans les 16 bits supérieurs, AX stockent le résultat dans les 16 bits inférieurs

Exécutez le segment de programme suivant

MOV AX,87

MOVBL,6

MUL BL

Aller à ( ) s'inscrire pour voir le résultat

A、 HACHE

B、BX

C、AL

D. Les 16 bits de poids fort du résultat stocké dans DX et les 16 bits de poids faible du résultat stocké dans AX

La section des données contient les définitions suivantes :

DATA1 BD 1,2,3,4

DB 5,6,7,8

DB 9,10,11,12

DB 1,2,3,4

Exécutez le segment de programme suivant

MOV BX,0

MV SI,0

MOV CX,4

MOV AL,0

S : AJOUT AL,DONNEES1[BX][SI]

INC OUI

AJOUTER BX, 4

BOUCLES

Le résultat du registre AL est ( )

A、 10 B、 16 C、 24 D、 22

La section des données contient les définitions suivantes :

DATA1 BD 1,2,3,4

DB 5,6,7,8

DB 9,10,11,12

DB 1,2,3,4

Exécutez le segment de programme suivant

MOV BX,0

MV SI,0

MOV CX,4

MOV AL,0

S : AJOUT AL,DONNEES1[BX][SI]

INC OUI

INC BX

BOUCLES

Le résultat du registre AL est ( )

A、 10 B、 16 C、 24 D、 22

La section des données contient les définitions suivantes :

DATA1 BD 1,2,3,4

DB 5,6,7,8

DB 9,10,11,12

DB 1,2,3,4

Exécutez le segment de programme suivant

MOV BX,0

MV SI,0

MOV CX,4

MOV AL,0

S : AJOUT AL,DONNEES1[BX+SI]

AJOUT AL,DONNEES1[BX+4+SI]

INC OUI

BOUCLES

Le résultat du registre AL est ( )

A、 10 B、 16 C、 52 D、 36

Il y a les définitions suivantes, la déclaration est correcte ( ).

X DW 5 DUP (1,2,3)

A. Un total de 15 octets sont définis B. Un total de 3 octets sont définis

C. Un total de 5 octets sont définis D. Un total de 30 octets sont définis

Il y a les définitions suivantes, la déclaration est correcte ( ).

X BD 3 DUP (1,2 DUP(3))

A. Équivalent à X DB 1, 2, 3

B. Équivalent à X DB 1, 2, 3, 1, 2, 3, 1, 2, 3

C. Équivalent à X DB 1, 3, 3, 1, 3, 3, 1, 3, 3

D. Équivalent à X DB 1, 2, 2, 1, 2, 2, 1, 2, 2

Il y a les définitions suivantes, la déclaration est correcte ( ).

X DW 5 DUP (1.3 double (2))

A. Un total de 10 octets sont définis B. Un total de 20 octets sont définis

C. Un total de 30 octets sont définis D. Un total de 40 octets sont définis

Chapitres 9-10

Lorsque le CPU exécute "l'étiquette d'appel", cela équivaut à exécuter ( ).

A. push IP ; jmp far ptr label

B. push CS ； push IP ； jmp far ptr 标号

C. push IP ; jmp près de l'étiquette ptr

D. pousser CS ; pousser IP ; jmp près de l'étiquette ptr

En utilisant les instructions call et ret, nous pouvons réaliser une conception modulaire dans la programmation en langage assembleur. L'erreur dans la description suivante est ( ).
    A. Plusieurs sous-programmes peuvent être mis en œuvre avec des instructions call et ret.
     B. Un problème complexe peut être résolu par plusieurs sous-programmes interdépendants avec des fonctions indépendantes.
     C. Pour les sous-routines courantes, il est préférable d'ajouter des commentaires détaillés.
     D. Utiliser le langage assembleur pour la programmation, et les sous-routines doivent être implémentées avec call et ret.
Une fois le programme suivant exécuté, la valeur de AX est ( ).

mov hache, 4

appels

non

S：

mov hache, décalage s

mov bp,sp

sous-axe,[bp]

A.0 B.1 C.2 D.3

Pour l'instruction jmp qui saute en fonction du déplacement, quand le déplacement du saut est-il calculé ? ( )

A. compiler B. lier C. exécuter D. compiler ou exécuter

La commande pour modifier cs et ip est ( ).

A. jmp ax B. jmp far ptr s C. loop D. ret

"mot jmp ptr [bx]" est ( ).

Transfert proche intra-segment B. Transfert proche inter-segment C. Transfert court intra-segment D. Transfert court inter-segment

"jmp word ptr [bx]" modifie le registre ( ).

A.IP B. BP C.CS D.CS和IP

Quelle instruction peut avoir une plage de saut différente des trois autres ? ( )

A.jmp B.jcxz C.loop D.je

Laquelle des déclarations suivantes est correcte ( ).

L'instruction iret peut être décrite comme suit :

popf

pop cs

pop ip

mov al,1

add al,0ffh

上面两条指令执行后，(AX)=0

用debug进行调试时，用p命令可以一次执行多条汇编指令
call指令不能通过位移进行跳转

关于loop指令，错误的说法是（）。

A.loop指令的跳转范围是-128~127

B.CX=10时，执行loop指令，IP的值一定减小

C.CX=0时，执行loop指令后，CX=0ffffh

D.CX=1时，执行loop指令，IP的值不变

假设sp=0010h，则执行哪条指令，sp的值会减小？（）

A.iret B.jmp 标号 C.retf D.call 标号

在debug中，用“d 1000：0”查看内存，显示如下.

1000：0000 69 76 65 20 25 63 20 61-6E 64 20 70 72 65 73 73

1000：0010 20 3C 45 4E 54 45 52 3E-0A 00 6B 00 41 62 6F 75

1000：0020 74 20 74 6F 20 67 65 6E-65 72 61 74 65 20 2E 45

接着，即写且执行以下指令：

mov ax,1000

mov ds,ax

jmp far [2]

之后，cs：ip的值依次是（）。

A.6325：2065 B.6520：2563 C.2065：7669 D.6520：2567

关于转移指令，错误的说法是（）。

A.进行段内短转移时，jmp指令对应的机器码中没有转移的目的地址。

B.进行段间转移时，jmp指令对应的机器码中有转移的目的地址。

C.进行段内短转移时，IP的修改范围是0~255。

D.loop指令也是转移指令。

读取，执行哪条指令CPU会修改两次IP？（）

A.push B.pushf C.ret D.mov

在debug中用t命令执行下列指令，可观察到的现象是（）。

内存地址汇编指令

076e：0 mouvement hache,5

076e：3 hache d'appel

076e：5 hache inc

076e：6 mov bp,sp

076e：8 mot jmp ptr [bp]

A. Boucle d'exécution mov ax,5 et call ax

B. Appel d'exécution de boucle ax vers mot jmp ptr [bp]

C. Boucle inc ax vers jmp mot ptr [bp]

D.ss : les données pointées par bp sont inconnues, elles sautent donc vers une mémoire inconnue et le résultat est imprévisible

Utilisez la commande debug d pour vérifier la mémoire, les résultats sont les suivants, après l'exécution des instructions suivantes, les valeurs de CS et IP sont ( ).
    1000 : 0010 63 69 66 69 65 73 20 61...
    mov axe, 1000H
    mov es, axe
    jmp dword ptr es : [0012H]

A.6669 6573 B.6966 6965 C.7365 6966 D.1000 0012

Terminez le programme avec une instruction qui permet au programme de revenir. ( )

supposons cs：code

segments de données

jj 4 dup (0)

les données se terminent

segment de code

s：

mov hache, 4c00h

int 21h

le code se termine

supposons cs：a

un segment

commencer:

_____________

une se termine

fin début

A.jmp s B.loop s C.jmp lointain ptr s D.jmp proche ptr s

Après avoir lu et exécuté les instructions suivantes, combien de fois le CPU a-t-il modifié la valeur IP au total ? ( )

sous-hache, hache

correct

A.1 B.2 C.3 D.4

Le processus de lecture et d'exécution des instructions du 8086CPU est ( ).

① Lire les instructions de l'espace mémoire pointé par CS: IP et placer les instructions dans le tampon d'instructions

② Exécutez la commande et passez à l'étape ①

③IP pointe vers l'instruction suivante

A.① ②

B.① ③ ②

C. Si l'instruction est une instruction de transfert, le processus est ① ③ ②, sinon, le processus est ① ②

D. Si l'instruction est une instruction de transfert, le processus est ① ②, sinon, le processus est ① ③ ②

a la définition suivante

SEGMENT DE DONNÉES

X1 DB 5 DUP (1，2，3)

X2 DW 1

X3 DW 1000H

FIN DES DONNEES

Après l'exécution du segment de programme suivant, la valeur de CX est ( )

MOV AX, DONNÉES

MOV DS,AX

MOV CX, DÉCALAGE X3

A、 15

B、 16

C、 17

J、 18

Vérifiez la mémoire avec Debug, les résultats sont les suivants :

2000:1000 04 05 60 BE 00 06 00 00 00 ……

A ce moment, le CPU exécute l'instruction :

mov hache, 2000H

mov es,ax

jmp dword ptr es:[1002H]

Après cela, l'énoncé correct est ( )

A、 (CS)=2000H，(IP)=1002h

B、 (CS)=BE60H，(IP)=0600H

C、 (CS)=60BEH，(IP)=0006H

D、 (CS)=0600H，(IP)=BE60H

a la définition suivante

SEGMENT DE DONNÉES

X1 DB 5 DUP (1，2，3)

X2 DW 1

X3 DW 1000H

FIN DES DONNEES

Après l'exécution du segment de programme suivant, la valeur de CX est ( )

MOV AX, DONNÉES

MOV DS,AX

MOV BX, DÉCALAGE X3

MOV CX,[BX]

A、 18

B、 17

C、 1

D、 1000H

Concernant le libellé de la commande JMP SHORT, l'énoncé correct est

A. Exécutez cette commande et modifiez CS et IP une fois

B. Exécutez cette commande et modifiez l'IP une fois

C. Exécutez la commande et modifiez l'IP deux fois

D. Exécutez la commande et modifiez l'IP trois fois

Concernant le libellé de la commande JMP SHORT, l'énoncé correct est

A. Exécutez l'instruction, (IP) = (IP) + déplacement de 8 bits

B. Exécutez l'instruction, (IP) = (IP) + déplacement de 16 bits

C. Exécutez l'instruction, (IP) = (IP) + adresse de décalage dans le segment où se trouve l'étiquette

D. Exécutez l'instruction, (IP) = l'adresse de décalage dans le segment où se trouve l'étiquette

Concernant l'étiquette de l'instruction JMP NEAR PTR, la mention correcte est

A. Exécutez l'instruction, (IP) = (IP) + déplacement de 8 bits

B. Exécutez l'instruction, (IP) = (IP) + déplacement de 16 bits

C. Exécutez l'instruction, (IP) = (IP) + adresse de décalage dans le segment où se trouve l'étiquette

D. Exécutez l'instruction, (IP) = l'adresse de décalage dans le segment où se trouve l'étiquette

Concernant l'étiquette de l'instruction JMP FAR PTR, la mention correcte est

A. Exécutez l'instruction, (IP) = (IP) + déplacement de 8 bits

B. Exécutez l'instruction, (IP) = (IP) + déplacement de 16 bits

C. Exécutez l'instruction, (IP) = (IP) + adresse de décalage dans le segment où se trouve l'étiquette

D. Exécutez l'instruction, (IP) = l'adresse de décalage dans le segment où se trouve l'étiquette

Parmi les instructions suivantes, celle qui ne modifie pas CS est ( )

A、JMP AXE

B、 JMP FAR PTR S1

C、 JMP DWORD PTR DS:[0]

D、 JMP DWORD PTR [BX]

下列指令中，同时修改CS和IP的是（）

A、 JMP AX

B、 JMP NEAR PTR S1

C、 JMP WORD PTR DS:[0]

D、 JMP DWORD PTR [BX]

第11章

以下指令执行后，of和cf的值是（）

mov ax,0

push ax

popf

mov ax,0ffffh

inc ax

A. of=0，cf=0 B. of=1，cf=0 C. of=0，cf=1 D. of=1，cf=1

以下指令执行后，sf、cf、zf、of的值分别是（）。

mov ax,0ea04h

sub ax,4ae0h

A. 0，1，0，1 B. 1，1，0，0 C. 1，0，0，0 D. 1，0，1，0

可以改变标志寄存器的值的指令是（）。

A.PUSHF B.MOV AX,AX C.SHL AX,CL D.JCXZ

可改变SF和ZF的值的指令是（）。

A.je next B.in al,20h C.puah ax D.shl ax,1

不会影响标志寄存器的值的指令是（）。

A.adc ax,bx B.cmp cx,ax C.inc ax D.jmp word ptr [bx]

可使if=1的指令是（）。

A.sti B.cld C.std D.shr

mov al,62h

add al,63h

这两条指令执行后，cf\of的值是（）。

A. cf=0，of=0 B. cf=0，of=1 C. cf=1，of=0 D. cf=1，of=1

La description suivante des drapeaux est correcte ( ).
A. Vous pouvez utiliser des instructions de pile pour modifier la valeur du bit d'indicateur

Les instructions Cmp et pushf peuvent affecter la valeur du bit d'indicateur
C. Vous pouvez connaître la taille des deux nombres en jugeant si le bit sf après l'exécution de l'instruction cmp est 1.
D. L'instruction de transfert et l'instruction de décalage n'ont pas effet sur la valeur du bit drapeau

Lors de l'exécution de l'instruction JNB, ( ), le saut est effectué.

A.CF=1 et ZF=1 B.CF=0 ou ZF=1 C.CF=0 ou ZF=0 D.CF=0

Une fois le programme suivant exécuté, les valeurs de pf, sf, cf et de sont respectivement ( ).

mov hache, 0ff80h

ajouter al, 0f0h

A.pf=1 sf=1 cf=1 de=1 B.pf=0 sf=1 cf=1 de=1

C.pf=0 sf=0 cf=1 de=1 D.pf=1 sf=0 cf=0 de=0

Laquelle des déclarations suivantes liées au registre des drapeaux est fausse ( ).

A. Le registre des drapeaux est accessible par des instructions de pile

B. Lorsque al=0ffh, l'exécution de "inc al" affectera la valeur de cf

C. Les instructions d'opération arithmétique n'affecteront pas le drapeau df

D. L'instruction de transfert conditionnel qui transfère en fonction du résultat de la comparaison du nombre non signé détecte la valeur de zf.cf

Pour la description des bits pertinents du registre des drapeaux, l'erreur est ( ).

mobile,1

ajouter tout, 127

Après exécution de ces deux instructions, OF=1, il y a débordement ; bien que le résultat logique soit positif, SF vaut 1

mobile,1

ajouter al, 0ffh

Après l'exécution de ces deux instructions, OF=0, CF=1

"inc ax" n'affecte pas le bit CF du registre des drapeaux
S：mouvement hache,8f00h

cmp hache,5

jb s

int 21h

Pendant l'exécution de ce programme, SF vaut toujours 1

Les instructions suivantes ne doivent pas modifier le registre des drapeaux ( ).

A.int 21h B.jmp ax C.cmp ax,bx D.sub ax,ax

Si AL=75H, après avoir exécuté ADD AL,0F0H, les valeurs de OF et CF sont ( ).

A.OF=1，CF=0 B.OF=0，CF=0 C.OF=0，CF=1 D.OF=1，CF=1

Après l'instruction dans laquelle des options suivantes est exécutée, zf=1, pf=1 ? ( )

Hache A.mov,1 Hache B.mov,1 Hache C.mov,1 Hache D.mov,1

ajouter ax,2 et ax,0 sous ax,2 ou ax,0

Après l'instruction dans laquelle des options suivantes est exécutée, cf=1, of=1 ? ( )

A.mov al,98 B.mov al,0f0H C.mov al,0f0H D.mov al,68H

ajouter al,99 ajouter al,88H ajouter al,78H ajouter al,1

En ce qui concerne l'instruction de transfert de chaîne, la mauvaise instruction est ( ).

A. Avec une seule instruction movsb, les données d'une unité de mémoire peuvent être transférées vers une autre unité de mémoire

B. Après l'exécution de l'instruction movsb, les valeurs de SI et DI peuvent augmenter ou diminuer

C. La transmission peut être effectuée en unités d'octets ou de mots

D. Si la valeur de CX est 10 avant d'exécuter "movsb", "movsb" sera répété 10 fois

Pour le registre d'indicateurs de 8086CPU, les déclarations suivantes sont erronées ( ).

A. Le registre de drapeau est de 16 bits

B. Il est impossible de mettre à jour tous les bits du registre des drapeaux via une instruction d'assemblage

C. Certains bits de ce registre n'ont aucune signification

L'instruction D.cmp peut changer la valeur du registre de drapeau

Chapitre 12 et au-delà

Stocké dans la table des vecteurs d'interruption est ().

A. Code de type d'interruption B. Adresse d'entrée du gestionnaire d'interruption

C. Gestionnaire d'interruptions D. Adresse de point d'arrêt

Le vecteur d'interruption occupe ( ) octets.

A. 1 B. 2 C. 3 D. 4

使用call和ret指令，我们可以实现汇编语言编程中的模块化设计。以下描述中错误的是（   ）。
      A. 可以用call和ret指令实现多个子程序。
         B. 可以通过多个相互联系.功能独立的子程序来解决一个复杂的问题。
         C. 对于通用的子程序，最好加上详细的注释。
         D. 用汇编语言进行程序设计，子程序一定要用call和ret来实现。
以下指令执行后，al和cf的值分别是（）。

mov al,00000001B

mov cx,109h

shl al,cl

A. 29 ，1 B. 29 ，0 C. 0，1 D. 0，0

已知（AX）=2，则能实现（AX）=（AX）*8的程序段是（）。

A.shl ax,3 B.shr ax,3

C.MOV CL,3 D.mov cl,3

SHL AX,CL shr ax,cl

关于shl与shr，正确的说法是（）。

A.shl用0补充最高位。

B.shr将一个寄存器或内存单元中的数据向左移动。

C.移出的bit的值是0，shl与shr不影响CF。

D.shr用0补充最高位。

其逻辑不是实现 (ax)=(ax)*10的程序段是（）。

A. shl ax,1

mov bx,ax

mov cl,2

shl ax,cl

add ax,bx

B. mov bx,ax

shl ax,1

shl bx,1

add ax,ax

add ax,bx

C. mov bx,ax

mov cl,3

shl ax,cl

shl bx,1

add ax,bx

D. mov cl,3

shl ax,cl

mov bx,ax

mov cl,2

shr bx,cl

add ax,bx

现在想要判断AL的值是否是某个正整数的2^n（n是正整数）次方，若al=10000110b，那么至少需要移位几位，通过cf的值可判断出结果？（）

A.1 B.2 C.3 D.4

Stocké dans la table des vecteurs d'interruption est ().

A. Code de type d'interruption B. Adresse du point d'arrêt C. Gestionnaire d'interruption D. Adresse d'entrée du gestionnaire d'interruption

Il est possible d'augmenter la valeur de ax de 2 fois ( ).

A. mul 2 B. mul ax,2 C. shl ax,1 D. shr ax,1

Pour 8086CPU, l'instruction correcte est ( ).

A. inc cx,1 B. shl ax,2 C. et [bp],al D. mov [bx][bp],ax

Pour utiliser la commande t dans le débogage, l'instruction correcte est ( ).

A. Peut déclencher une interruption en une seule étape B. Exécutera l'intégralité du programme C. Une seule instruction peut être exécutée

D. Après avoir exécuté les deux instructions "mov ax,4c00h" et "int 21h" en séquence, le programme retourne

mov hache, 4c00h

int 21h

La fonction de ce programme est ( ).

Appelez la fonction 4c00h de la routine d'interruption 21h
indique au compilateur que le programme se termine ici
retour au DOS
Aucune des trois premières options n'est correcte

L'énoncé correct est ( ).

A. Ce code peut être utilisé pour lire les informations sur l'année dans le CMOS

mobile,9

en 70h,al

dehors al,71h

B. Dans l'instruction de décalage, vous pouvez utiliser bl pour stocker un numéro de décalage supérieur à 1

C. Utilisez la commande shl pour décaler al, faites attention à l'impact sur la valeur de ah

D. Code ASCII du nombre décimal = code BCD du nombre décimal + 30h

E. L'étiquette d'adresse suivie de ":" peut être écrite dans tous les segments

F. L'étiquette de données ne peut être écrite que dans le segment de données

2. Utilisez une instruction pour écrire les fonctions spécifiées ci-dessous

Multipliez la valeur du registre AL par 8.
Tronquez les 4 bits inférieurs du registre BL.
Réglez le bit D14 du registre CX sur 1 et laissez le reste des bits inchangé.
Utiliser le mode d'adressage index de base des registres BX et SI pour ajouter un octet en mémoire au contenu du registre AL et le sauvegarder dans le registre AL.
On sait (AL) = 03H, et le code des 4 bits inférieurs dans AL est inversé au moyen de l'instruction, tandis que les 4 bits supérieurs du code restent inchangés.
Complete efface AX et efface le bit d'indicateur CF.
Le contenu de AX est incrémenté de 1. L'exigence n'affecte pas les FC.
Envoyer 25H au registre AL.
Multipliez le contenu AL par 2.
Le contenu AL est multiplié par le contenu BL.
Testez si le bit le plus bas de AL est 1.
Remplacez le contenu AL par le code ASCII correspondant
Ajoutez un mot dans le registre au contenu du registre CX avec le mode d'adressage relatif du registre de BX et le déplacement 0B2H, et renvoyez le résultat à la mémoire.
La valeur du registre AX est sauvegardée sur la pile.
Effacer les bits D6 et D2 de AL ;
Multipliez la valeur du registre CX par 2.
Décrémenter 1 à partir de la valeur du registre BL.
Le contenu de AX est augmenté de 1, et l'exigence n'affecte pas CF.
Inverser le bit D4 du registre BX.
Effacez les 4 bits supérieurs du registre AX à 0.
Ajoutez le numéro 0A0H au contenu du registre AL et renvoyez le résultat à AL.

3. Analyse du programme

Le programme suivant calcule 28, choisissez un programme d'achèvement de données. ( )

supposons cs：code

segment de code

start： mov hache, 2

mov cx, _____

s： ajouter hache, hache

boucles

mov hache, 4c00h

int 21h

le code se termine

fin début

8 B. 7 C. 4 D. 128

Après l'exécution du programme suivant, AX=( ).

supposons cs：code

segment de code

start： mov hache, 2

mov bx, 2

mov cx,0

s： ajouter hache, bx

boucles

mov hache, 4c00h

int 21h

le code se termine

fin début

A. 2 B. 4 C. 0FFFEH D. 0FFFCH

Une fois les instructions suivantes exécutées, le contenu de l'unité de mémoire 10000H~10006H est ( ).

mov ax,1000H
    mov ds,ax
    mov bx,0000H
    mov ax,3e88H
    mov [bx],ax
    inc bx
    inc bx
    mov [bx],ah
    mov ah,0
    inc bx
    mov [bx],ax
    inc bx
    mov [bx] ,ax
    mov ax,ds：[1]
    inc bx
    inc bx
    mov [bx],ax

A.88H,3eH,3eH,88H,88H,00H,3eH

B.88H, 3eH, 3eH, 88H, 00H, 88H, 00H

C.88H, 3eH, 3eH, 88H, 00H, 3eH, 3eH

D.88H,3eH,3eH,88H,88H,3eH,3eH

Complétez le programme suivant, calculez la valeur de 00101000h-00202000h, et enregistrez le bit haut du résultat du calcul dans AX, et enregistrez le bit bas dans BX. ( )

Mov hache, 0010h

Boîte de mouvement, 1000h

___________

A.Sub bx, 2000h B.Sbb bx, 2000h

Sous-axe, 0020h Sous-axe, 0020

C.Sub bx, 2000h D.Sbb bx, 2000h

Hache Sbb,0020h Hache Sbb,0020h

Terminer le programme afin qu'il puisse réaliser la somme de toutes les données BYTE dans le .SUM=string STR. ( )

ASSUME CS：CODE,ES：DATA

DATA SEGMENT

STR DB 'NULL POINTER ASSIGNMENT.'

DATA ENDS

CODE SEGMENT

SUM DW 0

START：MOV AX,DATA

MOV ____,AX

MOV SI,0

MOV CX,24

S：MOV AL,STR[SI]

ADD ____,AL

ADC BYTE PTR SUM[1],0

LOOP S

MOV AX,4C00H

INT 21H

CODE ENDS

END START

A.ds，SUM[2] B.es，SUM[2]

C.es，byte ptr SUM[0] D.ds，byte ptr SUM[0]

以下程序实现.将data段中的大写字母转换为小写，小写字母转换为大写。补全程序。（）

ASSUME CS：CODE

DATA SEGMENT

DB "heLLo"

DATA ENDS

CODE SEGMENT

START：MOV AX,DATA

MOV DS,AX

MOV BX,0

MOV CX,5

S：ADD BYTE PTR [BX],00100000B

AND BYTE PTR [BX],_________

OR BYTE PTR [BX],01000000B

INC BX

LOOP S

MOV AX,4C00H

INT 21H

CODE ENDS

END START

A.01h B.00h C.80h D.7fh E.前几个选项都不对

下面的程序统计1000：0处的32个字节型整数中，其值在[-64,-16]中的数据的个数，结果存在DX中。补全这个程序。（）

mov ax,1000h

mov ds,ax

mov bx,0

mov dx,0

mov cx32

s：mouvement,0

________

cmp al,16

________

cmp al, 64

________

inc dx

s0： inc bx

boucles

ou al,[bx]；jmp ax；shr al,1
ajouter al,[bx]；jnb s0；jna s0
et al,[bx]；est s0；est s
sous al,[bx]；jb s0；ja s0

E．Aucune des options précédentes n'est correcte.

Complétez le programme pour qu'il puisse copier "assembly" dans l'espace mémoire à 0:200. ( )

supposons cs：code,ds：données

segments de données

db 'assemblage'

les données se terminent

segment de code

commencer:

mov hache, données

mov ds, hache

bouge toi___

mov hache,0

mov es,ax

passer par, ___

mov cx, ___

std

représentant movsw

mov hache, 4c00h

int 21h

le code se termine

fin début

A.6，206h，4

B.8，208h，4

C.0，200h，8

D.0，200h，4

Complétez le programme afin que (AX)=2^10 puisse être réalisé. ( )

mov hache, 2

mov cx, ___

s： ajouter hache, hache

boucles

A.8 B.9 C.10 D.11

Après l'exécution du programme suivant, la valeur de ax est ( ).

mov hache,0

pousser la hache

populaire

mov hache, 0fff0h

ajouter une hache, 88h

pousser

pop hache

et al,11000101b

et ah, 10001000b

Ref.Flags Registre

15	14	13	12	11	dix	9	8	7	6	5	4	3	2	1	0
				DE	DF	SI	TF	SF	ZF		DE		FP		FC

A. 1h B. 804h C. 5h D. 前三个选项都不对

assume cs：code

stack segment

db 16 dup(0)

stack ends

code segment

start： mov ax,stack

mov ss,ax

mov sp,16

mov ax,sp

push cs

call s

sub ax,sp

s：pop ax

mov ax,4c00h

int 21h

code ends

end start

这个程序加载到内存后，其一段程序所在的内存空间的情况如下：

内存地址机器码所对应的源程序中的指令

1000：0008 8BC4 mov ax,sp

1000：000A 0E push cs

1000：000B E80200 call s

1000：000E 2BC4 sub ax,sp

1000：0010 58 s：pop ax

执行这个程序，“pop ax”执行后，ax的值为（）。

A. 8h B. 0bh C. 0eh D. 1000h E. 2 F. 10h

以下程序计算(345-333)^2，结果存在dx.ax中。补全这个程序。（）

assume cs：code

code segment

start： mov ax,333

push ax

mov ax,345

push ax

call calc

mov ax,4c00h

int 21h

calc： push bp

mov bp,sp

mov ax,_____

sub ax,_____

mov bp,ax

mul bp

pop bp

ret 4

code ends

end start

A.[bp+6]，[bp+8] B.[bp+4]，[bp+6]

C.[bp+2]，[bp+4] D.[bp+4]，[bp+2]

以下程序统计0f123：0处的32个字节中，大小在(15，100]的数据的个数，结果存在dx中。补全这个程序。（）

mov hache, 0f123h

mov ds, hache

mov bx,0

mov dx,0

mov cx32

s：mov al,[bx]

cmp al,15

_________

cmp al, 100

_________

inc dx

s0：inc bx

boucles

A. jna s0，jnb s0 B. ja s0，jb s0

C. jnb s0，jna s0 D. jna s0，ja s0

Quand le programme suivant est exécuté jusqu'à (cx)=0, combien de fois le CPU modifie-t-il l'IP ? ( )

mov cx, 2

s： mov hache, bx

boucles

A. 3 B. 5 C. 6 D. 7 E. 8 F. 9

Vérifiez la mémoire avec debug, le résultat est le suivant.

2000 : 0200 00 01 02 03 04 05 06 07-08 09 0A 0B 0C 0D 0E 0F
2000 : 0210 10 11 12 13 14 15 16 17-18 19 1A 1B 1C 1D 1E 1F

Après le programme suivant est exécuté, hache, cx , Le contenu de dx est ( ) à son tour.

mov hache, 1fffh

mov ds, hache

mov ss, hache

mov bx, 210h

mov sp, bx

mov hache,[bx]

mov cx,[bx+12h]

pop-dx

A. inconnu, inconnu, inconnu B. 0100h, 1312h, inconnu

C.0001h，1213h，1415h D.0100h，1312h，0100h

Compléter le programme pour qu'il puisse être réalisé Accumuler 8 données en a, et mémoriser le résultat dans le mot double en b. ( )

supposons cs：code,ds：données

segments de données

un dw 1,2,3,4,5,6,7,8

b jj 0

c dw a,b

les données se terminent

segment de code

.......

mov hache, 4c00h

int 21h

le code se termine

fin début

A. start： mov hache, données

mov ds, hache

mov si,0

mov cx, 8

s： mov ax,a[si]

add b[0],ax

adc b[2],ax

add si,2

loop s

B. start： mov si,0

mov cx,8

s： mov ax,a[si]

add word ptr b[0],ax

adc word ptr b[2],0

add si,1

loop s

C. start： mov ax,seg a

mov ds,ax

mov si,0

mov cx,8

s： mov ax,a[si]

mov bx,offset b

add word ptr[bx],ax

adc word ptr 2[bx],0

add si,2

loop s

D. start： mov ax,data

mov ds,ax

mov si,0

mov cx,8

s： mov ax,a[si]

mov bx,word ptr c[0]

add word ptr [bx],ax

mov bx,word ptr c[2]

adc word ptr[bx],0

add si,2

loop s

补全程序，使其可以实现.将data段中的字符串转化为大写。（）

assume cs：code

data segment

db 'conversation',0

data ends

code segment

start：

mov ax,data

mov ds,ax

mov si,0

mov cx,12

call capital

mov ax,4c00h

int 21h

capital：

......

code ends

end start

A. or byte ptr [si],00100000b

inc si

loop capital

ret

B. mov cl,[si]

mov ch,0

jcxz ok

sub word ptr [si],20h

inc si

jmp short capital

ok： ret

C. mov cl,11011111b

s： push cx

and byte ptr [si],cl

inc si

pop cx

loop s

ok： ret

D. mov cl,[si]

mov ch,0

inc cx

loop ok

ret

ok： and byte ptr [si],11011111b

inc si

jmp capital

以下程序中所有的转移指令的机器码都是两个字节。用一条指令补全程序，使其可以由代码段中的程序段返回。（）

assume cs：code

code segment

mov ax,4c00h

int 21h

commencer:

non

pousser cs

pop ds

mov si, décalage o

mov di, début décalé

mov hache,ds：[si]

mov ds：[de],hache

mov cx,-2

s：

_____________

début jcxz

o： boucle s

le code se termine

fin début

A.ajouter cx,2 (code machine : 83H C1H 02H)

B.add cx,1 (code machine : 83H C1H 01H)

C.inc cx (code machine : 41H)

D. Aucune des réponses ci-dessus n'est correcte

Vérifiez l'unité de mémoire avec le débogage, les résultats sont les suivants. Exécutez ensuite le programme suivant, quelle est la valeur de ax ? ( )

1100：F000 BE 00 06 00 6A 22

MOUVEMENT AXE, 2000H

MOV DS,AX

MOV BX, 0000H

MV SI,0

MOV AX,2[BX][SI]

INC OUI

AJOUTER AX,2[BX][SI]

INC OUI

MOUVEMENT DE,OUI

SOUS AXE,2[BX][DI]

A.9c06h B.479ch C.7006h D.8c70h

Après l'exécution du programme suivant, quelle est la valeur de ax ?

adresse mémoire code machine instruction d'assemblage

1000:0 b8 00 00 mouvement hache,0

1000:3 e8 01 00 appel s

1000:6 40 inc hache

1000:7 58 s : hache pop

Après l'exécution du programme suivant, quelle est la valeur de ax ?

adresse mémoire code machine instruction d'assemblage

1000:0 b8 00 00 mouvement hache,0

1000:3 9a 09 00 00 10 appel lointain ptr s

1000:8 40 inc hache

1000:9 58 s : hache pop

ajouter hache, hache

boîte de pop

ajouter hache, bx

Après l'exécution du programme suivant, quelle est la valeur de ax ?

adresse mémoire code machine instruction d'assemblage

1000:0 b8 06 00 mov hache,6

1000:2 ff d0 call ax

1000:5 40 inc hache

1000:6 mov bp,sp

ajouter une hache,[bp]

La procédure est la suivante.

assumer cs: code

segments de données

？

les données se terminent

segment de code

début : mouvement de la hache, données

mov ds, hache

mov bx,0

mot jmp ptr [bx+1]

le code se termine

fin début

Pour que CS:IP pointe vers la première instruction du programme après l'exécution de l'instruction jmp dans le programme, quelles données doivent être définies dans la section data ?

La procédure est la suivante.

supposons que cs:code,ds:data

segments de données

jj 12345678h

les données se terminent

segment de code

début : mouvement de la hache, données

mov ds, hache

mov bx,0

mov [bx],_______

mouv [bx+2],_________

jmp dword ptr ds:[0]

le code se termine

fin début

Terminez le programme de sorte qu'après l'exécution de l'instruction jmp, CS:IP pointe vers la première instruction du programme.

Vérifiez la mémoire avec Debug, les résultats sont les suivants :

2000:1000 BE 00 06 00 00 00 ......

A ce moment, le CPU exécute l'instruction :

mov hache, 2000H

mov es,ax

jmp dword ptr es:[1000H]

Après cela, (CS)=? , (IP)=?

Complétez le programme ci-dessous, comptez le nombre de données dans [32,128] dans les 32 octets à F000:0.

mov hache, 0f000h
mov ds, hache

mov bx,0
mov dx,0
mov cx,32
s:mov al,[bx]
cmp al,32
_________

cmp al,120
__________

inc dx
s0:inc bx
boucle s

Complétez le programme suivant et comptez le nombre de données dont la taille est (32 128) parmi les 32 octets à F000:0.

mov hache, 0f000h
mov ds, hache

mov bx,0
mov dx,0
mov cx,32
s:mov al,[bx]
cmp al,32
__________

cmp al,120
___________

inc dx
s0:inc bx
boucle s

Expérience 1 ~ Expérience 9

王爽《汇编语言》期末考试题库（附答案）

Chapitre 7-8 (Modes d'adressage)

Chapitres 9-10

第11章

Chapitre 12 et au-delà

Je suppose que tu aimes