PrettyOS um Rechner erweitern

lmb

gut
soll ich jetzt den calculator in asm oder c schreiben?
ich denke nämlich, dass c für mich einfacher ist, vorallendingen, weil ich aus dem php bereich komme, die syntax ähnelt sich ziemlich.
aber c kann man nicht einfach einbinden?

Erhard Henkes

soll ich jetzt den calculator in asm oder c schreiben?

An der Stelle in asm. Das ist sicher eine interessante Übung.

lmb

okay
stimmt das so? grundlegend?

addieren:
mov zahl1, 15
mov zahl2, 2
add zahl1, zahl2
mov ergebnis, zahl1

variable ergebnis müsste 15 sein, oder?

Erhard Henkes

2+15=17

Hier ist ein vielleicht interessanter Assembler-Einstiegs-Crash-Kurs: http://ivs.cs.uni-magdeburg.de/bs/lehre/sose99/bs1/seminare/assembler.shtml#add

lmb

klar, natürlich 17, hab mich verschrieben
danke für den linktipp!

lmb

aha noch einfacher.
guuuuut!

Erhard Henkes

aha noch einfacher. guuuuut!

Genau!

lmb

nochmal:
addition:

mov ergebnis,50
add ergebnis,20
;ergebnis = 70

subtraktion:

mov ergebnis,30
sub ergebnis,10
;ergebnis = 20

multiplikation:

mov zahl1,3
mov zahl2,5
imul ergebnis, zahl1, zahl2
;ergebnis = 15

division:

mov zahl1,30
mov zahl2,10
idiv ergebnis, zahl1, zahl2
;ergebnis = 3

alles soweit richtig?
quelle: http://de.wikibooks.org/wiki/Assembler_(80x86_Prozessor)-Programmierung:_Rechnen_mit_dem_Assembler
korrigiert

Badestrand

lmb, mach besser einen neuen Thread hier im Assembler-Forum auf, in diesem hier geht's um etwas anderes

Nobuo T

Will ich meinen. Ich versuche mal, die betroffenen Beitraege abzutrennen, hoffe die "Kollateralschaeden" sind gering.

lmb

Gut, Danke
Stimmt das denn alles?
Ich bin mir vorallendingen bei der Division nicht sicher...

Echt klasse Forum!

Nobuo T

tiny und co. werden aufgrund regelmaessigen Missbrauchs zensiert. Wenn du was verlinken willst, tue es direkt.

Zu deinem Code:
imul akzeptiert keine 3 Speicherzugriffe als Operanden (die wenigsten Instruktionen koennen uebrigens nur mit Speicherzugriffen als Operanden arbeiten).
Selbes gilt also fuer idiv. Das akzeptiert sogar nur einen Operanden, den Divisor.
In Befehlsreferenzen kannst du nachschauen, wie Befehle funktionieren. zB. hier.

Allgemein solltest du dir auch mal Gedanken darueber machen, wann es sinnvoll ist Variablen zu verwenden und wann Register reichen. In laufenden Rechnungen arbeitet man sinnvollerweise zB. eher auf Registern: Arbeit mit Variablen braucht einmal Platz im RAM (klar) und verhaeltnismaessig viel Zeit zum Lesen/Schreiben im RAM.

lmb

das mit den registern habe ich leider noch nie richtig geschnallt.
deswegen verstehe ich wohl auch deinen link nicht richtig, aber trotzdem danke!

Nobuo T

In den FAQ gibt es Einsteigertutorials zu Asm. Der Umgang mit Registern und ein grobes Verstaendnis der Programmierumgebung der Ziel-CPU gehoert zu den grundlegensten Dingen beim Programmieren in Assembler.
So, fuerchte ich, ist diese Art von Frickelei leider recht fruchtlos.

lmb

ich versuche es so lange, bis ich es geschafft habe.

mein jetztiger code:

mov eax,50
    add eax,20
    mov ergebnis, eax
    mov si, ergebnis
    call print_string
    jmp loop_start  

