问题[assembly](coding)

我正在寻找一个非常简约的 ARM64 指令长度反汇编程序，以便我可以遍历函数的一些指令。
我需要一个没有太多依赖项的独立函数，因为我需要它用于内核驱动程序。

对于 x64，我使用的是https://github.com/gh-nomad/length-disassembler/blob/master/ldisasm.cpp，但我找不到适用于 AArch64 的类似程序。有一些完整的反汇编库，但它们带有大量源代码和用户空间依赖项。

我甚至不需要支持任何扩展指令集，比如 SVE

我正在编写一个简单的引导程序（希望很快能编写一个操作系统）。我一直在取得进展，但这部分有点难倒我。

我正在将此操作系统和引导加载程序写入磁盘映像，其中包括：

1. MBR 引导扇区和第一阶段引导加载程序
2. 为第二阶段引导加载程序保留 32kb 区域
3. 一个包含操作系统的 FAT32 分区，以及kernel.bin

我的目标是将 kernel.bin 加载到内存中并跳转到该位置，为了做到这一点，我必须遍历 FAT 表。

读取 FAT32 分区所涉及的许多逻辑需要 32 位值（如许多 BPB 值）

由于我现在基本上处于实模式，因此我不确定在执行乘法等计算时如何处理这些 32 位数字。我知道我可以使用操作数大小前缀和/或地址大小前缀来使用 32 位寄存器，但我无法以有意义的方式对它们进行算术运算。

例子

以下是存储来自 BPB 的重要值的汇编部分：

BPB_info:

    ; BPB info from the FAT32 boot sector
    BPB_NumFATs: db 0 ; Number of FATs (1 byte)
    BPB_FATSz32: dd 0 ; Size of each FAT in sectors (4 bytes)
    BPB_RootClus: dd 0 ; First cluster of the root directory (4 bytes)
    BPB_SecPerClus: db 0 ; Sectors per cluster (1 byte)
    BPB_RsvdSecCnt: dw 0 ; Reserved sectors count (2 bytes)

    ; Calculated values used in the bootloader
    FAT_root_dir_start: dq 0 ; Start of the root directory in sectors (calculated)
    FAT_lba: dq 0 ; Logical block address of the FAT tables (calculated)

为了计算FAT_root_dir_start，我必须使用以下公式：

BPB_RsvdSecCnt + ((BPB_RootClus - 2) * BPB_SecPerClus)

但由于BPB_RootClus是一个双字（32 位），我不确定如何执行此操作。

任何建议都将不胜感激！我走对路了吗？我应该完全不同地处理这个问题吗？也许切换到保护模式？我不确定。

org 0x7c00

BOOTDRIVE equ 0x9000

flatcode equ 0x0008                             
                                                
flatdata equ 0x0010                                 
                                                
flatstack equ 0x0010                                

[bits 16]

section .text

bspstart:
    
    xor ax,ax       ;some BIOS required
    
    mov ds,ax
    mov byte [BOOTDRIVE],dl
    
    mov ax,0x8000
    mov ss,ax
    mov sp,0

    mov cx,2000 ;80x25*2
    xor si,si
    mov di,1
    mov ax,0xb800
    mov ds,ax
    
cleanscreen:

    mov byte [ds:si],0x0
    add si,2
    mov byte [ds:di],0xf
    add di,2
    
    loop cleanscreen
    
    xor ax,ax
    mov ds,ax       ;restore ax to load GDTR
    
Read_Disk_INT0x13:  ;Read/Write Harddisk/Floppy provided by BIOS INT 0x13   ;cannot use in 32bits mode and 64bits mode
    
    mov ah,0x2  ;function ID 0x2 read_sector; 0x3 write_sector
    mov al,0x2  ;count of read/write sector
    mov ch,0x0  ;location(cylider)
    mov dh,0x0  ;location()
    mov cl,0x2  ;location(sector)
    mov byte dl,[BOOTDRIVE] ;type of drive(0x0~0x7f floppy drive;0x80~0xff hard drive)
    
    mov bx,0x0
    mov es,bx   ;es:bx target memory area 
    mov bx,0x7e00
    
    int 13h
    
    cli             ;after int 0x13 inst execute, the IF bit was enabled. we must to disable it.
    
    jc Read_Disk_Error
    
