Bei COM Dateien, wenn nicht explizit angegeben, ist Code-Segment, Daten-Segment und Stack-Segment immer das Gleiche.
Das sieht bei EXE-Dateien natürlich ganz anders aus.
Ergänzend - der Stack Pointer wird innerhalb des 64KB Segments bei COM-Dateien auf FFFE gesetzt, also möglichst weit weg vom Programm-Start, der bei COM-Dateien fest auf IP = 0100h steht. Bei EXE-Dateien kann das alles anders gesetzt werden, je nachdem was man im Header der Assemblerdatei so definiert. Üblicherweise setzt man auch den Anfang der Daten ans Ende des Codes, also bspw. Zeichenketten usw., aber das ist nirgends fest vorgeschrieben... manche setzen Ihre Variablen auch direkt an den Anfang, nach einem JMP-Befehl, der den Datenbereich erstmal überspringt.
... ich denke, Dein Stapelspeicher ist etwas klein:
dw 2 dup(1)
bedeutet 2 mal das Wort 10, nicht 10 mal das Wort 2.
Du hast also nur 32 Bytes Stapel - nicht viel.
Vermutlich geht es gut, aber Du kannst mit dem Debugger gerne mal nachsehen, was am Ende des Programms in Stack steht, d.h. was davon überhaupt genutzt und damit überschrieben wird.
Deshalb habe ich in meinem Beispiel den Stapelspeicherbereich mit einem gut lesbaren Text vorbelegt (das muss man nicht, kann man auch dup(?) undefiniert lassen, dann müsste die .EXE Datei etwas kleiner werden).
Solche Stapelüberläufe sind ganz typische Fehler, die dann zu "mal geht es, mal geht es nicht - muss an DOS/Windows/Linux/... liegen" führen.
Viele Compiler bieten dazu eine Überprüfung an ("Stack Probes"), da wird bei jeder aufgerufenen Unterroutine geprüft, ob der Stapel schon voll ist. Beim Assembler muss man das selbst machen bzw. testen.
naja... RET geht nur wenn es vorher eine Rücksprungadresse auf den Stack gab. JZ macht das nicht.
So wie Du das gemacht hast, brauchst Du sowieso kein RET sondern ein JMP WFKEY.
Mit RET ohne JSR davor wird irgendein Zufallswert vom Stack geholt - Crash...
Achso ja, JUMP speichert keine Rücksprungadresse auf dem Stack, aber CALL speichert die Rücksprungadresse. Also könnte ich ja auch mit CZ (call if zero) arbeiten, wenn ich "unbedingt" RET am Ende der Routine haben will ?!
EDIT: Also CZ gibts beim 8088 nicht... Ich bin normalerweise 8080 gewöhnt... 
Vielen Dank !
Gruß Jan
jein. Dann kommt das Programm ja an den Befehl nach dem CZ zurück. Sicher auch nicht Dein Plan...
EDIT: Du machst doch hier sowas wie ein CASE statement in C. Da werden vom Kompiler auch nur JUMPs erzeugt.
Mache den Stack aber größer als gerade ausreichend!
Ob der SP initialisiert werden muss oder ob dies das DOS macht weiss ich nicht, da müssen Dir andere weiterhelfen!
Zum Menü wieder auflisten kannste ja einfach nach START springen.
Verstehe nicht, warum ihr da beim Stack so knausern müsst. Normalerweise kann man den Stack Pointer einfach auf das Ende des Datensegments stellen, zumindest wenn man nicht 64KB Daten nutzt (und das ist überwiegend wohl nicht der Fall). Da extra Bytes zu reservieren, und vor allem so wenig, verstehe ich nicht....
Normalerweise würde man einen Stack von 256 oder mehr Bytes vorsehen. Auch wenn ein PC nur 640KB hat, sollte es auf die paar Bytes nicht ankommen. Bei einem Microcontroller mit vielleicht nur ein paar Bytes RAM sieht das natürlich anders aus.
In meinem Beispiel habe ich den Stack mit einer lesbaren Signatur gefüllt.
Dann setzt man vor dem finalen Ende des Programms einen Breakpoint und kann dann den Stackbereich ansehen. Dann weiß man genau, was man mindestens braucht.
Den Wert sollte man dann noch sicherheitshalber noch großzügig vergrößern, wenn man den Speicher hat. Außerdem ruft man schnell mehr Unterprogramme mit weiteren PUSH/POP Paaren und RETURN Adressen auf und wenn man dann vergisst, jedes mal den Stack anzupassen kommt man in die Hölle oder an einen anderen dunklen Ort.
Es kann auch gut sein, dass die aufgerufenen DOS Funktionen den Stack nutzen - viele schalten auf einen eigenen Stack um, aber vermutlich nicht alle.
Aber Ihr wisst hoffentlich, dass es sich bei MS-DOS nur um ein Single Thread Single User Betriebssystem handelt, oder ?
Selbst TSR Programme stören da nicht die Betrachtung, weil sie ganz ans Ende des nutzbaren Speicherbereichs gelegt werden, und somit auch bei der Betrachtung des genutzten Speichers nicht wirklich stören.
Wenn Ihr also ein MS-DOS Programm startet, gehört Euch der gesamte freie Speicherbereich mehr oder weniger. Da könnt Ihr auch den Stack Pointer einfach innerhalb des freien Bereichs "irgendwo" hinsetzen, da muss nix am Ende des Programmbereichs reserveriert werden, sondern wenn das Programm ein Datensegment nutzt (und das tut es immer!), setzt innerhalb des Datensegments einfach den SP auf FFFE, das passt m.E. nach immer.
Und das frisst dann kein Byte im Programm selbst.
Der MASM sorgt eigentlich mit dem Assume Kommando schon dafür, und standardmässig ist der SP bei COM-Dateien, wie bereits erwähnt, schon auf FFFE gesetzt. Kapiere also immer noch nicht eure Anstrengungen...
Vielen Dank für die Antworten ! Also grundsätzlich ist es so, dass mein größtes Assemblerprogramm bis dato compiliert 2-3kb hatte (ohne nachladende Sound- und Grafikdateien). Am IBM ein Programm in einem einzigen Segment zu programmieren würde mir sicherlich reichen. Aber mir ging es ja darum, wie die einzigen Segmente "definiert" und angesprochen werden in einem Programm und das habe ich nun verstanden.
Bei der Programmierung des 6502 hatte ich natürlich nie mit Stack-Definition zu tun, der Stack ist da ja immer zwischen $100 und $1FF. Beim Intel 8080 sieht das etwas anders aus. Da hab ich am Anfang des Programm den alten Stackpointer gerettet, den Stack mit einer Page am Ende des Programms reserviert und am Ende des Programms den alten Stack wieder geholt. Also so:
; Intel 8080 Source
; Stack Definition
;
org 0100h ; Hier gehts los..
lxi h,0 ; HL Register löschen
dad sp ; Alten Stackpointer zu HL addieren und somit reinschreiben
shld oldsp ; Alten Stackpointer in definiertem Speicher sichern
;
lxi sp,stack ; Neuen Stack für dieses Programm definieren
;
;
;
;
;
;
;
end lhld oldsp ; Alte Stackpointeradresse laden
sphl ; ..und in Stackpointer schreiben
;
; Programmende
;
ds 0ffh ; 1 page für stack reservieren
stack ds 01h ; Stack-TOP
oldsp ds 02h ; alter Stackpointer Also zurück zum X86. Ich habe mich jetzt dazu entschieden, mit 2 Segmenten zu arbeiten. Dem Code-Segment und dem Daten-Segment. Das ist mehr als ausreichend. Den Stackpointer habe ich (wie oben vorgschlagen) an das Ende des Datensegmentes gelegt. Hier der Code:
;
;
; Testprogramm Floppylaufwerk
;
;
;
.model small ; EXE-Datei
.radix 16 ; HEX
;
cr equ 0ah
lf equ 0dh
;
title ftest
;
data segment
assume cs:code,ds:data,es:code,ss:data
;
signon db "Disk drive alignment tool V0.5",0dh,0ah
db "by JH 2021",lf,cr,cr,"$"
menu db "1 - Set drive",cr,lf
db "2 - Test rpm",cr,lf
db "3 - Seek test",cr,lf
db "4 - Exit to DOS",cr,lf,"$"
choose db cr,lf,"Please choose...(1-4) $"
;
.stack 0fffeh ; Stack Pointer 0FFFEh
;
data ends
;
code segment
assume cs:code,ds:data,es:code,ss:data
;
org 0100h
start:
;
push ax
call clscn
pop ax
mov bx,data
mov ds,bx ; Datenregister "data" in DS
mov ah,09 ; function 09
mov dx,offset signon
int 21
mov dx,offset menu
int 21
mov dx,offset choose
int 21
;
; Warte auf Auswahl
;
wfkey proc
mov ah,00
int 16
mov bx,ax
mov ax,0534 ; Scancode für "4"
cmp ax,bx
jz fini
mov ax,0433 ; Scancode für "3"
cmp ax,bx
jz seek
mov ax,0332 ; Scancode für "2"
cmp ax,bx
jz tst
mov ax,0231 ; Scancode für "1"
cmp ax,bx
jz set
jnz wfkey
;
set proc
jmp start
;
tst proc
jmp start
;
seek proc
jmp start
fini proc
mov ax,0002
int 10
mov ah,4c ; Programmende
int 21
; Subroutinen
clscn proc
mov ax,0000
int 10
ret
code ends
end startAlso das Grundgerüst steht zumindest.... Jetzt muß ich mich durch die Interrupts bzw. Systemcalls durchschlagen, dass das Programm einen Sinn bekommt...
Gruß Jan
Und WO setzt Du denn SS:SP auf Datensegment:0xfffe?
Das musste nun schon selbst machen.
Ich wuerde mal vermuten nein, das war ja schon bei dem print mit ds das Problem. DOS Assembler ist bei mir aber schon lange her, kann also auch sein das ich mich da taeusche.
Ich habe für COM Dateien noch nie den SP explizit gesetzt. Bei EXE Dateien schon eher, aber solche Sachen macht ja MS-DOS bei der Ausführung von Programmen teilweise selbst, ob Du dann das noch explizit auf den gleichen Wert setzt oder nicht, wäre dann egal.
ASSUME macht überhaupt keinen Code.
Das ist nur eine Direktive für den Assembler, damit er weiss, auf welches Segment sich ein Label bezieht und er dann das richtige Segmentregister dazu verwendet.
Vielleicht hilft das ja: https://elearning.algonquincol…es.f03/33-COM-and-EXE.htm
