Zitat Zitat von PicNick
Situation auf dem Stack:
stckp + 2 -> wert A
stckp + 1 -> wert B+0
stckp + 0 -> wert B+1

aaaaaaber:
Jetz rufst du dein Unterprogramm
RCALL Unterprogramm

und so sieht daher der Stack beim Unterprogramm aus
stckp + 4 -> wert A
stckp + 3 -> wert B+0
stckp + 2 -> wert B+1
stckp + 1 -> rücksprungadresse Hi
stckp + 0 -> rücksprungadresse Lo
okay, soweit verstanden, ich muss als die Rücksprung-Adresse (welche ja 16-Bit ist) zunächst vom stack holen und sichern.

Zitat Zitat von PicNick
Jetzt gibt's mehre Möglichkeiten:
1) Brutal und nicht schön, geht aber:
Code:
Unterprogramm: 
        pop   r0       rücksprungadresse sichern    
        pop   r1       rücksprungadresse sichern      

        pop   R25    (B+1,  siehe oben)
        pop   R24    (B+0,  siehe oben)
        pop   R16    (A,  siehe oben)

;--- irgendwas machen, R0 und R1 aber in Ruhe lassen

        push   r1       rücksprungadresse wieder auf den Stack
        pop    r0       r0, r1 immer symmetrisch poppen, pushen !  
        ret
Hier kommt eine Frage auf. Alles soweit verständlich, aber wieso schiebst du r1 auf den stack zurück (push r1) und machst dann pop r0 ?? r0 muss doch auch zurück auf den stack, also push r0.
Denkfehler von mir oder war das ein Schreibfehler ?

Zitat Zitat von PicNick
2) Besser:
Code:
Unterprogramm: 
                IN            ZL, SPL       Stackpointer nach ZL:ZH 
                IN            ZH, SPH                übernehmen
; und mit "Offset"  in die Zielregister laden
                LDD          R25, Z+2      (B+1,  siehe oben)
                LDD          R24, Z+3      (B+0,  siehe oben)
                LDD          R16, Z+4      (A,  siehe oben)

;--- irgendwas machen

               RET
2) AAAAAAAAber:
Im hauptprogramm müssen jetzt noch die drein gepushten
Parameter wieder weg
Daher sieht das jetzt so aus
Code:
          lds r16, A 
          push r16 
          lds r16, B+0 
          push r16 
          lds r16, B+1 
          push r16 
        RCALL    Unterprogramm 
         pop     r0    (irgendein Register)
         pop     r0    (irgendein Register)
         pop     r0    (hauptsache, der Stack stimmt wieder)

------- jetzt ist alles wieder paletti
Aber ist das nicht gepfuschter code, wenn ich einfach die letzten 3 stack-Inhalte runterhole, nur damit der stack wieder korrekt ist ?

Aber vielen Dank für die Erläuterungen.

Noch eine Sache zum Verständnis:

Wenn ich also einen 16-Bit Wert in z.B. r20, r21 packe, dann muss ich nicht irgendwie defnieren was davon HIGH-byte und LOW-byte ist ?? ich kopiere die einfach rein und muss bei späterer Verwendung halt selber wissen in welchem Register welcher Inhalt ist ?

Weil bei den Registern X, Y , Z ist ja die Unterteilung in L und H gegeben