assembly Motorola 68000汇编代码：未显示在Easy68k模拟器应用程序中

yshpjwxd  于 2023-11-19  发布在  其他
关注(0)|答案(1)|浏览(187)

说明：程序演示了一个简化的printf函数（printg），它是硬编码的，什么都没有播放。我不知道为什么。

  1. ORG     $8000
  3. START:
  4.         ; Push parameters onto the stack (right-to-left)
  5.         MOVE.L  #300, -(SP)    ; Push the sixth number
  6.         MOVE.L  #11, -(SP)     ; Push the fifth number
  7.         MOVE.L  #134212, -(SP) ; Push the fourth number
  8.         MOVE.L  #92, -(SP)     ; Push the third number
  9.         MOVE.L  #51, -(SP)     ; Push the second number
  10.         MOVE.L  #23, -(SP)     ; Push the first number
  12.         ; Push the address of the format string onto the stack
  13.         LEA     FMT, A0       ; Load the address of FMT into A0
  14.         MOVE.L  A0, -(SP)     ; Push the address onto the stack
  16.         ; Call printg subroutine
  17.         BSR     printg
  19.         ; Clean up the stack
  20.         ADDA.L  #28, SP       ; Remove all six 32-bit numbers and the format string address
  22.         ; Rest of the program or exit
  23.         SIMHALT             ; Stop simulation
  25. printg:
  26.         ; Save registers that will be used
  27.         MOVE.L  A0, -(SP)     ; Save A0
  28.         MOVE.L  D0, -(SP)     ; Save D0
  29.         MOVE.L  D1, -(SP)     ; Save D1
  31.         ; Call LENGTH to get the number of integers to print
  32.         MOVEA.L 8(SP), A0     ; Move the address of the format string into A0
  33.         BSR     LENGTH        ; Call LENGTH, result will be in D0
  34.         MOVE.B  D0, D1        ; Store the number of integers in D1
  36.         ; Calculate the starting address of the integers on the stack
  37.         ADDA.L  #4, SP        ; Adjust stack pointer to the first integer
  39. PRINT_LOOP:
  40.         ; Check if we have processed all format characters
  41.         DBF     D1, END_PRINT ; Decrement D1 and branch if D1 is -1
  43.         ; Get the next format character
  44.         MOVE.B  (A0)+, D0     ; Move the next format character into D0
  46.         ; Determine the base for the DISPLAY subroutine
  47.         CMP.B   #'B', D0
  48.         BEQ     DISPLAY_BINARY
  49.         CMP.B   #'0', D0
  50.         BEQ     DISPLAY_OCTAL
  51.         CMP.B   #'D', D0
  52.         BEQ     DISPLAY_DECIMAL
  53.         CMP.B   #'H', D0
  54.         BEQ     DISPLAY_HEXADECIMAL
  55.         BRA     PRINT_LOOP    ; If the character is not B, O, D, or H, skip it
  57. DISPLAY_BINARY:
  58.         MOVE.B  #2, -(SP)     ; Push base 2 for binary
  59.         BRA     CALL_DISPLAY
  60. DISPLAY_OCTAL:
  61.         MOVE.B  #8, -(SP)     ; Push base 8 for octal
  62.         BRA     CALL_DISPLAY
  63. DISPLAY_DECIMAL:
  64.         MOVE.B  #10, -(SP)    ; Push base 10 for decimal
  65.         BRA     CALL_DISPLAY
  66. DISPLAY_HEXADECIMAL:
  67.         MOVE.B  #16, -(SP)    ; Push base 16 for hexadecimal
  69. CALL_DISPLAY:
  70.     ; Calculate the offset for the current integer
  71.     MOVE.L  D1, D2           ; Copy the index to D2
  72.     LSL.L   #2, D2           ; Multiply the index by 4 to get the byte offset
  73.     LEA     (SP), A1         ; Load the address of the first integer into A1
  74.     ADDA.L  D2, A1           ; Add the offset to the address
  75.     MOVE.L  (A1), D1         ; Move the integer at the calculated offset into D1
  76.     MOVE.L  D2, -(SP)        ; Push the base onto the stack
  77.     MOVE.L  D1, -(SP)        ; Push the integer onto the stack
  78.     BSR     DISPLAY          ; Call DISPLAY subroutine
  79.     ADDA.L  #8, SP           ; Clean up the stack (base + integer)
  80.     BRA     PRINT_LOOP       ; Process the next character
  82. END_PRINT:
  83.         ; Restore the original stack pointer position
  84.         SUBA.L  #4, SP        ; Adjust stack pointer back to the format string address
  86.         ; Restore registers
  87.         MOVE.L  (SP)+, D1     ; Restore D1
  88.         MOVE.L  (SP)+, D0     ; Restore D0
  89.         MOVE.L  (SP)+, A0     ; Restore A0
  90.         RTS                    ; Return from subroutine
  92. LENGTH:
  93.         MOVE.L  A0, -(SP)     ; Save A0 on the stack
  94.         CLR.B   D0            ; Initialize the length counter to 0
  96. LENGTH_LOOP:
  97.         MOVE.B  (A0)+, D1     ; Load the next character from the format string
  98.         BEQ     LENGTH_DONE   ; If the character is null (0), we are done
  99.         ADDQ.B  #1, D0        ; Increment the length counter
  100.         BRA     LENGTH_LOOP   ; Loop back to process the next character
  102. LENGTH_DONE:
  103.         MOVE.L  (SP)+, A0     ; Restore A0 from the stack
  104.         RTS                    ; Return from subroutine
  106. DISPLAY:
  107.     ; Save registers that will be used by TRAP #15
  108.     MOVE.L  D0, -(SP)     ; Save D0 on the stack
  109.     MOVE.L  D1, -(SP)     ; Save D1 on the stack
  111.     ; Pop the base and the number off the stack
  112.     MOVE.L  (SP)+, D2     ; Pop the base off the stack into D2
  113.     MOVE.L  (SP)+, D1     ; Pop the integer value off the stack into D1
  115.     ; Ensure D2 only contains the base in the lower byte
  116.     ANDI.L  #$FF, D2      ; Clear upper bytes of D2, leaving only the base
  118.     ; Set up for TRAP #15 to display the number
  119.     MOVE.L  D1, D1        ; Number to display
  120.     MOVE.L  D2, D2        ; Base
  121.     MOVE.W  #3, D0        ; Task number for TRAP #15
  122.     TRAP    #15           ; Execute the trap to display the number
  124.     ; Restore registers after TRAP #15
  125.     MOVE.L  (SP)+, D1     ; Restore D1
  126.     MOVE.L  (SP)+, D0     ; Restore D0
  128.     RTS                   ; Return from subroutine
  130.         ORG     $9000
  131. FMT     DC.B    'B','D','O','O','H','B',0  ; Format string for printg
  133.         END     START