.
.
.
.

ergebnis db 0

Allerdings scheint in dieser zeile:
mov ergebnis, eax
etwas falsch zu sein.
denn diese fehlermeldung kommt: invalid combination of opcode and operands
aber das müsste eigentlich richtig sein!
ich kopiere den inhalt von eax nach ergebnis
falsch?
oder kann ich auch direkt:
mov si, eax

PS: ich bin lernbereit für ALLES!

Nobuo T

lmb schrieb:

ich versuche es so lange, bis ich es geschafft habe.

Bewundernswerte Einstellung. Waere aber sicher effizienter, wenn du dir Methoden aneignest, deinen Code selbst zu verifizieren und zu testen.

Zu deinem Code:
In NASM meint

mov eax, ergebnis

idR. in etwa "kopiere die Offset-Adresse des labels 'ergebnis' nach eax".
Also nicht das, was du hier willst und andersherum funktioniert das natuerlich gar nicht, da das offset eines labels eine konstante, beim Assemblieren bestimmte Zahl ist und in konstante Zahlen kannst du nichts reinschreiben. (vgl. mov 15, eax).
Um in Intel-Syntax Speicherzugriffe zu machen, packt man idR. eckige Klammern um ein Label oder eine Adresse.
zB.

mov eax, [ergebnis]

liest vom Speicher (bzw. der "Variable") beim Label "ergebnis".

Die Prozedur PrintString erwartet nun in si einen Zeiger (hier Offset-Adresse) auf einen 0-terminierten String. Was du da nach der Addition in "ergebnis" kopieren willst, ist jedoch weder 0-terminiert noch ein String, sondern einfach ein integer - kannst du so also nicht ausgeben. Vorher musst du deinen integer in einen string konvertieren. Dazu bietet dir Erhards code im RealMode AFAIK aber keine Funktionen. ... Die muesstest du dir also auch erstmal selbst schreiben. Zum Thema wie das funktioniert gab es vor nicht all zu langer Zeit 3 Themen, die sich eigentlich noch irgendwo unter den ersten 5 Foren-Seiten hier finden sollten.

lmb

Nobuo T schrieb:

lmb schrieb:

ich versuche es so lange, bis ich es geschafft habe.

Bewundernswerte Einstellung. Waere aber sicher effizienter, wenn du dir Methoden aneignest, deinen Code selbst zu verifizieren und zu testen.

Ja, ich versuche was ich kann.

Nobuo T schrieb:

Zu deinem Code:
In NASM meint
mov eax, ergebnis
idR. in etwa "kopiere die Offset-Adresse des labels 'ergebnis' nach eax".
Also nicht das, was du hier willst und andersherum funktioniert das natuerlich gar nicht, da das offset eines labels eine konstante, beim Assemblieren bestimmte Zahl ist und in konstante Zahlen kannst du nichts reinschreiben. (vgl. mov 15, eax).

Ich hatte es doch genau andersherum, also:

mov ergebnis, eax

Nach meinem Verständniss müsste das heissen:
Kopiere den Inhalt von eax nach ergebnis
Aber nach diesen Aussagen:

Nobuo T schrieb:

Um in Intel-Syntax Speicherzugriffe zu machen, packt man idR. eckige Klammern um ein Label oder eine Adresse.
zB.
mov eax, [ergebnis]
liest vom Speicher (bzw. der "Variable") beim Label "ergebnis".

müsste es

mov [ergebnis], eax

heissen.

Nobuo T schrieb:

Die Prozedur PrintString erwartet nun in si einen Zeiger (hier Offset-Adresse) auf einen 0-terminierten String. Was du da nach der Addition in "ergebnis" kopieren willst, ist jedoch weder 0-terminiert noch ein String, sondern einfach ein integer - kannst du so also nicht ausgeben. Vorher musst du deinen integer in einen string konvertieren. Dazu bietet dir Erhards code im RealMode AFAIK aber keine Funktionen. ... Die muesstest du dir also auch erstmal selbst schreiben. Zum Thema wie das funktioniert gab es vor nicht all zu langer Zeit 3 Themen, die sich eigentlich noch irgendwo unter den ersten 5 Foren-Seiten hier finden sollten.

