diレジスタから変数へmovを使用すると値が変化します

Question

私のコードに問題があります。

DIレジスタの値を、という変数に移動しようとしています。です。 DIレジスタに入る値は、0,1,2,3（ランダムに選択）のいずれかになりますが、varに移動すると、値は514に変わります（私はデバッガの時計機能を使用してそれを参照してください）。
問題は行440の「ゲーム」ラベルの下にあります。あなたは単語（16B）から[ARRの+のSI]をフェッチしているので、

IDEAL 
    MODEL small 
    STACK 100h 
    DATASEG 
    x dw 80 
    y dw 64 
    green db 2 
    red db 4 
    yellow db 14 
    blue db 1 
    white db 15 
    arr dw 11 dup(4) 
    Clock equ es:6Ch 
    hold db 0 
    key db 0 
    marker dw 0 
    var dw ? 
    CODESEG 
    proc YellowP 
     mov[x], 80 
     mov[y], 64 
     yLoop: 
      mov bh,0h 
      mov cx,[x] 
      mov dx,[y] 
      mov al,[yellow] 
      mov ah,0ch 
      int 10h 
      inc [x] 
      cmp cx, 112 
      jl yLoop  
     ySquare: 
      mov bh, 0h 
      inc [y] 
      mov [x], 80 
      cmp dx, 96 
      jl yLoop 
     ret 
     endp YellowP 
    proc BlueP 
     mov[x], 113 
     mov[y], 64  
     bLoop: 
      mov bh, 0h 
      mov cx, [x] 
      mov dx, [y] 
      mov al, [blue] 
      mov ah, 0ch 
      int 10h 
      inc [x] 
      cmp cx, 144 
      jl bLoop  
     bSquare: 
      mov bh, 0h 
      inc [y] 
      mov [x], 113 
      cmp dx, 96 
      jl bLoop 
     ret 
     endp BlueP 
    proc GreenP 
     mov[x],80 
     mov[y],32 
     gLoop: 
      mov bh, 0h 
      mov cx, [x] 
      mov dx, [y] 
      mov al, [green] 
      mov ah, 0ch 
      int 10h 
      inc [x] 
      cmp cx, 112 
      jl gLoop  
     gSquare: 
      mov bh, 0h 
      inc [y] 
      mov [x], 80 
      cmp dx, 64 
      jl gLoop 
     ret 
     endp GreenP 
    proc RedP 
     mov[x],112 
     mov[y],32 
     rLoop: 
      mov bh, 0h 
      mov cx, [x] 
      mov dx, [y] 
      mov al, [red] 
      mov ah, 0ch 
      int 10h 
      inc [x] 
      cmp cx, 144 
      jl rLoop  
     rSquare: 
      mov bh, 0h 
      inc [y] 
      mov [x], 112 
      cmp dx, 64 
      jl rLoop 
     ret 
     endp RedP 
    ;=============================================================== 
    ;=============================================================== 
    proc Random 
     RND: 
      mov ax, 40h 
      mov es, ax 
      mov ax, [es:6Ch] 
      and al, 00000011b 
      xor ah, ah 
      mov di, ax 
      cmp al, 0 
      je GreenPress 
      cmp al, 1 
      je RedPress 
      cmp al, 2 
      je YellowPress 
      jg BlueMid 
     GreenPress: 
      mov[x],80 
      mov[y],32 
      g2Loop: 
       mov bh, 0h 
       mov cx, [x] 
       mov dx, [y] 
       mov al, [white] 
       mov ah, 0ch 
       int 10h 
       inc [x] 
       cmp cx, 112 
       jl g2Loop 
      g2Square: 
       mov bh, 0h 
       inc [y] 
       mov [x], 80 
       cmp dx, 64 
       jl g2Loop 
     ret 
     RedPress: 
      mov[x],112 
      mov[y],32 
      r2Loop: 
       mov bh, 0h 
       mov cx, [x] 
       mov dx, [y] 
       mov al, [white] 
       mov ah, 0ch 
       int 10h 
       inc [x] 
       cmp cx, 144 
       jl r2Loop 
      r2Square: 
       mov bh, 0h 
       inc [y] 
       mov [x], 112 
       cmp dx, 64 
       jl r2Loop 
     ret 
     BlueMid: 
      jmp BluePress 
     YellowPress: 
      mov[x], 80 
      mov[y], 64 
      y2Loop: 
       mov bh,0h 
       mov cx,[x] 
       mov dx,[y] 
       mov al,[white] 
       mov ah,0ch 
       int 10h 
       inc [x] 
       cmp cx, 112 
       jl y2Loop 
      y2Square: 
       mov bh, 0h 
       inc [y] 
       mov [x], 80 
       cmp dx, 96 
       jl y2Loop 
     ret  
     BluePress: 
      mov[x], 113 
      mov[y], 64 
      b2Loop: 
       mov bh, 0h 
       mov cx, [x] 
       mov dx, [y] 
       mov al, [white] 
       mov ah, 0ch 
       int 10h 
       inc [x] 
       cmp cx, 144 
       jl b2Loop 
      b2Square: 
       mov bh, 0h 
       inc [y] 
       mov [x], 113 
       cmp dx, 96 
       jl b2Loop 
     ret 
     endp Random 
    proc second 
     mov ax, 40h 
     mov es, ax 
     mov ax, [Clock] 
     FirstTick: 
     cmp ax, [Clock] 
     je FirstTick 
     mov cx, 9 
     DelayLoop: 
      mov ax, [Clock] 
     Tick: 
     cmp ax, [Clock] 
     je Tick 
     loop DelayLoop 
     ret 
     endp second 
    ;=============================================================== 
    ;=============================================================== 
    proc Gpress 
      mov[x],80 
      mov[y],32 
      g3Loop: 
       mov bh, 0h 
       mov cx, [x] 
       mov dx, [y] 
       mov al, [white] 
       mov ah, 0ch 
       int 10h 
       inc [x] 
       cmp cx, 112 
       jl g3Loop 
      g3Square: 
       mov bh, 0h 
       inc [y] 
       mov [x], 80 
       cmp dx, 64 
       jl g3Loop 
      ret 
      endp Gpress 
    proc Rpress 
     mov[x],112 
     mov[y],32 
     r3Loop: 
      mov bh, 0h 
      mov cx, [x] 
      mov dx, [y] 
      mov al, [white] 
      mov ah, 0ch 
      int 10h 
      inc [x] 
      cmp cx, 144 
      jl r3Loop 
     r3Square: 
      mov bh, 0h 
      inc [y] 
      mov [x], 112 
      cmp dx, 64 
      jl r3Loop 
     ret 
     endp Rpress 
    proc Ypress 
     mov[x], 80 
     mov[y], 64 
     y3Loop: 
      mov bh,0h 
      mov cx,[x] 
      mov dx,[y] 
      mov al,[white] 
      mov ah,0ch 
      int 10h 
      inc [x] 
      cmp cx, 112 
      jl y3Loop 
     y3Square: 
      mov bh, 0h 
      inc [y] 
      mov [x], 80 
      cmp dx, 96 
      jl y3Loop 
     ret 
     endp Ypress 
    proc Bpress 
     mov[x], 113 
     mov[y], 64 
     b3Loop: 
      mov bh, 0h 
      mov cx, [x] 
      mov dx, [y] 
      mov al, [white] 
      mov ah, 0ch 
      int 10h 
      inc [x] 
      cmp cx, 144 
      jl b3Loop 
     b3Square: 
      mov bh, 0h 
      inc [y] 
      mov [x], 113 
      cmp dx, 96 
      jl b3Loop 
     ret 
     endp Bpress 
    proc RNDsquare 
     call second 
     call random 
     call second 
     cmp di, 0 
     je aG 
     cmp di, 1 
     je aR 
     cmp di, 2 
     je aY 
     jg aB 
     aG: 
      call GreenP 
      jmp endproc 
     aR: 
      call RedP 
      jmp endproc 
     aY: 
      call YellowP 
      jmp endproc 
     aB: 
      call BlueP 
      jmp endproc 
     endproc: 
      ret 
      endp RNDsquare 
    proc CheckArr 
     mov si, 0 
     check: 
      cmp [arr + si], 0 
      je tempo1 
      cmp [arr + si], 1 
      je tempo2 
      cmp [arr + si], 2 
      je tempo3 
      cmp [arr + si], 3 
      je tempo4 
      jg tempo 
      tempo1: 
       call second 
       call Gpress 
       call second 
       call GreenP 
       inc si 
       jmp check 
      tempo2: 
       call second 
       call Rpress 
       call second 
       call RedP 
       inc si 
       jmp check 
      tempo3: 
       call second 
       call Ypress 
       call second 
       call YellowP 
       inc si 
       jmp check 
      tempo4: 
       call second 
       call Bpress 
       call second 
       call BlueP 
       inc si 
       jmp check 
      tempo: 
       mov si, 0 
       ret 
       endp CheckArr 
    ;=============================================================== 
    ;===============================================================        
    start: 
    mov ax, @data 
    mov ds, ax 
    ; Graphic mode 
    mov ax, 13h 
    int 10h 
    call YellowP 
    call GreenP 
    call BlueP 
    call RedP 
    call RNDsquare 
    mov [arr + 0], di 
    mov ah, 1 
    int 21h 
    mov [key], al 
    cmp di, 0 
    je temp1 
    cmp di, 1 
    je temp2 
    cmp di, 2 
    je temp3 
    jg temp4 
    temp1: 
     cmp [key], 113 
     jne nextmid 
     call Gpress 
     call second 
     call GreenP 
     je prog 
    temp2: 
     cmp [key], 119 
     jne nextmid 
     call Rpress 
     call second 
     call RedP 
     je prog 
    temp3: 
     cmp [key], 97 
     jne nextmid 
     call Ypress 
     call second 
     call YellowP 
     je prog 
    temp4: 
     cmp [key], 115 
     jne nextmid 
     call Bpress 
     call second 
     call BlueP 
     je prog 
    ;=========================================after round 1 
    nextmid: 
     jmp next 
    prog: 
     call CheckArr 
     cmp [arr + 12], 4 
     jne nextmid2 
     inc [marker] 
     mov si, [marker] 
     call RNDsquare 
     mov [arr + si], di 
     mov si, 0 
    game: 
     mov di, [arr + si] 
     mov [var], di 
     cmp [var], 0 
     je game0 
     cmp [var], 1 
     je game1 
     cmp [var], 2 
     je game2 
     cmp [var], 3 
     je game3 
     jmp prog 
     game0: 
      mov ah, 1 
      int 21h 
      cmp al, 113 
      jne next 
      call Gpress 
      call second 
      call GreenP 
      inc si 
      jmp game 
     game1: 
      mov ah, 1 
      int 21h 
      cmp al, 119 
      jne next 
      call Rpress 
      call second 
      call RedP 
      inc si 
      jmp game 
    nextmid2: 
     jmp next 
     game2: 
      mov ah, 1 
      int 21h 
      cmp al, 97 
      jne next 
      call Ypress 
      call second 
      call YellowP 
      inc si 
      jmp game 
     game3: 
      mov ah, 1 
      int 21h 
      cmp al, 115 
      jne next 
      call Bpress 
      call second 
      call BlueP 
      inc si 
      jmp game 
    next: 
     ; Wait for key press 
     mov ah,00h 
     int 16h 
     ; Return to text mode 
     mov ah, 0 
     mov al, 2 
     int 10h 
    exit: 
     mov ax, 4c00h 
     int 21h 
    END start 

