Gutes x86-Assembler-Tutorial?

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    Unsere Datenschutzerklärung wurde aktualisiert. Mit der Nutzung unseres Forums akzeptierst Du unsere Datenschutzerklärung. Du bestätigst zudem, dass Du mindestens 16 Jahre alt bist.

    • Gutes x86-Assembler-Tutorial?

      Hallo,

      kennt jemand von euch ein gutes x86-Assembler-Tutorial? Ich programmiere nämlich auf kleinen 8-Bit-Mikrocontrollern schon mit ASM (mit Erfolg) und wollte es auch mal auf 'nem PC versuchen.

      Da auf einem PC natürlich alles anders ist als auf einem kleinen 8-Bit-Käfer, habe ich auch noch ein paar weitere Fragen:

      1. Wenn ich mein Programm durch den Assembler jage, bekomme ich dann nur den nackten Maschinencode von meinem Assemblercode?
      2. Welchen Assembler könnt ihr mir empfehlen?
      3. Wenn ich das ganze dann im XProfan-Interpreter aufrufen will, kann ich das so machen?:

      Quellcode

      1. Declare ASMCode#
      2. Dim ASMCode#, irgendwas
      3. 'Array befüllen...
      4. @Call(Addr(ASMCode#))



      Gruß
      Jonathan
      WICHTIG: Bitte diesen Virencheck durchführen: paules-pc-forum.de/forum/pc-si…infiziert.html#post902873
    • Wenn du Assembler in XProfan verwenden willst, empfehle ich dir dringend meinen Inline-Assembler XPIA. Findest du auf meiner Webseite.

      1. Wenn ich mein Programm durch den Assembler jage, bekomme ich dann nur den nackten Maschinencode von meinem Assemblercode?
      2. Welchen Assembler könnt ihr mir empfehlen?
      3. Wenn ich das ganze dann im XProfan-Interpreter aufrufen will, kann ich das so machen?:
      Zu 1.: Ja, aber zusammen mit dem passenden Exe-Header (Dll oder Exe)
      Du kannst den Assembler aber veranlassen die erstellten, nativen Bytes anzuzeigen/zu speichern
      Zu 2.: Unbedingt JWasm, zusammen mit dem PoLinker. Der ist MASM32 kompatibel, kann aber auch 64-Bit Assembler produzieren.

      Zu 3.: Ja, das geht mit Call. Wenn du allerdings API oder Variablen verwenden willst, wird es ziemlich kompliziert. Ohne ist problemlos möglich.

      Mit XPIA hättest du den Vorteil, dass du deinen Assemblercode direkt in den XProfancode integrieren könntest, und trotzdem die komplette JWasm-Syntax nutzen kannst, inclusive Makros und API. Ausserdem erstellt er eine Dll aus dem Assemblercode, die du mit allen Sprachen verwenden kannst.
      Ein Beispielcode:

      Quellcode

      1. $MAKE CLE
      2. Declare x&,y&,z&,dauer&
      3. Cls
      4. x&=37
      5. y&=999999
      6. dauer&=&GetTickCount
      7. AsmStart Funktionsname1(x&,y&)
      8. mov eax,0
      9. mov ebx,para1
      10. mov ecx,para2 ;ecx als Schleifen-Zähler einsetzen
      11. .while ecx!=0 ;Schleife so lange wiederholen, bis ecx gleich Null ist
      12. add eax,ebx
      13. dec ecx ;Wert von ecx um eins subtrahieren
      14. .endw
      15. ;Diese Assemblerroutine macht das gleiche wie:
      16. ;
      17. ;x&=0
      18. ;Whileloop 999999
      19. ; x&=x&+37
      20. ;EndWhile
      21. ;
      22. ;Eine Schleife, die eine Millionen mal einen Wert addiert
      23. ;Dauer: XProfan = 18 Sekunden / XPIA = 1 Millisekunde
      24. AsmEnd (z&)
      25. dauer&=&GetTickCount-dauer&
      26. Print "Ich addierte 999999 mal 37 = "+Str$(z&)+", berechnet in "+Str$(dauer&)+" ms."
      27. WaitInput
      28. End
      Alles anzeigen


      Eine Assembler-Schnellkurs hab ich selber mal geschrieben. du findest ihn hier: paules-pc-forum.de/forum/sonst…ler-crashkurs-32-bit.html
      Gruß, Frank
    • Und danach (aber wirklich erst viel viel später!) wird das hier interessant:
      Iczelions Win32Asm Tutorials (36 Beiträge) - auf Deutsch übersetzt von Joachim Rhode.

      Gruss

      P.S.: Den neuesten JWasm gibts hier.
      Leider etwas veraltet ist dagegen das nachstehende Link zum Thema. In den Artikeln wird aber auf die Unterschiede, Stärken und Schwächen der einzelnen Freeware-Assembler besonders eingegangen.
      Win7-64HomPremSP1,XProfan11.2a,XPIA,JWasm,xpse,IntelCoreQuad2.5GHz/4GB/je1TB HD intern:esataBay:USB3
    • p. specht;882499 schrieb:


      Leider etwas veraltet ist dagegen das nachstehende Link zum Thema. In den Artikeln wird aber auf die Unterschiede, Stärken und Schwächen der einzelnen Freeware-Assembler besonders eingegangen.

      Der wichtigste fehlt dort ganz :-D
      Flat Assembler ? Wikipedia
      (der kann z.B. auch Linux oder sich selbst compilieren)
      Gruß Thomas
      Meine Hardware
      Wenn ich lügend sage, dass ich lüge, lüge ich oder sage ich Wahres?
      ComputerInfo für PPF
    • Frabbing;882525 schrieb:

      Kann JWasm doch auch:

      Hab ja auch nichts gegenteiliges Behauptet, dafür kenne ich den zu wenig.
      Ich weiß, ist Dein LieblingsAssembler, weil er die steinalte Syntax von MASM
      unterstützt :D. Für Einsteiger sollte das aber egal sein und FASM ist
      wesentlich bekannter, deshalb mein Hinweis. Entscheiden muss er wohl selber.
      Gruß Thomas
      Meine Hardware
      Wenn ich lügend sage, dass ich lüge, lüge ich oder sage ich Wahres?
      ComputerInfo für PPF
    • Die tun sich alle (ausser vieleicht der antike NASM) von der Syntax her nicht viel - ist wirklich minimal. Masm32/JWasm hat aber High-Level-Syntax und ist für Umsteiger daher optimal geeignet. Und es gibt dafür sehr aktive Foren zum Austauschen, wenn auch nur englisch-sprachig. Die deutschen Foren taugen nicht viel.
      Gruß, Frank
    • High-Level-Syntax kann FASM auch, das was Du vielleicht vermißt, dafür
      gibt es Macros, sollten im Ergebnis sogar effektiver sein, als eingebaute
      Funktionen.
      Aber im Endeffekt ist es ziemlich egal, die nehmen sich nicht viel und ASM
      ist für heutige PCs sowieso kein Werkzeug der ersten Wahl mehr.
      Außer zur PIC-Programmierung sollte ASM nutzlos sein ;-)
      Gruß Thomas
      Meine Hardware
      Wenn ich lügend sage, dass ich lüge, lüge ich oder sage ich Wahres?
      ComputerInfo für PPF
    • So...

      Das hier müsste doch eigentlich die Byte-Folge 0-1-2-3-4-5-6-7-8-9 in "MeinArray" schreiben, oder? Kann da mal jemand drüberschauen? ;-)

      Quellcode

      1. .code
      2. PUSHF
      3. PUSH eax
      4. PUSH ebx
      5. PUSH ecx
      6. LEA eax, MeinArray
      7. MOV ebx, eax
      8. Schleife:
      9. MOV ecx, eax
      10. SUB ecx, ebx
      11. MOV [eax], cl
      12. INC eax
      13. CMP ecx, 10
      14. JB Schleife
      15. POP ecx
      16. POP ebx
      17. POP eax
      18. POPF
      19. RET
      20. .data
      21. MeinArray db 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
      Alles anzeigen


      Ist das so richtig? Ist nämlich mein erster Gehversuch mit x86-Assembler ;-)


      Gruß
      Jonathan
      WICHTIG: Bitte diesen Virencheck durchführen: paules-pc-forum.de/forum/pc-si…infiziert.html#post902873
    • Nicht ganz. Dein Code ist jetzt so aufgebaut, dass hinter CMP ecx, der Offset des letzten Array-Elements stehen muss, nicht aber die Anzahl der Elemente!

      In deiner Anfangszeit mit x86-Assembler kannst du ja mal versuchen, den Weg, den der Prozessor mit dem Code geht, 'gedanklich' nachzustellen, z.B. so:

      Quellcode

      1. ; 9 Elemente wurden jetzt schon gefüllt. eax ist ebx+9 und zeigt damit auf das
      2. ; letzte Arrayelement. So weit, so gut. Gehen wir mal den restlichen Ablauf durch:
      3. MOV ecx, eax
      4. SUB ecx, ebx ; ecx ist 9
      5. MOV [eax], cl ; letztes Arrayelement wird mit einer 9 beschrieben
      6. INC eax ; WARNUNG: eax wird erhöht, ecx aber nicht
      7. CMP ecx, 10 ; ecx ist also immer noch 9 und damit kleiner als 10!
      8. JB Schleife ; FEHLER: Schleife wird nicht beendet
      9. MOV ecx, eax ; eax ist ebx+10, zeigt also werweißwohin!
      10. SUB ecx, ebx ; ecx ist 10
      11. MOV [eax], cl ; werweißwas wird mit einer 10 beschrieben
      12. INC eax ; ecx bleibt wie es ist
      13. CMP ecx, 10 ; 10 ist nicht kleiner als 10
      14. JB Schleife ; Schleife wird zu spät beendet
      15. POP ecx
      16. POP ebx
      17. POP eax
      18. POPF
      19. RET
      Alles anzeigen
      Verspätet ist übrigens auch meine Antwort auf deine Frage 3 ganz oben... :lol:
      Du wolltest wissen, ob das geht:

      Quellcode

      1. @Call(Addr(ASMCode#))
      Frank hat schon geantwortet, aber: Wenn du sowas doch mal ohne XPIA machen wolltest (sei es auch nur probehalber), dann musst du das Addr unbedingt weglassen:

      Quellcode

      1. @Call(ASMCode#)
    • Trotz XProfan-Forum will ich dich noch schnell was fragen:

      Frabbing;882621 schrieb:

      Statt JB besser JNE
      Was ist denn da der Vorteil (jetzt speziell in so einer aufwärts zählenden Schleife)?
      Zumindest bei Anfängern dürfte JB (oder generell der "<"-Operator) sicherer als JNE (<>) sein.
    • In dem Fall ist ja immer sicher, dass die Bedingung erreicht wird, ist auch schneller. JB ist nur für unsigned Werte, wenn dann besser JL nehmen für signed.

      Ich würd's so machen, dann ist gleich zu ersehen, wie die Schleife arbeitet. Ungetestet:

      Quellcode

      1. LEA ebx, MeinArray
      2. xor ecx, ecx
      3. Schleife:
      4. MOV [ebx+ecx], cl
      5. inc ecx
      6. CMP ecx, 10
      7. jne Schleife
      Gruß, Frank
    • Professor Chaos;882619 schrieb:

      Nicht ganz. Dein Code ist jetzt so aufgebaut, dass hinter CMP ecx, der Offset des letzten Array-Elements stehen muss, nicht aber die Anzahl der Elemente!


      Aaaah... Da hatte ich wohl Tomaten auf den Augen. Klar, wenn ich ecx nicht mit erhöhe... ;-)

      @Frabbing: Wenn ich dann noch Fragen habe, schreibe ich das dann unter "sonstige Programmiersprachen", mir ging es hier jetzt eben speziell darum, wie ich das im XProfan-Interpreter aufrufe (@Call(Code#)).


      Gruß
      Jonathan
      WICHTIG: Bitte diesen Virencheck durchführen: paules-pc-forum.de/forum/pc-si…infiziert.html#post902873