use32
mov esi, dword [esp + 4]      ; Pointer to first structure of bytes
mov edi, dword [esp + 8]      ; Pointer to second structure of bytes
mov ecx, dword [esp + 12]     ; Number of bytes in each structre
xor edx, edx                  ; Max difference at start is zero

next:
mov al, [esi]
mov bl, [edi]
cmp al, bl
ja skip_swap    ; Make sure bl > al
mov ah, al
mov al, bl
mov bl, ah
skip_swap:
sub al, bl      ; al = bl - al
cmp al, dl      ; Compare with max difference until now
jb absdiff      ; If al > dl Then dl = al
mov dl, al
absdiff:
inc esi
inc edi
loop next
mov eax, edx
ret 12    

use64
; RCX = Number of bytes in each structure
; RDX = Max difference at start is zero
; R8 = Pointer to first structure of bytes 
; R9 = Pointer to second structure of bytes 

xor rax, rax
xor rbx, rbx

next:
mov al, [r8]
mov bl, [r9]
cmp al, bl
ja skipswap
mov ah, al
mov al, bl
mov bl, ah
skipswap:
sub al, bl
cmp al, dl
jb skipdiff
mov dl, al
skipdiff:
inc r8
inc r9
loop next
mov rax, rdx
ret    

        xor eax, eax
next:
        mov al, [r8 + rcx - 1]
        sub al, [r9 + rcx - 1]
        ja skipswap
        neg al
skipswap:
        cmp al, ah
        jb skipdiff
        mov ah, al
skipdiff:
        loop next
        movzx eax, ah
        ret    

use64

push rsi
push rdi
push rax
push rbx

mov rsi, r8
mov rdi, r9
xor rax, rax
xor rbx, rbx

next:
mov al, [rsi]
mov bl, [rdi]
cmp al, bl
ja skipswap
mov ah, al
mov al, bl
mov bl, ah
skipswap:
sub al, bl
cmp al, dl
jb skipdiff
mov dl, al
skipdiff:
inc rsi
inc rdi
loop next

pop rbx
pop rax
pop rdi
pop rsi

mov rax, rdx
ret    

The primary difference is the registers cleared. The 64-bit version clears RAX/RBX, but the 32-bit version clears EDX. Does the 64-bit version initialize EDX elsewhere?

Code:

        xor eax, eax
next:
        mov al, [r8 + rcx - 1]
        sub al, [r9 + rcx - 1]
        ja skipswap
        neg al
skipswap:
        cmp al, ah
        jb skipdiff
        mov ah, al
skipdiff:
        loop next
        movzx eax, ah
        ret    

... should perform the same operation - greatest absolute difference.

... RAX/RBX I pushed them into stack before working with these registers and restore them before return. I did it with RDI and RSI also and seems to work fine.

The x64 ABI considers registers RBX, RBP, RDI, RSI, RSP, R12, R13, R14, R15, and XMM6-XMM15 nonvolatile. They must be saved and restored by a function that uses them.