[OT] Assembly - Moltiplicazione HW/SW

Oggi ho fatto esperimenti con l'istruzione MUL su ATmega8A vs ATtiny85
logicamente l'attiny non ha la suddetta istruzione e quindi si fa tutto via sw.

DOMANDA: dove diavolo sta' il risultato ?

Motivazioni:

  • su ATmega appena viene eseguita la MUL il risultato lo si trova in R1/R0, tutti felici e contenti
  • su ATtiny viene chiamata in campo la Ram per appoggiarvici i dati intermedi, ma in nessun posto trovo il risultato finale.

il calcolo e' 250*100=2500 25000=0x61A8
l'LSB me lo ritrovo sia in Ram che in R0, ma il MSB non lo vedo da nessunissima parte

Allego il listato:

0000001E  LDI R24,0xFA	
0000001F  STD Y+1,R24	
00000020  LDI R24,0x64	
00000021  STD Y+2,R24	
00000022  LDD R24,Y+1		
00000023  LDD R25,Y+2	
00000024  MOV R22,R25		
00000025  RCALL PC+0x0003	
00000026  STD Y+3,R24	
00000027  RJMP PC-0x0000		
00000028  CLR R0		
00000029  SBRC R24,0		
0000002A  ADD R0,R22		
0000002B  LSL R22		
0000002C  BREQ PC+0x03		
0000002D  LSR R24	
0000002E  BRNE PC-0x05	
0000002F  MOV R24,R0		
00000030  RET

Intanto 250x100 fa 25.000, non 2.500 come hai scritto tu (anche se poi l'HEX è giusto :-)) .
Dovresti poi prendere il datasheet e controllare le istruzioni, perché alcune pongono il risultato nel registro, altre in celle di memoria. Dal codice mi pare di capire che:

  • caricano i due fattori uno alla volta in R24 e subito li salvano in memoria, nelle celle Y+1 e Y+2
  • poi caricano ogni fattore in 2 registri differenti ed iniziano un certo numero di operazioni
  • alla fine dovresti avere tutto nella coppia R22, R0, se non sbaglio.
    Ma l'assembly è una brutta bestia, le istruzioni sono da pag. 202, come vedi diverse interessano registri e bit di flag, sono un pò arrugginito a dire la verità :stuck_out_tongue_closed_eyes:

si ho mancato uno zero nel post ma il listato e' giusto :wink:

alcune operazioni parlano chiaro, come ad esempio la succitata MUL, ma nel caso specifico invece proprio mi manca meta' risultato.
R0 si, confermo come avevo scritto, contiene meta' risultato, mentre R22 non c'entra perche' viene usato sull'istruzione "Logical Shift Left" fino a che shiftando shiftando non arriva a 0, dopodiche' viene alterato il branching. Quindi R22 e' sempre 0x00 alla fine

Bha :expressionless:

meriti karma +1 gia' per avermi solo letto :slight_smile:

Trovato, i due operandi rientravano in un Byte, e quindi facevo operazioni su un solo byte, ma il risultato di 25000 necessita di due Byte :slight_smile:

Però ora mi spieghi che caspita te ne fai di sapere come vengono fatte le moltiplicazioni in assembly :wink:

Pura sete di conoscenza :slight_smile:

ROTFL :stuck_out_tongue_closed_eyes: