Assembler, was bedeutet $

[mumu]

Code:

.DATA;----------------------------------------------------------
  ; ( 1 )
  MiniArray EQU $
  ; ( 2 )
  ORG $ + 32               ;reserviert 32 Byte
  ; ( 3 )
  i     DW               ? ;kriegt ein Alias-Symbol:
  iLow  EQU            $-2 ;...:für das 1.Byte
        ;                  ;... und ein eigenes Symbol
  iHigh EQU            $-1 ;...:für das 2.Byte
  DsDatenPointer DW OFFSET DsDatenPointer ;Zeigt auf sich selbst!
.CODE;----------------------------------------------------------
  ; ( 4 )
  ;Indizierter Zugriff auf das 3.Byte von MiniArray
  MOV DI,2;
  MOV BYTE PTR (MiniArray+DI),Do       ; Bei Do handelt es sich um ein EQU: Do EQU '$'
  ;MOV BYTE PTR (MiniArray+2),36
  
  ; ( 5 )
  ;Indirekter Wort-Zugriff mit Indizierung (auf "iLow" bzw "i")
  MOV DI,2
  MOV BX,DsDatenPointer ; zeigt auf sich selbst => wirkt wie MOV BX,OFFSET DsDatenPointer 
  MOV WORD PTR [BX-DI],5

also hier hab ich noch ein paar fragen:
zu ( 1 ):
was bedeutet dieses $ und was mache ich mit MiniArray EQU $???
zu ( 2 ):
was macht ORG $ + 32
zu ( 3 ):
definiere ich hier ein Word (also 2 bytes) und iLow zeigt aufs erste Byte von i und iHigh aufs zweite Byte.
Was macht in diesem Fall $ genau?!
zu ( 4 ):
was passiert hier? versteh ich irgendwie überhaupt nicht? BYTE PTR?
zu ( 5 ):
was passiert hier?

wär klasse wenn mir jemand ein paar Fragen möglichst ausführlich erklären würde.

Vielen Dank schonmal

[jbg]

Zitat von mumu:

zu ( 1 ):
was bedeutet dieses $ und was mache ich mit MiniArray EQU $???

$ ist der aktuelle Programmcodezähler. Den Programmcodezähler kann man sich so vorstellen: Nachdem das Programm in den Speicher geladen ist, enhält $ den Wert 0 für das erste Byte des Programms im Speicher. 1 für das zweite Byte, 2 für das Dritte, ... Es handelt sich bei $ aber nicht um eine Variable sondern der Assembler ersetzt $ durch eine konstante Adresse. (Da die EQU Assembler-Anweisungen keine Befehle sind verändern sie den Programmcodezähler nicht.)

Zitat:

zu ( 2 ):
was macht ORG $ + 32

Hierdurch wird der aktuelle Programmcodezähler um 32 Bytes verschoben.

Nimmt man (1) und (2) zusammen, so wird MiniArray auf das erste Byte zeigen. Danach folgen 31 weitere Bytes (insg 32 Bytes), die ungenutzt sind und den Kommentaren zu folge für das MiniArray benutzt werden.

Man hätte das auch so schreiben können:

Code:

MiniArray DB 32 DUP(?)

Zitat:

zu ( 3 ):
definiere ich hier ein Word (also 2 bytes) und iLow zeigt aufs erste Byte von i und iHigh aufs zweite Byte.
Was macht in diesem Fall $ genau?!

$ steht 2 Bytes hinter "i". Somit wird durch das abziehen von 2 bzw 1 das entsprechende Byte des Words adressiert.

Zitat:

zu ( 4 ):
was passiert hier? versteh ich irgendwie überhaupt nicht? BYTE PTR?

Da "Do" ein "Do EQU '$'" ist wird an die Adresse MiniArray+DI (DI ist ein CPU register und hat den Wert 2 erhalten), also MiniArray+2 das Zeichen '$' geschrieben, weil $ hier in einfachen Anführungsstrichen steht und somit nicht die Bedeutung des Programmcodezählers hat.

Zitat:

zu ( 5 ):
was passiert hier?

Dabei handelt es sich nur um einen komplizierten Weg, um die Zahl 5 in das Word "i" zu schreiben.
Denn "DsDatenPointer DW OFFSET DsDatenPointer" erzeugt ein Word, dessen Inhalt der Offset dieses Words selbst ist. Und das ist wiederum der aktuelle Programmcodezähler $.
Und von diesem wird wieder DI abgezogen, womit wir wieder bei der Addresse von "i" landen. In in diesen wird dann die Zahl 5 gemovt.

[mumu]

danke für die antworten jetzt hab ichs glaub ich kapiert. nur noch eine Frage dazu:

Zitat:

zu ( 5 ):
was passiert hier?

Dabei handelt es sich nur um einen komplizierten Weg, um die Zahl 5 in das Word "i" zu schreiben.
Denn "DsDatenPointer DW OFFSET DsDatenPointer" erzeugt ein Word, dessen Inhalt der Offset dieses Words selbst ist. Und das ist wiederum der aktuelle Programmcodezähler $.
Und von diesem wird wieder DI abgezogen, womit wir wieder bei der Addresse von "i" landen. In in diesen wird dann die Zahl 5 gemovt.

wenn wir von DsDatenPointer zwei abziehen, dann sind wir bei iLow, oder? iLow zeigt wiederrum auf das erste Byte von i und deshalb wird in i die Zahl 5 geschrieben. Wenn ich richtig liege, dann hast du hier nen punkt übersprungen (beabsichtigt oder unbeabsichtigt ist ja eigentlich egal). Mich interessiert blos ob ich das jetzt hier richtig interpretiert hab?