Read_Disk_OK:
    
    lgdt [GDT_PROP]
    
    in al,0x92
    or al,2
    out 0x92,al
    
    mov eax,0x1
    mov cr0,eax
    
    jmp dword flatcode:bsp_protected_mode_init_segreg

[bits 32]

bsp_protected_mode_init_segreg:

    mov ax,flatdata
    mov ds,ax
    mov ax,flatstack
    mov ss,ax
    
    mov esp,0x00200000
    
loadpage:

    mov eax,flatdata
    mov ds,eax
    mov es,eax
    mov esi,temp_pt
    mov edi,0x00100000
    mov ecx,temp_pt_end - temp_pt
    cld
    rep movsb
    
    mov esi,temp_pdt
    mov edi,0x00101000
    mov ecx,temp_pdt_end - temp_pdt
    cld
    rep movsb
    
    mov esi,temp_pdpt
    mov edi,0x00102000
    mov ecx,temp_pdpt_end - temp_pdpt
    cld
    rep movsb
    
    mov esi,temp_pml4
    mov edi,0x00103000
    mov ecx,temp_pml4_end - temp_pml4
    cld
    rep movsb

bsp_init_long_mode:
    
    call checkcpuid
    
    call checkia32e
    
    mov ax,flatdata
    mov ds,ax
    
    mov eax,0x20
    mov cr4,eax
    
    mov eax,0x00103000      ;pml4
    mov cr3,eax
    
    mov ecx,0xc0000080
    rdmsr
    or eax,1 << 8
    wrmsr
    
    cli
    
    mov eax,0x80000001
    mov cr0,eax
    
    jmp dword flatcode:bsp_long_mode
    
temp_pt:

    dq 0x00000000000b8001
    dq 0x00000000000b8001
    dq 0x0000000000000001
    dq 0x0000000000000001
    dq 0x0000000000000001
    dq 0x0000000000000001
    dq 0x0000000000104001   ;stack at 0x00104000
    dq 0x0000000000007001   ;bootloader
    
temp_pt_end:
    
temp_pdt:

    dq 0x0000000000100001
    
temp_pdt_end:
    
temp_pdpt:
    
    dq 0x0000000000101001
    
temp_pdpt_end:

temp_pml4:

    dq 0x0000000000102001
    
temp_pml4_end:

GDT_PROP:
    
    dw GDT_TABLE_32_END - GDT_TABLE_ENTRY_32 - 1
    dd GDT_TABLE_ENTRY_32
    
GDT_TABLE_ENTRY_32:

    dq 0x0000000000000000   ;Empty Entry
    
    dq 0x00cf9a000000ffff   ;code
    
    dq 0x00cf92000000ffff   ;data&stack
    
GDT_TABLE_32_END:

GDT_PROP_64:
    
    dw GDT_TABLE_64_END - GDT_TABLE_ENTRY_64 - 1
    dq GDT_TABLE_ENTRY_64

GDT_TABLE_ENTRY_64:

    dq 0x0000000000000000
    
    dq 0x00af9a000000ffff
    
    dq 0x00af92000000ffff
    
GDT_TABLE_64_END:


    
[bits 16]

BIOS_13H_ERROR:

    db 'PizzaLoader:(0x0) Disk Error! System Halted.'

Read_Disk_Error:
    
    mov ax,0x0
    mov ds,ax
    
    xor si,si
    
    mov bx,BIOS_13H_ERROR
    
    mov cx,44
    
Print_Disk_Error:
    
    mov dx,0x0
    mov ds,dx
    
    mov byte al,[ds:bx]         ;read BIOS_13H_ERROR
    add bx,1
    
    mov dx,0xb800
    mov ds,dx
    
    mov byte [ds:si],al         ;write 0xb8000
    add si,2
                     
    loop Print_Disk_Error
    
    jmp cpuhlt
    
