Algorithme Fletchers dans l'assemblage

Question

Sur une discoboard (ARM7), j'essaie d'implémenter l'algorithme de Fletcher à partir de https://en.wikipedia.org/wiki/Fletcher%27s_checksum, et l'entrée est un seul mot de 32 bits.

Impossible de mettre en œuvre la version 32 bits de années fletcher car il fallait charger un grand nombre en mémoire afin:

Je vais partager le mot de 32 bits en 2 mots de 16 demi-bit, puis exécuter le fletcher- 16 algorithme.

Cependant, la sortie est toujours la somme des nombres à la place, ce qui me semble très faux.

par exemple,

Input: 0x1b84ccc/1101110000100110011001100 

Résultats escomptés:

Checksum value 

réel Sortie:

The sum of the 2 16 bit half words. Wut 

Quelqu'un pourrait-il aider si cela est l'algorithme réel, ou ai-je fait une erreur?

@ Input: 
@ r0: 32 bit message 
@ Output: 
@ r0: checksum value 
fletchers_checksum: 
    push {r1-r4,lr} 
    mov r3, #0 @ store the sum 
    mov r4, r0 @ store message 

    @split to 2 16 bit messages: 
    @@take frequency 
    ldr r1, =#0xFFFF0000 
    and r0, r1, r4 
    lsr r0, #16 
    bl compute_checksum_for_16_bit_number 

    @@amplitude 
    ldr r1, =#0xFFFF 
    and r0, r1, r4 
    bl compute_checksum_for_16_bit_number 

    mov r0, r3 
    pop {r1-r3,lr} 
    bx lr 

compute_checksum_for_16_bit_number: 
    push {lr} 
    ldr r1, =#65536 
    add r0, r3 @add current sum to it. 
    bl mod 
    mov r3, r0 @store new sum 
    pop {lr} 
    bx lr 

Merci!

Answer 1

Sur la page Wikipédia liée:

Habituellement, la deuxième somme sera multiplié par 2^16 et ajouté à la somme de contrôle simple, , empiler efficacement les côte à côte sommes dans un Mot de 32 bits avec la somme de contrôle simple à l'extrémité la moins significative.

Votre code semble calculer les deux sommes de contrôle de 16 bits, mais pas de déplacer la deuxième somme de contrôle de 16 bits comme requis.