为什么 mov sp, 32，debug程序，执行sp=32的位置，后面的代码就全乱了

SimonY

为什么 mov sp, 32，debug程序，执行sp=32的位置，后面的代码就全乱了（在小甲鱼零基础汇编第6章，包含多段程序，的视频代码）

1. assume cs:code, ds:data, ss:stack
   
2. 
   
3. 
   
4. data segment
   
5.         dw 0123h, 0456h, 0789h, 0abch, 0defh, 0fedh, 0cbah, 0987h; 用来作存放数据
   
6. data ends
   
7. 
   
8. 
   
9. stack segment
   
10.         dw 0, 0, 0, 0, 0, 0, 0, 0; 用来作栈的空间
    
11. stack ends       
    
12. 
    
13. 
    
14. code segment
    
15.        
    
16. start:
    
17.        
    
18.         ; 设置数据段
    
19.         mov ax, data
    
20.         mov ds, ax       
    
21.        
    
22.         ; 设置栈段
    
23.         mov ax, stack
    
24.         mov ss, ax
    
25.         mov sp, 32 ; 只要不设置为32都能正常运行
    
26.        
    
27.         ; 将8个字都压入栈
    
28.         mov bx, 0
    
29.         mov cx, 8
    
30. s:        push [bx];
    
31.         add bx, 2
    
32.         loop s
    
33.        
    
34.         ; 将8个字都弹出栈
    
35.         mov bx, 0
    
36.         mov cx, 8
    
37. s0:        pop [bx]
    
38.         add bx, 2
    
39.         loop s0
    
40.        
    
41.        
    
42.         mov ax, 4c00h
    
43.         int 21h
    
44. 
    
45. code ends
    
46. 
    
47. end start

复制代码

初始情况

                               
登录/注册后可看大图

执行完 mov ss, ax后

                               
登录/注册后可看大图

对比图

                               
登录/注册后可看大图

FishC

在汇编语言中，`mov sp, 32` 是将32赋值给堆栈指针（Stack Pointer，简称SP）。SP的作用是指示当前栈顶的位置。

在你的代码中，你使用了 `mov sp, 16` 来初始化SP，然后在压栈和弹栈之前没有对SP进行适当的调整。所以当你执行 `mov sp, 32` 后，栈顶位置发生了变化，导致接下来的压栈和弹栈操作都出错了。

为了解决这个问题，你需要在执行完 `mov sp, 16` 后，通过增加或减少SP来调整栈顶位置。例如，在开始压栈之前，你可以先执行 `add sp, 16` 来将栈顶位置向上移动16个字节。然后在弹栈操作之前，你可以执行 `sub sp, 16` 来将栈顶位置恢复到之前的位置。

以下是修改后的代码：

1. start:
   
2.        
   
3.         ; 设置数据段
   
4.         mov ax, data
   
5.         mov ds, ax       
   
6.        
   
7.         ; 设置栈段
   
8.         mov ax, stack
   
9.         mov ss, ax
   
10.         mov sp, 16
    
11.        
    
12.         ; 将栈顶位置向上移动16个字节
    
13.         add sp, 16
    
14.        
    
15.         ; 将8个字都压入栈
    
16.         mov bx, 0
    
17.         mov cx, 8
    
18. s:        push ;
    
19.         add bx, 2
    
20.         loop s
    
21.        
    
22.         ; 将栈顶位置恢复到之前的位置
    
23.         sub sp, 16
    
24.        
    
25.         ; 将8个字都弹出栈
    
26.         mov bx, 0
    
27.         mov cx, 8
    
28. s0:        pop
    
29.         add bx, 2
    
30.         loop s0
    
31.        
    
32.        
    
33.         mov ax, 4c00h
    
34.         int 21h
    
35. 
    
36. code ends
    
37. 
    
38. end start

复制代码

现在，你的代码应该能够正确地压栈和弹栈，而不会出现错误。请记住，在进行堆栈操作时，始终确保栈顶位置的正确性，以免导致程序出错。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。