cpuhlt:

    hlt
    
    
times 510 - ($ - $$) db  0x0

db 0x55, 0xaa

[bits 32]

NO_CPUID_ERROR:

    db 'PizzaLoader:(0x1)The Processor does not support CPUID instruction, System Halted.'

checkcpuid:
    
    pushfd
    pop eax
    
    mov ecx,eax
    
    xor eax,1<<21
    
    push eax
    popfd
    
    pushfd
    pop eax
    
    push ecx
    popfd
    
    xor eax,ecx
    jz nocpuid
    
    ret

nocpuid:
    
    mov ax,flatdata
    mov ds,ax
    
    mov esi,0x000b8000
    
    mov ebx,NO_CPUID_ERROR
    
    mov ecx,81
    
Print_no_CPUID_Error:
    
    mov byte al,[ebx]           ;read NO_CPUID_ERROR
    add ebx,1
    
    mov byte [esi],al           ;write 0xb8000
    add esi,2
                     
    loop Print_no_CPUID_Error
    
    hlt
    
NO_IA32E_ERROR:

    db 'PizzaLoader:(0x2)The Processor does not support 64-bits mode, System Halted.'
    
checkia32e:

    mov eax, 0x80000000    ; Set the A-register to 0x80000000.
    cpuid                  ; CPU identification.
    cmp eax, 0x80000001    ; Compare the A-register with 0x80000001.
    jb noia32e             ; It is less, there is no long mode.
    ret
    
noia32e:

    mov ax,flatdata
    mov ds,ax
    
    mov esi,0x000b8000
    
    mov ebx,NO_IA32E_ERROR
    
    mov ecx,76
    
Print_no_IA32E_Error:
    
    mov byte al,[ebx]           ;read NO_CPUID_ERROR
    add ebx,1
    
    mov byte [esi],al           ;write 0xb8000
    add esi,2
                     
    loop Print_no_IA32E_Error
    
    hlt

[bits 64]

bsp_long_mode:
    
    lgdt [GDT_PROP_64]
    
    mov rax,flatdata
    mov ds,rax
    mov ss,rax
    mov sp,0x00006000
    
    call Load_Kernel
    
    hlt
    
Load_Kernel:
    
    mov rsi,0x00000000
    
    mov rbx,loading_kernel_Message
    
    mov rcx,21
    
Print_Loading_Kernel_Message:
    
    mov byte al,[rbx]           ;read message
    
    add rbx,1
    
    mov byte [rsi],al           ;write 0x000b8000
    add rsi,2
                     
    loop Print_Loading_Kernel_Message

    ret
    
loading_kernel_Message:

    db 'Loading Mio Kernel...'
    
[bits 64]

restart:
    
    mov dx,0xcf9
    mov al,0xe
    out dx,al

这是我的完整代码，运行结果如下：

Kn’chmf?Lhn?Jdqmdk———

文本输出的 ASCII 代码比应有的低 1，因此在字母表中比应有的早 1 个字母。应为“正在加载...”

我正在尝试在实模式下编写一个将在 QEMU 中运行的示例“Hello World”。主机是运行 FreeBSD 14 的 64 位英特尔。

我尝试了以下方法：

这是boot.asm文件：

format binary
org 0x7C00      ; Bootloader loaded at 0x7C00

start:
    ; Set up segment registers
    mov ax, cs
    mov ds, ax
    mov es, ax

    ; Set up stack
    mov ax, 0x0000
    mov ss, ax
    mov sp, 0x7C00

    ; Print message using BIOS interrupt
    mov si, msg
print_loop:
    lodsb               ; Load next character
    test al, al
    jz halt             ; Jump if null terminator
    mov ah, 0x0E        ; BIOS teletype function
    int 0x10            ; Call BIOS
    jmp print_loop

halt:
    cli                 ; Disable interrupts
    hlt                 ; Halt processor

msg db "Hello, World!", 0

times 510 - ($-$$) db 0 ; Pad to 510 bytes
dw 0xAA55               ; Boot signature