Answer 1

game:

mov di, [arr + si] 
    mov [var], di 

di以下簡単に見てからわずかの推測では、登録16bがあり、そしてあなたはそこに数を用意しランダム0-3 バイト（8b）だと思いますか？

514は0x0202ですが、実際には2バイトの2のように見えます。

あなたvarが16Bである、とarrは8bのソースであれば、あなたが使用し、その後、様々な方法でそれを修正することができます：

movzx di, byte [arr + si] ; fetch only 8b from [] 
     ; and extend them to 16b with zeroes (zx = zero extended) 
     ; (similar instruction movsx extends with sign bit) 
    mov [var], di ; store the converted 0-3 16b value to var 

---

編集： あなたarr dw 11 dup(4)定義はARRを意味している示唆しているが16b配列として使用することができます。実際の問題はおそらくランダム0-3ジェネレータにあり、ワードの代わりにバイトを格納しています。この修正は、gameラベルの下では必要ありませんが、他の場所（arrジェネレータを検索するのは気にしません）です。

Answer 2

arr dw 11 dup(4) 

あなたのプログラムの基本的な問題は、あなたが、配列ARRとして単語を定義した、まだそれは、バイトが含まれているかのようあなたが繰り返し配列を反復処理することです。
アレイを再定義するのが最適であり、他の多くの変更を避けることができます。だから私はDIレジスタを使用し続けることができるようにシンプルなソリューションを提案：

arr db 11 dup(4) 
... 
game: 
    mov di, [arr + si] 
    and di, 255  <<<< removes the garbage high byte! 
    mov [var], di 

この道をmov di, [arr + si]命令は悲しげにゴミバイトを読み込みますが、以下のand di, 255はそれを離れてきれいにします。シンプルで最小の労力で。

プログラムには、配列に書き込む場所が1つあります。 DIの登録だけでもうオプションはできません。代わりに、バイトサイズのレジスタを使用する必要があります：私は、配列の大きさが十分であるとは思わない

mov ax, di   ;Temporarily copy to splittable register 
    mov [arr + si], al ;Only write the low byte 
    mov si, 0 
game: 

---

。ある行で、あなたはcmp [arr + 12], 4と書きました。これは意味をなさない！ワードサイズの配列では、中間のどこかを指し、バイトサイズの配列では配列を指します。
という値で配列を初期化したということは、配列の最後の要素をチェックする必要があることを意味します。これは、11要素のバイトサイズの配列でオフセット10になります。

arr db 11 dup(4) 
... 
prog: 
    call CheckArr 
    cmp [arr + 10], 4 <<< checks last element!