ein was versteh ich aber trotzdem noch nicht so ganz:
MOV WORD PTR [BX-DI],5
hätte es jetzt einen Unterschied gemacht folgendes zu schreiben: MOV BYTE PTR [BX-DI],5
transferriert MOV WORD PTR [BX,DI],5 ins Byte 1 von i 5 und ins Byte 2 auch 5, oder wie?

[Flocke]

Zitat von jbg:

Dabei handelt es sich nur um einen komplizierten Weg, um die Zahl 5 in das Word "i" zu schreiben.
Denn "DsDatenPointer DW OFFSET DsDatenPointer" erzeugt ein Word, dessen Inhalt der Offset dieses Words selbst ist. Und das ist wiederum der aktuelle Programmcodezähler $.
Und von diesem wird wieder DI abgezogen, womit wir wieder bei der Addresse von "i" landen. In in diesen wird dann die Zahl 5 gemovt.

... was nicht funktionieren wird, da es einen solchen Adressierungsmodus nicht gibt.

Zitat von mumu:

danke für die antworten jetzt hab ichs glaub ich kapiert. nur noch eine Frage dazu:

Zitat:

ein was versteh ich aber trotzdem noch nicht so ganz:
MOV WORD PTR [BX-DI],5
hätte es jetzt einen Unterschied gemacht folgendes zu schreiben: MOV BYTE PTR [BX-DI],5
transferriert MOV WORD PTR [BX,DI],5 ins Byte 1 von i 5 und ins Byte 2 auch 5, oder wie?

"MOV WORD PTR [BX,DI],5" gibt's nicht.
Im 16-Bit Modus gibt es nur eine begrenzte Zahl von Adressierungsmodi:

Code:

[BP]
[BX]
[SI]
[DI]
[BP+SI]
[BP+DI]
[BX+SI]
[BX+DI]

Jeweils optional mit Byte/Word-Displacement.

[jbg]

Zitat von mumu:

wenn wir von DsDatenPointer zwei abziehen, dann sind wir bei iLow, oder? iLow zeigt wiederrum auf das erste Byte von i und deshalb wird in i die Zahl 5 geschrieben. Wenn ich richtig liege, dann hast du hier nen punkt übersprungen (beabsichtigt oder unbeabsichtigt ist ja eigentlich egal). Mich interessiert blos ob ich das jetzt hier richtig interpretiert hab?

Ich habe da nichts ausgelassen. Alle EQU sind Assembler-Anweisungen und verändern den aktuellen Programmcodezähler nicht. Alle Assembler-Anweisungen (.CODE, .DATA, ASSUME, EQU, .IDEAL, IF, ...) werden vor $ "versteckt". Somit sieht der Speicher so aus:

Code:

DS:00 MiniArray
DS:32 i
DS:34 DsDatenPointer

CS:00 MOV DI, 2
...

Wenn nun in Word(DS:34,DS:35) (=DsDatenPointer) die Zahl 34 steht (=OFFSET DsDatenPointer) und man davon nun 2 abzieht, landt man bei 32, was wiederum der Offset von "i" ist.

Zitat:

ein was versteh ich aber trotzdem noch nicht so ganz:
MOV WORD PTR [BX-DI],5
hätte es jetzt einen Unterschied gemacht folgendes zu schreiben: MOV BYTE PTR [BX-DI],5

Ja, da du nicht weißt, was im anderen Byte steht (uninstalisiert) kann das Word eine ziemlich große Zahl werden.

Zitat:

transferriert MOV WORD PTR [BX,DI],5 ins Byte 1 von i 5 und ins Byte 2 auch 5, oder wie?

Durch das "WORD PTR" ist klar, dass du ein WORD moven willst. Also wird deine Zahl 5 im Assemblat vom Assembler als ein WORD abgelegt => 0005h.

[mumu]

Zitat:

Ich habe da nichts ausgelassen. Alle EQU sind Assembler-Anweisungen und verändern den aktuellen Programmcodezähler nicht. Alle Assembler-Anweisungen (.CODE, .DATA, ASSUME, EQU, .IDEAL, IF, ...) werden vor $ "versteckt". Somit sieht der Speicher so aus:

ja stimmt ja, ok sorry, hab da nicht so ganz dran gedacht

das mit MOV BYTE PTR und MOV WORD PTR hab ich jetzt auch verstanden

danke vielen dank

[mumu]

[quote="Flocke"]

Zitat von jbg:

"MOV WORD PTR [BX,DI],5" gibt's nicht.
Im 16-Bit Modus gibt es nur eine begrenzte Zahl von Adressierungsmodi:

Code:

[BP]
[BX]
[SI]
[DI]
[BP+SI]
[BP+DI]
[BX+SI]
[BX+DI]

Jeweils optional mit Byte/Word-Displacement.

ja, hab mich da verschrieben, soll natürlich MOV WORD PTR [BX-DI],5 heißen, siehe weiter oben

[mumu]

zu ( 5 ) noch was:

müsste soetwas nicht auch gehen?
MOV AL,BYTE PTR DX

tut aber leider nicht:
**Error** LSG2-1.ASM(36) Operand types do not match
warum?

[Muetze1]

Wenn du durch type overwrite die Datengrösse angibst, dann musst du die [] drum machen, also

mov al, byte ptr [dx]

[mumu]

ok, das heißt [] funktioniert eigentlich nur im speicher, nicht auf register, oder?