这是 makefile：

# Makefile for FreeBSD bootloader example

ASM = fasm
QEMU = qemu-system-i386
TARGET = boot.bin
SOURCE = boot.asm

all: $(TARGET)

$(TARGET): $(SOURCE)
        $(ASM) $(SOURCE) $(TARGET)

run: $(TARGET)
        $(QEMU) -fda boot.bin -serial stdio -display none

clean:
        rm -f $(TARGET)

这是我组装文件并通过 qemu 运行后得到的结果：

$ make
fasm boot.asm boot.bin
flat assembler  version 1.73.32  (16384 kilobytes memory)
2 passes, 512 bytes.

$ make run
qemu-system-i386 -fda boot.bin -serial stdio -display none
WARNING: Image format was not specified for 'boot.bin' and probing guessed raw.
         Automatically detecting the format is dangerous for raw images, write operations on block 0 will be restricted.
         Specify the 'raw' format explicitly to remove the restrictions.

一些问题：

1. 我希望 -serial stdio 捕获示例引导加载程序显示的消息的输出，但没有显示任何消息。
2. 如何指定 qemu 的文件格式以便不再显示警告。

我正在用68000 汇编实现排序算法，并决定使用堆栈将参数传递给交换数组中两个元素的子例程。我想确保正确高效地处理堆栈。

具体来说，在调用SWAP_SUB子程序之前，我使用 将两个元素的地址推送到堆栈pea.l，然后使用 的偏移量在子程序内部检索它们A7。

完整代码如下：

      ORG $8000

START:
      moveq.l #len-1,d7  
OUTER_LOOP:
      lea.l array,a0     
      moveq.l #len-2,d6  

INNER_LOOP:
      move.b (a0)+,d2   
      cmp.b (a0),d2
      blt.s DO_SWAP  

NO_SWAP:
      subq.l #1,d6
      bge.s INNER_LOOP
      
      subq.l #1,d7
      bge.s OUTER_LOOP
      
      SIMHALT

DO_SWAP:
     pea.l (a0)  
     pea.l -1(a0)  
     bsr.s SWAP_SUB  
     addq.l #8,a7  
     bra.s NO_SWAP 

SWAP_SUB: 
     movem.l d3-d4,-(a7) ;new line
                         
     move.l 4(a7),a0  
     move.l 8(a7),a1  
     
     move.b (a0),d3  
     move.b (a1),d4  

     lsl.w #8,d3  
     or.w d4,d3  
     rol.w #8,d3  
     move.w d3,d5  
     lsr.w #8,d5  
     move.b d5,(a0)  
     andi.w #$00FF,d3  
     move.b d3,(a1)  
     
     movem.l (a7)+,d3-d4 ;new line

     rts  

array   DC.B 5,3,8,1,7       
len     EQU 5                

    END START

问题：

1. 我是否正确使用堆栈传递参数？我的方法是否存在任何潜在问题？
2. 向子程序传递参数时，是否有设置堆栈的通用方法？
3. 这段代码能以任何方式简化吗？

我正在开发一个Motorola 68000汇编程序，该程序使用子例程连接两个字符串。挑战在于通过堆栈实现输入和输出的参数传递，因此我专注于正确设置和恢复堆栈。

我在Sep Roland和Erik Eidt的帮助下开发了程序逻辑。之后，我研究了如何使用堆栈传递参数，这就是为什么我的代码有大量注释的原因。

任务要求：

• 用68000 汇编语言实现一个使用堆栈传递参数的子程序。
• 该子程序接受两个输入字符串：
  • A ="Hello"
  • B ="World"
• 它将它们连接成输出字符串C，结果为：
  • C ="HelloWorld"
• 主程序应该：
  1. 通过推送参数来准备堆栈。
  2. 调用子程序。
  3. 函数返回后正确恢复堆栈。

我的实现：

          ORG $8000
   
;DATA
StringA DC.B 'Hello',0    ; First string with a null terminator
StringB DC.B 'World',0    ; Second string with a null terminator
StringC DS.B 256          ; Buffer for the concatenated string 

