Array-Ausgabe

mov eax, 0

hatte ich auch schon probiert, war mir aber nicht sicher, ob das wirklich alles mit Nullen vollschreibt.
Das behebt das Problem nicht.
Ich hab mir mal direkt nach

mov eax, [var + 1]
	call print_int

meine Register umd Memory ausgeben lassen:

Register Dump # 1
EAX = 00000000 EBX = 00000160 ECX = 011FFFE8 EDX = 0000033F
ESI = 00000054 EDI = 0001193C EBP = 011FFFB8 ESP = 011FFF98
EIP = 00001DE2 FLAGS = 0206 PF
Memory Dump # 2 Address = 0000D4E0
0000D4E0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 "????????????????"
0000D4F0 25 69 00 25 73 00 52 65 67 69 73 74 65 72 20 44 "%i?%s?Register D"

Ich vermute nun, dass es irgendwie am Memory liegt.
Wie kann ich das ganze Memory löschen?

Gruß
peak

peak_me schrieb:

Ich vermute nun, dass es irgendwie am Memory liegt.

Nein! - es funktioniert genau so wie Es soll!!!

überleg dir mal den Unteschied zwischen
mov eax,[...] und mov al,[...]

Einmal schiebt er was in EAX und einmal in AL.

Auserdem: was ist der unteschied zwischen AL,AX und EAX

EAX steht für Enhanced AX, also die 32-bit-Version von AX, also ein doppeltsogroßer AX.
Damit EAX aber noch abwärtskompatibel ist, kann man immer noch AX ansprechen. Dies ist wohl die linke hälfte von EAX?!
Und AX ist nochmal in die Hälften AH und AL aufgeteilt.

Die Funktion print_int scheint ja einen vorzeichenbehafteten 32bit Wert als Dezimalstring auszugeben.

Ich habe keine Ahnung, was diese Funktion tut.
Ich benutze dieses Tutorial hier
http://www.drpaulcarter.com/pcasm/pcasm-book-german.zip
Dort ist die Funktion "print_int" in der asm_io.asm enthalten, um eine einfache Ausgabe zu ermöglichen.
Ich hab die Datei mal als Pastebin hochgeladen:
http://pastebin.com/UgagrX6P

peak_me schrieb:
Ich vermute nun, dass es irgendwie am Memory liegt.

Nein! - es funktioniert genau so wie Es soll!!!

Wenn du Spaß daran hast, reite noch weiter auf deinem überlegenen Wissen mit drei Ausrufezeichen durch die Gegend.
Helfen tut es keinem außer dir.

sry - wenn du selber drauf kommst, hilft dir das mehr als wenn ich es einfach nur raushaue.

sry - wenn du selber drauf kommst, hilft dir das mehr als wenn ich es einfach nur raushaue.

Das stimmt natürlich, doch weiß ich nicht, wie ich drauf kommen soll.
Mein Verständnis von EAX, AX, AH und AL habe ich geschrieben, das gibt mir aber keine neue Idee.

vielleicht kannste mir ja noch einen Hinweis geben

EAX ist ein 32Bit Register. AX stellt die 16 niederwertigen bits EAX's dar,AL die die untersten 8.
Die funktion print_int gibt dir den inhalt von EAX (also 32Bit) wieder.

EAX ist ein 32Bit Register. AX stellt die 16 niederwertigen bits EAX's dar,AL die die untersten 8.
Die funktion print_int gibt dir den inhalt von EAX (also 32Bit) wieder.

Genauso hatte ich das auch verstanden.

mov eax,1

belegt das niederwertigste Byte mit "1", die anderen bleiben null.

mov al,1

belegt "al" mit "1". Da "al" das niederwertigste Byte von "EAX" darstellt, müsste bei beiden Varianten doch das gleiche rauskommen, oder nicht?
nämlich EAX=00000001

peak_me schrieb:

mov al,1
belegt "al" mit "1". Da "al" das niederwertigste Byte von "EAX" darstellt, müsste bei beiden Varianten doch das gleiche rauskommen, oder nicht?
nämlich EAX=00000001

nur wenn in EAX vorher nichts drin war - mov al,1 ändert nur die untersten 8 Bit

nur wenn in EAX vorher nichts drin war - mov al,1 ändert nur die untersten 8 Bit

Deswegen habe ich ja extra vorher mov eax,0 gemacht.

Dann müssten ja

mov eax, 0
	mov eax, [var + 1]
	call print_int

und

mov eax, 0
	mov al, [var + 1]
	call print_int

das gleiche Ergbenis liefern. Tun sie aber nicht.
Die erste Variante gibt "262914" und die andere "2" aus.

Mein ganzes Programm sieht so aus:

%include "asm_io.inc"
segment .data
var db 1,2,3,4

segment .text
        global  _asm_main
_asm_main:
        enter   0,0 
        pusha

	mov eax, 0
	mov eax, [var + 1]
	call print_int

        popa
        mov     eax, 0
        leave                     
        ret

es ist doch Richtig! - was macht den MOV EAX,[...]?

es ist doch Richtig!

Ist es nicht; ich wil das zweite Element aus dem Array haben und das ist "2" und nicht "262914".

- was macht den MOV EAX,[...]?

Das packt "[...]" in "EAX".

EAX ist ein 32Bit Register, AL ein 8Bit Register. - dem entsprechend wird aus dem Speicher gelsen.

EAX ist ein 32Bit Register, AL ein 8Bit Register. - dem entsprechend wird aus dem Speicher gelsen.

aha
Ein Element aus dem Array muss das gesamte Register ausfüllen, also müssen die einzelnen Elemente im EAX dann double-words ein.
mit

var dd 1,2,3,4

bekomme ich dann das erste Element mit mov eax, [var]
das zweite mit mov eax, [var + 4]
das dritte mit mov eax, [var + 8]
und das vierte mit mov eax, [var + 12]

Ist das tatsächlich das Standardvorgehen beim Laden von Array-Elementen?

ja (hängt natürlich von der Elementgröße ab)
Dynamischer ist folgendes (eine von vielen Möglichkeiten):

array dd 1,2,3,4,5,6,7,8,9,10 ; 10 Elemente

    xor ecx,ecx ; index register
    lea edx,array
l1: cmp ecx,10
    jae l2
    mov eax,[edx+ecx*4]
    ;eax = array[ecx]
    ;...
    lea ecx,[ecx+1]
    jmp l1
l2:

alles klar
vielen Dank für deine schnelle Hilfe!