Gut, danach werde ich jetzt gleich mal suchen (ich meine, als ich eben gestöbert habe, habe ich das thema gesehen)
Aber erstmal der jetzige Code:

mov eax,50
    add eax,20
    mov [ergebnis], eax
    ;integer in string umwandeln
    mov si, ergebnis
    call print_string
    jmp loop_start  

.
.
.
.

ergebnis db 0

EDIT:
Oh, das sieht komplizierter aus.
Ich habe aber auch noch das hier gefunden:
http://www.softgames.de/forum/viewtopic.php?t=3308
was sagt ihr dazu?
sieht schwer nach nasm aus, heisst aber pure asm

Nobuo T

Deinen String kannst du natuerlich nicht in das eine Byte bei "ergebnis" stopfen.
Dafuer musst du dir einen anderen, ausreichend grossen Speicherbereich anlegen. Entweder auf dem Stack (waere wahrscheinlich am praktischsten) oder irgendwo im Speicher wo sicher nichts anderes steht.

Zu dem verlinkten Code: Das ist zwar Intel-Syntax, sieht NASM deshalb aehnlich, verwendet aber sonst keine NASM-Typische Syntax.
Besonders schoen ist der Code zudem auch nicht. Mach dir besser erstmal das Prinzip hinter der Umwandlung klar und versuche dann dir deinen eigenen Code zu basteln. c&p wuerde ich diesen Code nicht.

lmb

so, ich bin jetzt soweit, dass überprüft wird, ob eax = 0 ist (nach deiner anleitung)
ich weiss aber auch nicht, durch welche basis es geteilt werden soll

schleife:

                                cmp eax,0
                                jne ungleich
                gleich:
                                jmp weiter
                ungleich:
                                ; eax durch basis teilen; doch welche basis?
                                jmp schleife
                weiter:         jmp ende_schleife

        loop schleife
        ende_schleife:
        ; hier sollte es weitergehen

und dann komm ich nicht ganz klar mit der anleitung.
ich soll ax, ax:dx oder eax:adx (eins der drei wird automatisch ausgewählt) durch den divisor teilen
aber durch welchen divisor?

Nobuo T

Kannst du den Thread nochmal verlinken?

Ok, dir ist aber schon so weit ueberhaupt klar, was du dort weshalb auf 0 pruefst?
Dividieren tust du dann natuerlich durch die Basis des Zahlensystems, in dem du deine Zahl in den String schreiben willst. Das Dezimalsystem hat die Basis 10, hexadezimal die Basis 16, Binaer die Basis 2, usw. Ein System erkennbar?

Deine Schleife ist uebrigens noch ziemlich verbesserungsfaehig:
eax pruefst du sinnvollerweise erst nach der Division am Ende der Schreife.
Wozu soll der doppelte Sprung ueber "weiter" gut sein?
Wozu das "loop schleife"? Weist du ueberhaupt, was der loop-Befehl tut?

lmb schrieb:

und dann komm ich nicht ganz klar mit der anleitung.

Bin um aufklaerung und Verbesserung bemueht, dann taugt der Text vielleicht auch irgendwann mal fuer die FAQ.

lmb schrieb:

ich soll ax, ax:dx oder eax:adx (eins der drei wird automatisch ausgewählt) durch den divisor teilen
aber durch welchen divisor?

Naja, welche Register als Dividend genommen werden, haengt davon ab, wie breit der Divisor (Operand von div fuer unsigned, bzw. idiv fuer signed) ist. Fuer Division durch 8 brauchst du 16Bit Eingang (ax), fuer 16Bit-Divisor 32Bit Dividend (dx:ax), usw.
Der Divisor ist die oben erwaehnte Basis.