START: 

; The stack pointer (A7) starts at address $8000. 
; In the 68000 architecture, A7 always points to the memory address where 
; the next value will be saved (push operation).

      pea.l StringC ; Equivalent to [move.l #StringC, -(a7)]
                    ; The stack pointer (A7) is decremented by 4 (pushing a longword = 4 bytes)
                    ; Initial A7 = $8000, now A7 = $7FFC
      
      pea.l StringB  ; A7 = $7FF8
      pea.l StringA  ; A7 = $7FF4

; Therefore, the stack (from lowest to highest address) contains:
; A7 = $7FF4  |StringA address| 
; A7 = $7FF8  |StringB address| 
; A7 = $7FFC  |StringC address| 
; A7 = $8000 (original SP value before the push operations)

      bsr.s CopyStrings     ; Call the first subroutine, saving the PC (Program Counter)
                            ; onto the stack
                                
; When executing bsr.s, the processor:
; - Saves the return address (PC) on the stack (another 4 bytes subtracted from A7).
; - Then branches to CopyStrings.

; Upon returning from the subroutine (rts), the stack pointer A7 will remain 
; where the subroutine left it. However, we need to clean up the three parameters 
; (StringA, StringB, StringC) that we previously pushed.

      addq.l #8,a7  ; Restore 8 bytes of the stack
      addq.l #4,a7  ; Restore the remaining 4 bytes (total 12 bytes)

      SIMHALT 

CopyStrings:
      ; At the entry of the subroutine, the stack looks like this:
      ; A7    |Return Address | 
      ; A7+4  |StringA Address| 
      ; A7+8  |StringB Address| 
      ; A7+12 |StringC Address|
      
      move.l 4(a7),a0  ; Retrieve the address of StringA 
      move.l 8(a7),a1  ; Retrieve the address of StringB
      move.l 12(a7),a2 ; Retrieve the address of StringC 
      
CopyA: 
      move.b (a0)+,(a2)+  ; Load a character from StringA into StringC
                          
      bne.s CopyA         ; If the character is not null, continue copying
      subq.l #1,a2        ; Move back 1 byte to overwrite the null terminator

CopyB:
      move.b (a1)+,(a2)+  ; Load a character from StringB into StringC
      bne.s CopyB         ; If the character is not null, continue copying
      rts                 ; Return from subroutine
    
     END START

问题：

1. 我通过堆栈传递参数的方法正确吗？
2. 我应该考虑哪些优化或最佳实践？

任何反馈都将不胜感激！

我正在用汇编语言为 Motorola 68000 编写一个子程序，用于连接两个字符串。该子程序接收两个输入字符串StringA("Hello") 和StringB("World")，并将连接结果存储在StringC("HelloWorld") 中。

代码编译时没有错误，似乎可以工作，但我不确定输出是否正确或实现是否在逻辑上正确。

我写了以下代码：

    ORG $8000
     
StringA DC.B 'Hello',0    ; First string with null terminator
StringB DC.B 'World',0    ; Second string with null terminator
StringC DS.B 20           ; Buffer for the concatenated string (large enough?)

START: 
      lea.l StringA,a0    ; a0 -> "Hello"
      lea.l StringB,a1    ; a1 -> "World"
      lea.l StringC,a2    ; a2 -> Buffer for concatenation
      clr.b d0            

      jsr CopyA           ; Call first subroutine 
      
      SIMHALT             

CopyA: 
      move.b (a0)+,d0     ; Load character from StringA into d0
                          ; Check if it is the null terminator
      beq.s CopyB         ; If yes, start copying StringB
      move.b d0,(a2)+     ; Otherwise, copy character into StringC
      bra CopyA           
      
CopyB:
      move.b (a1)+,d0     ; Load character from StringB into d0
      move.b d0, (a2)+    ; Copy it into StringC
      bne CopyB           ; If the character is not null, continue copying
     
     rts                  ; Return from subroutine
    
     END START

问题：

• 我的子程序实现正确吗？我使用了jsr和rts，但我想确认这是否是此上下文中的最佳方法。
• 可以以任何方式进行优化吗？例如，我可以删除哪些冗余指令？

我正在用M68K汇编语言编写一个程序来查找数组中的最小值。

这是我的代码：

ORG $8000

; DATA
array DC.B 2,3,1,4,5  ; The minimum is 1
len EQU 5
min DC.L 0          ; Stores the found minimum

START:
     lea.l array,a0
     move.b (a0)+,d0   ; d0 = 2 (current minimum), a0 now points to 3
     moveq.l #len-1,d1 ; One element already used

LOOP: 
    cmpi.l #0,d1       ; If d1 = 0, no more elements to check
    beq.s END          ; Jump to the end if finished
    
    move.b (a0)+,d2    ; Load next element into d2
                       ; d2 = 3, a0 -> 1
                       ; d2 = 1, a0 -> 4
                       ; d2 = 4, a0 -> 5
                       ; d2 = 5, a0 -> ??? (What happens here?)
                       
    cmp.b d0,d2 
    blt.s UPDATE       ; If d2 < d0, update minimum

    bra.s DECREMENT

UPDATE:
     move.b d2,d0      ; Update the minimum

DECREMENT:
     subq.l #1,d1      ; Decrease counter
     bra.s LOOP

END: 
    move.b d0,min   ; Store the minimum
    SIMHALT
    END START

我的问题：

1. 在我标记的位置，处理完最后一个元素5???后会发生什么？它是否指向无效地址？a0
2. 我的初始化方法是否是d0一个move.b (a0)+,d0好的开始方式，或者是否有更好的方法？
3. 我的代码还可以进一步优化吗？

任何建议都将不胜感激！谢谢！

我正在使用Easy68k开发一个汇编程序，并使用M68k 汇编语言进行编程。我正在尝试计算两个 16 位字数组（A和B）的标量积（点积）。但是，我遇到了一个问题，我的LOOP变得无限大，但我不知道为什么。

代码如下：

           ORG $8000

START:
      clr.l d0
      lea.l A,a0
      lea.l B,a1 
      moveq #len,d1   

LOOP:
      move.w (a0)+,d5  
      move.w (a1)+,d6  
      mulu.w d5,d6  
      add.l d6,d0  
      subq.l #1,d1    
      bne.s LOOP 

      move.l d0,scalar_prod   
      SIMHALT

    ; DATES
A DC.W 10,20,30,40 
B DC.W 50,60,70,80  
len EQU 4
scalar_prod DC.L 0  
    
    END START

问题

d1我以为当和都减为零时循环应该停止d2，但它并没有按预期终止。有人能帮我理解这里可能出了什么问题吗？通过使用move.b #len,d1

优化建议：

我也非常感激任何关于如何优化此代码的建议。谢谢！:-)

我正在尝试用 Easy68K 编写一个程序来计算数组元素的总和，但它在 ( ) 处冻结。

也许我没有完全理解a0、(a0)和总和的工作原理。有人能帮帮我吗？

这是我的代码：

            ORG $8000
            
array DC 1,2,3,4,5,6,7,8,9,10  ; DC reserves 4 bytes for each element  
                                ; $8000 -> 1, $8004 -> 2, etc.
len EQU 10                     ; Number of elements in the array
sum DC 0                       ; Variable to store the sum

START:  
      suba.l a0,a0              ; Clear register A0 (set to 0)
      clr d1                    
      clr d0                    
      movea array,a0            ; Load the address of 'array' into A0
      move len,d1               
      move sum,d0               

LOOP:
     TST d1                     ; Check if D1 (counter) is zero
     beq END                    ; If zero, exit the loop
     
     move (a0),d5               ; Load the value at address A0 into D5
     add d5,d0                  ; Add D5 to D0 (accumulate sum)
     addq #4,a0                 ; Move to the next element in the array (4-byte step)
     subq #1,d1                 ; Decrease the loop counter by 1
     bra LOOP                   
  
END: 

    SIMHALT                      

    END     START