字符串
我希望硬编码输出显示在输出上。

assembly

1条答案

按热度按时间
bogh5gae

bogh5gae1#

一切都是关于堆栈的

一旦到达 printg 子例程，您的堆栈就具有：

  1. 300    ; the sixth number
  2. 11     ; the fifth number
  3. 134212 ; the fourth number
  4. 92     ; the third number
  5. 51     ; the second number
  6. 23     ; the first number
  7. FMT    ; the address of FMT
  8. ?      ; the return address

字符串
然后在堆栈上保留一些寄存器：

  1. 300    ; the sixth number
  2. 11     ; the fifth number
  3. 134212 ; the fourth number
  4. 92     ; the third number
  5. 51     ; the second number
  6. 23     ; the first number        this is at 20(SP)
  7. FMT    ; the address of FMT      this is at 16(SP)
  8. ?      ; the return address
  9. ?      ; preserved A0
  10. ?      ; preserved D0
  11. ?      ; preserved D1            this is at (SP)

型

  • 第一个错误是在MOVEA.L 8(SP), A0中，你应该从堆栈中获取格式字符串的地址。在偏移量+8处，你已经存储了A0的内容，碰巧包含该地址，所以你在这一点上实际上并没有失败。正确的指令是MOVEA.L 16(SP), A0。
  • LENGTH 子例程最好不要将D 0视为字节，最好将其视为一个long，这样一旦将其完整复制到D1中，依赖于位0到15的DBF D1, END_PRINT指令就可以正确工作。
  • 当在 * BLOG_BINARY* 中推送那些基值{2，8，10，16}时，不要使用.B。始终保持堆栈指针为偶数（并使用.L以清晰地显示堆栈布局），因此使用MOVE.L #2, -(SP)等。
  • 堆栈上整数的起始地址的计算完全是假的！指令ADDA.L #4, SP ; Adjust stack pointer to the first integer不好。只要删除它。不要忘记也删除它的恢复指令SUBA.L #4, SP ; Adjust stack pointer back to the format string address进一步下降。

因为堆栈现在看起来像：

  1. 300    ; the sixth number
  2. 11     ; the fifth number
  3. 134212 ; the fourth number
  4. 92     ; the third number
  5. 51     ; the second number
  6. 23     ; the first number        this is at 24(SP)
  7. FMT    ; the address of FMT
  8. ?      ; the return address
  9. ?      ; preserved A0
  10. ?      ; preserved D0
  11. ?      ; preserved D1
  12. ?      ; the base value

型
在 *CALL_CALL * 处的代码变为：

  1. CALL_DISPLAY:
  2. ; Calculate the offset for the current integer
  3. MOVE.L  D1, D2     ; Copy the index to D2
  4. LSL.L   #2, D2     ; Multiply the index by 4 to get the byte offset
  5. LEA     24(SP), A1 ; Load the address of the first integer into A1
  6. ADDA.L  D2, A1     ; Add the offset to the address

型
第一次运行此代码段时，D1包含值5。乘以4将为已经指向第一个数字（23）的A1加上20。最终结果是第六个数字（300）是您的程序将显示的第一个数字。不知道这是否是您想要的...

  • 你用栈上的两个长参数调用 * 子例程，并立即在栈上保留D 0和D1寄存器：
  1. ?      ; the base           this is at 16(SP)     (*)
  2. ?      ; the integer        this is at 12(SP)
  3. ?      ; the return address
  4. ?      ; preserved D0
  5. ?      ; preserved D1

型
代码：

  1. MOVE.L (SP)+, D2 ; Pop the base off the stack into D2
  2.  MOVE.L (SP)+, D1 ; Pop the integer value off the stack into D1

型
是不起作用的。你将弹出你刚刚推送保存的值！使用MOVE.L 16(SP), D2和MOVE.L 12(SP), D1分别检索基数和整数。
（*）最后一个提示：你的程序将基值两次推入堆栈（相邻）。

展开查看全部
赞(0）分享  回复(0）举报  2023-11-19
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com