Assembler

Funktion optimieren

Finnegan — Tue, 09 Dec 2025 04:26:47 GMT

@Lennox sagte in Funktion optimieren: @Finnegan Du hast in der Optimierung zwar genau einen Sprung weniger... dafür aber 8 Operatoren mehr (wenn ich richtig gezählt habe...). Ich glaube, das lohnt nicht... so teuer kann ein kleiner Sprung doch kaum sein. Aber das kann ich ad-hoc nicht mit Gewissheit sagen. Es ging mir in erster Line auch um ein verständliches Beispiel für einen Branchless-Ansatz. Die Zeilen hatten sich angeboten, weil es da relativ simpel war. Ich denke aber auch, dass sich das hier nicht unbedingt lohnt. Aber dennoch: immer messen! Wenn du wirklich zufällige Arrays sortierst, könnte es der Branch Predictor schwer haben und durchaus 50% falsche Vorhersagen treffen. Das ist auch nicht ganz billig. Ein überraschendes Ergebnis selbst hier ist also nicht ausgeschlossen. Das unterstreicht aber vor allem, dass bei solchen Messungen die Verteilung der Test-Daten nicht ganz unerheblich ist. Nur gleichverteilte Zufallszahlen zu testen liefert also nicht unbedingt ein vollständiges Bild. Zumal reale Daten auch nur selten so verteilt sind. Das ist auch der Grund warum ich bevorzuge, alle Algorithmen mit den gleichen Eingabedaten zu testen: weil diese selbst beim selben Algorithmus Einfluss auf das Messergebnis haben können. Und Google Benchmark weil ich (ohne es jetzt konkret zu wissen) davon ausgehe, dass das vorher u.a. auch den Branch Predictor "zurechtstutzt".

Assembler-Testumgebung für totale Anfänger

Erhard Henkes — Sun, 04 Aug 2024 19:34:54 GMT

https://www.henkessoft.de/Assembler/Assembler.htm https://www.henkessoft.de/Roboter/stk500.htm

Assembler Code Erklärung benötigt

Jan_2000 — Thu, 02 Nov 2023 09:35:37 GMT

Moin Leute, ich habe ein Assembler-Code bei dem ich die Berechnung der Summe und des Mittelwerts nicht verstehe. Kann mir jemand vielleicht das Programm erklären ? oder eventuell ein Flussdiagramm dazu erstellen. Ich bedanke mich für jede Hilfe im voraus. Hier ist das Programm: main: ; Hauptprogramm (Einsprung nach RESET) ;Ergebnissfelder Intialisieren Mov 28H, #0 Mov 29H, #0 ;Register Initialisieren Mov R5, #0 ;Schleifenzähler (Loop2) Mov R4, #0 ;Dividend Mov R3, #0 ;Summe (höheres Byte) Mov R2, #0 ;Summe Mov R1, #0 ;Schleifenzähler Mov R0, #0 ;Aktuelle Adresse ; Aufruf der Subroutine call INITC ;Alternative call INITB ;oder call INITA MOV R0, 20H ; Inhalt der Adresse 20H in Register 0 (Basisadresse in R0) MOV R1, 21H ; Inhalt der Adresse 21H in Register 1 laden (Anzahl in Messwerte in R1) ;Berechnung der Summe LOOP1: CLR C; Carry leeren MOV A, R2 ;Inhalt von Register 2 in Akku laden ADD A, @R0 ; Akku um den Wert in der Speicheradresse erhöhen, die in Register 0 gespeichert ist MOV R2, A ;Akku in Register 2 Laden JNC CarryNotSet1 ; Springe zum CarryNotSet 1, wenn Carry nicht gesetzt INC R3; Inkrementiere Inhalt von Register 3 CarryNotSet1: INC R0 ; Inkrementiere Inhalt von Register 0 (Adresse des Messwerts inkrementieren) DJNZ R1, LOOP1 ;Dekrementiere Inhalt von Register 1; springe zu Loop1 ;Berechnung Mittelwert MOV A,R3 ;Inhalt von Register 3 in Akkuladen MOV R4,A ;Akku in den Register 4 Laden MOV R5, #80H CLR C ;Carry leeren LOOP2: MOV A, R2 ;Inhalt von Register 2 in Akku laden ANL A, R5 ; Akku mit Inhalt von Register 5 logisch verbunden JZ AccEqZero1 ;Springe zu AccEqZero1, ;wenn Akku gleich Null SETB C ;Carry setzen AccEqZero1: MOV A, R4 ;Inhalt von Register 4 in Akku laden RLC A ; Linksverschiebung des Akkus inkl.Carry MOV R4, A; Akku in Register 4 laden ) MOV B, 21H ;Inhalt der Adresse 21H in B laden (Anzahl Messwerte bzw.Divisor in DIV AB ; Division A/B (Dividend/Anzahl Messwerte) CLR C ;Carry leeren JZ AccEqZero2 MOV A,R4 ;Inhalt von Register 4 in Akku laden SUBB A, 21H ; Adresse 21H von Akku Subtrahieren MOV R4, A ;Akku in den Register 4 laden SETB C ;Carry setzen AccEqZero2: MOV A, 28H ;Inhalt der Adresse 28H in Akku laden RLC A ; Linksverschiebung des Akkus inkl.Carry MOV 28H, A ; Akku in Adresse 28H laden MOV A, R5 ;Inhalt von Register 5 in Akku laden RRC A ; Rechtsverschiebung des Akkus inkl.Carry MOV R5, A ; Akku in Register 5 laden JNZ LOOP2 ; Springe zu LOOP2, wenn Akku ungleich 0 ;--Programmende-------------- ENDE: sjmp ENDE ; Subroutine INITA für Teilaufgabe A ;kann mit call INITA aufgerufen werden) INITA: ; Adresse der ersten Zahl mov 20H, #30h ; Anzahl Zahlen mov 21H, #5h ; Zahlen mov 30h, #1h mov 31h, #4h mov 32h, #7h mov 33h, #8h mov 34h, #0h ; Ruecksprung aus Subroutine ret ;--Subroutine INITB für Teilaufgabe B -- INITB: MOV 20H, #35H ; Adresse des ersten Messwertes MOV 21H, #10H ;Anzahl Messwerte MOV 35H, #01H MOV 36H, #02H MOV 37H, #03H MOV 38H, #04H MOV 39H, #05H MOV 3AH, #06H MOV 3BH, #07H MOV 3CH, #08H MOV 3DH, #11111111B MOV 3EH, #11111110B MOV 3FH, #11111101B MOV 40H, #11111100B MOV 41H, #11111011B MOV 42H, #11111010B MOV 43H, #11111001B MOV 44H, #11111000B ret ; Ruecksprung auf Subroutine ;--Subroutince INITC für Aufgabenteil C INITC: MOV 20H, #45H ; Adresse der ersten Zahl MOV 21H, #0AH ; Anzahl Zahlen MOV 45H, #10100111B ; Zahlen beginnend ;bei Basisadresse MOV 46H, #10101111B MOV 47H, #11001011B MOV 48H, #09H MOV 49H, #00111111B MOV 4AH, #23H MOV 4BH, #24H MOV 4CH, #10101000B MOV 4DH, #83H MOV 4EH, #01101101B ret ; Rücksprung aus Subroutine end; Ende des Assembler-Codes

RISC-V, Funktionen?

EinNutzer0 — Sat, 22 Jan 2022 18:42:20 GMT

@Finnegan sagte in RISC-V, Funktionen?: Ist das ne Übungsaufgabe oder wird daraus eigener Code Beides. Aber keine Angst, ein Flugzeug wollte ich nicht programmieren. Aber ja, addi a0, a0, 5 ginge genauso. (Ohne s0...) Aber das ist vornehmlich eine Übung für mich.

Raspberry Pi 3 (aarch64) in Assembler programmieren

Hirnfrei — Tue, 09 Nov 2021 21:03:08 GMT

@Finnegan sagte in Raspberry Pi 3 (aarch64) in Assembler programmieren: @Hirnfrei sagte in [Raspberry Pi 3 (aarch64) in Das absolute Sahnehäubchen wäre natürlich noch, einen gdbserver-Stub in deinem Code ans laufen zu bekommen. Damit könnte man dann sogar Remote-Debuggen. Also in deinem Editor Breakpoints setzen, durch das Programm steppen und gleichzeitig via HDMI eine Ausgabe zu haben. Da kann ich aber keine Tips geben, wie man das genau angeht, das habe ich in der Form noch nie gemacht. Dafür müsste man dem gbserver beibringen, den seriellen Port des Raspi zu nutzen. Gut möglich aber, das es da schon fertige Lösungen gibt. Denke da lohnt sich eine Recherche, wenn du dein Projekt wirklich so durchziehen willst. Da ist qemu ja wirklich von Vorteil. Da kann ich das starten. Mache ich auch schon die ganze Zeit so. Hat schon Recht, dass wäre echt der Knaller! Das klingt ja schonmal nach nem Plan. Allerdings bin ich mir nicht so sicher, was du mit "Datei laden" meinst. Das Thema haben wir ja schonmal angesprochen. Du hast kein Dateisystem und auch noch keine libc. D.h. auch keine lowlevel-Funktionen, mit denen man irgendwie Dateien öffnen könnte (open/close/read/write). Ja, noch nichtmal ein malloc, d.h. es funktionieren derzeit nur statische Allokationen wie der funktionslokale "Hallo Welt"-String, oder irgendwelche Arrays fester Größe. Nimm "Datei laden" nicht zu wörtlich. Eben den Inhalt einer Datei da rein bekommen. Ob jetzt fest eingelötet, wie du mir den Link geschickt hast, oder über Dateisystem, oder Bytes von dem Datenträger lesen, oder eigens Filesystem bauen, spielt da jetzt keine wirklich Rolle. Ich meine damit einfach nur, den Inhalt einer Datei in das (wie nennt man das jetzt eigentlich? OS? Bare-Metal-OS?) Programm zu bekommen um damit zu arbeiten. Auf welchem Weg lasse ich einfach mal offen. Genau genommen weiss ich auch noch gar nicht, wofür ich es benutzen werden. Ideen habe ich da viele. Vielleicht so eine Art GrundOS bauen, was sich dann aus einer spezifischen Datei das eigenliche Programm holt? Oder, was ich mir gerade eher vorstellen könnte, wäre Einstellungen für den ODB2 damit zu setzen, ohne gleich das Programm neu bauen zu müssen. Nicht jedes Steuergerät gibt die gleichen Daten raus. So könnte ich das selbe Programm auch einfach für mein zweites Auto verwernden. Als Beispiel jetzt mal. Ich will eben einfach die Möglichkeit haben, da auch Daten laden zu können. Wobei speichern auch cool wäre. GPS Daten als Fahrtenbuch oder so. Oh je, bei mir ist gerade eine Idee eingeschlagen ... Ich hab schon ein Video gesehen, wo sehr gut die Nutzung vom Mini-UART demonstriert wird. Ich könnte meinem Pi ja ein Floppy bauen :). Als ein SD.-Card Lesegerät. Mit einem Arduino ist das auslesen und speichern auf eine SD-Karte ja easy. Hab ich schon oft gemacht auch formatieren, Daten auslesen und das alles. Die Daten könnte ich dann ja zum Pi über UART schaufeln. Boah. Entdecke die Möglichkeiten! Ich benötige sowas nur wirklich selten, da ich kaum so hardwarenahe Sachen mache, aber einen Zeiger auf eine feste Adresse zeigen zu lassen, müsste in etwa so gehen: unsigned char* memory = (unsigned char*) (0xabcd); Einfach ein Integer-Literal mit der gewünschten Adresse in einen Pointer casten. In C++ dann mit reinterpret_cast. Mit char-Pointern sollte das unproblematisch sein, beim wildem hin- un her-casten sollte man aber vorsichtig sein, da können eventuell Regeln zu Strict Aliasing und in C++ Regeln zur Lebenszeit und zu uninitialisierten Objekten reinspielen. Da kommt man schonmal schnell in UB-Territorium. Das teste ich mal.. Klarr, vorsichtig muss man da sein. Würde ich auch nur dann nutzen, wenn es notwendig ist. Siehe unten. Speicher, dessen Inhalt auch unabhägig von deinem Programm von der Hardware geändert werden kann, sollte zudem auch noch über einen volatile-Pointer angesprochen werden. Sonst könnte Compiler anfangen, Leseoperationen rauszupotimieren, weil der Speicher innerhalb des C-Programms ja gar nicht modifiziert wurde. Das wäre dann für Pointer, über die du mit der Hardware kommunizierst und diese dir auch antwortet, indem sie in den Speicher schreibt. Für einen Framebuffer selbst sollte man das aber noch nicht benötigen. Wohl aber für Pointer auf irgendwelche Hardware-Register. Prinzipiell geht es mir auch nur darum. Wenn ich bei Assembler eins gelernt habe, dann das Hardware immer irgendwo in den Speicher gemampt ist und den muss man ja dann auch ansprechen können.

RISC-V, float-Konstante in Register laden

EinNutzer0 — Thu, 20 May 2021 16:10:01 GMT

püschel Bitte sagt mir, was falsch ist. Ich bin mit meinem Latein am Ende. Laut Debugger (der ist bei der VS Code-Erweiterung übrigens auch dabei) sieht alles gut aus, bis auf diese Zeile: fdiv.s f17, f17, f19. Danke für jeden Input.

E-Books Einführung in Assembler wo finde ich Lesestoff

*john 0 — Mon, 17 May 2021 16:25:10 GMT

Wenn Du nach Assembler Lehrmaterial suchst, solltest Du schon dazu schreiben für welche Plattform das gedacht ist. Denn Assembler ist immer Plattform spezifisch.

Assembler Programme, Lösung

Kajam — Thu, 22 Oct 2020 14:42:52 GMT

Habe ich gemacht. Ich habe es aufgeschrieben. Die letzte Antwort von mir: https://www.techniker-forum.de/thema/assembler-programme-loesung.122091/ Mir sind dabei nochmal zwei fragen entstanden. Ist das richtig so? Die Fragen sind dann: Was ich mich aber noch frage ist, wozu gibt es den Schritt 02? Hier lande ich doch gar nicht im Programm. Und wozu die drei Punkte nach Schritt 06, da geht es doch nicht weiter?

windbg und Speicher durchsuchen...

tomycat2009 — Wed, 08 Apr 2020 11:50:42 GMT

thx, ich habe folgendes eingegeben: s -d 0x00000000 L?0xffffffff ffdf1234 ... nach 30 min warten habe ich abgebrochen, ich will nur die eine Speicher stelle haben: ffdf1234 kann ich den Suchbefehl beschneunigen, so auf 10 min?

Verstaubte ASM-Literatur in den FAQs

titan99_ — Sun, 05 Apr 2020 07:52:03 GMT

Wegen UEFI erkennt SSD an USB nicht, habe ich EDK II, ähm oder UDK unter Windows erstellt. Dazu braucht es u. a. NASM Assembler.

arg_4 rückwertsrechnen..

Bashar — Sun, 29 Mar 2020 12:52:08 GMT

@tomycat2009 sagte in arg_4 rückwertsrechnen..: [ebp + arg_4] ist gleichzusetzen mit [ebp + 4], wenn die arg_4 4 Byte groß ist. Es geht nur um den Speicherort, mehr nicht? Ist das so, dann habe ich es verstanden. :--) Naja, es ist gleichzusetzen mit [ebp+12], weil 12 bzw. 0x0C nunmal der Wert von arg_4 ist. Die Größe stammt aus dem dword ptr und ... die Größe ist etwas anderers als der Speicherort.

IDA free und Funktionen analysieren...

tomycat2009 — Sat, 28 Mar 2020 10:18:14 GMT

ich habe es hinbekommen, Paraemter 1,2,3.. wird als Block dargestellt. Aus diesem muss herausgefriemel werden, welcher erster 1,2,3,,, Paraemter ist. Man zieht Werte ab vom Block Als erstes die Differnez aus -8 und -0ch .... ist der erste Parameterwert.

Was tut dieser Assembly Code? (Anfängerfrage)

EinNutzer0 — Wed, 18 Sep 2019 11:25:31 GMT

@SeppJ sagte in Was tut dieser Assembly Code? (Anfängerfrage): @EinNutzer0 sagte in Was tut dieser Assembly Code? (Anfängerfrage): @SeppJ sagte in Was tut dieser Assembly Code? (Anfängerfrage): in eine entsprechende Zahlenfolge, die für einen Computerprozessor verständlich ist Danke, ja das meinte ich... Ja, aber willst du da noch speziell was wissen? Bis jetzt, aktuell, keine konkreten Fragen... Aber was nicht ist das kann in ein paar Tagen noch kommen! Vielen Dank.

ASM in unmanaged C++ Klasse als Teil eines /clr Projektes

7x7-7 — Tue, 03 Sep 2019 20:17:08 GMT

Hallo Community, ich möchte gerne eine FFT , die spezielle FPU Kommandos verwendet als x86 asm Routine in einer unmanaged C++ Klasse verwenden, die dann Bestandteil eines managed Projektes ist (/clr in VS2008). Mit den hier und da im Netz vorhandenen Informationen bin ich schon mal soweit gekommen, dass überhaupt erstmal Zugriffe von und zu Klassenmember Variablen aus dem asm block mit mov Befehlen möglich ist. Allerdings scheint das Ganze bei dem asm Befehl „fld“ nicht so einfach zu funktionieren. Hier mal meine Try and Errors: class DoSomething { float VAR; void Crash1() { __asm{ fld [this].VAR } void Crash2(void * thisPointer) { __asm{ fld [thisPointer].VAR } } void Geht1() { __asm { mov ecx, [this] fld [ecx].VAR } } void Geht2(void * thisPointer) { __asm { mov ecx, [thisPointer] fld [ecx].VAR } } void Naja() { float locVAR; locVAR = VAR __asm{ fld locVAR } } DoSomething() { VAR = 1.0; Crash1(); Crash2(this); Geht1(); Geht2(this); Naja(); } }; Crashen tut es immer aufgrund einer Memory Accessviolation - vermutlich weil nicht die richtige Addresse übergeben wird. Da leider alle Register in der FFT Routine verwendet werden kann ich die Variante "Geht" nicht verwenden (bzw. müsste dann erhebliche Änderungen am eigentlich sehr schnellen FFT Code vornehmen). Die Variante "Naja" will ich mal aus Performancegründen ausklammern. Da meine beschränkten Kenntnisse aus dem Mikrokontrollerkosmos mir hier nicht mehr weiterhelfen würde ich mich über hilfreiche Kommentare von Euch sehr freuen.

DLX Pipeline mit Takthalbierung in IF,ID,MEM und WB

Nastypasty — Tue, 25 Jun 2019 14:32:10 GMT

Danke, werde mir das ansehen...

DLX einzelne bits prüfen (Parity checker)

wob — Mon, 06 May 2019 21:36:29 GMT

Du hast mehrere Möglichkeiten. Entweder du schiebst eine Testmaske über deine Zahl du zählt, wie oft da nicht-0 herauskommt. Oder lässt die Testmaske gleich (=1) und schiebst deine Zahl darüber und zählst dort. Kann doch nicht so kompliziert sein. Mal dir das vielleicht mal auf Papier auf, falls das hilft. Am einfachsten ist wahrscheinlich: lade deine Zahl in ein Register R solange R > 0: teste niedrigstes Bit (und zähle mit, wie oft es exisitert) schiebe R 1 Bit nach rechts teste, ob Anzahl Bits gerade/ungerade ist

Assembler in DOS: Abstände im Speicher

Swordfish — Thu, 24 Jan 2019 11:27:41 GMT

@oser sagte in Assembler in DOS: Abstände im Speicher: Und gibt es einen guten DOS-Debugger, womit ich mir während dem Programmablauf alle Register und Speicherstellen anzeigen lassen kann? Besorg Dir Borland C++ 3.1 ... ist inzwischen Abandonware und hat einen netten Debugger.

vollständige Funktionssignatur ausgeben

EinNutzer0 — Sun, 05 Aug 2018 17:22:01 GMT

@swordfish sagte in vollständige Funktionssignatur ausgeben: IDA nehmen. Hab ich schon, die letzte kostenlose Pro- Version von '15. Aber anscheinend gibt IDA keine C-Funktionssignaturen aus - oder diese sind unvollständig oder falsch. Zudem möchte ich anmerken: lacks all features introduced in IDA > v7.0. @mechanics sagte in vollständige Funktionssignatur ausgeben: Also, was willst du damit konkret machen? Mein Programm hacken/hooken.

lea vs mov

camper — Sun, 18 Mar 2018 09:25:24 GMT

der explizite byte override in byte [a] ist nicht erfordelich. in yasm ist a ein Symbol für eine Adresse, wärend [a] einen Speicherverweis darstellt, also das Objekt meint, auf dass a zeigt. In C-Begriffen quasi ein Zeiger bzw. ein lvalue. move kopiert das Argument, lea liefert die effektive Adresse eines Speicherverweises, Letzteres ist also so etwas wie der &-Operator in C.

Brauche Hilfe, bei einen Spamfilter in Assembler.

UniStudent69 — Wed, 17 Jan 2018 13:53:22 GMT

Hey Leute, ich bin ein blutiger Anfänger in Assembler, und ich soll einen Spamfilter für Emails schreiben, der für jedes "Badword" die "Gewichtung" erhöht. Mein Gedanke war der das ich zuerst auf das erste Email-Wort gehe das mit allen "Badwords" abgleiche und dann halt, wenn es mit allen Badwords abgeglichen wurde auf das nächste Email-Wort gehe. Natürlich hab ich einige Fehler im Code, die ich leider nicht überprüfen kann, da QTSpim einfach beim Laden der Datei "Keine Rückmeldung" mehr gibt. Ich dachte zuerst das irgendwo eine Endlosschleife drin ist, und einfach irgendwo was vergessen habe, aber nach exzessiven Suchen nichts gefunden habe, wende ich mich nun an das Forum. Ich weiß das der code momentan bei "bne email_buffer(a2),badwords_buffer(a2), badwords\_buffer(a2),badwords_buffer(a3), Else3" ein "Syntax Error" hervor bringt. Danke schon mal in voraus. Hier ist der jetzige Code den ich habe. spamfilter: ### Register gemaess Registerkonventionen sichern addi $s1, $s1, -20 sw $a0, 0($s1) sw $a1, 4($s1) sw $a2, 8($s1) sw $a3, 12($s1) sw $v0, 16($s1) ### Badwords liegen im Puffer badwords_buffer ### Der Text der E-Mail liegt im Puffer email_buffer ### Schleife ueber Bad words (wort1,gewicht1,wort2,gewicht2,...) ### lese ein Wort ### lese und konvertiere Gewicht ### suche alle Vorkommen des Wortes im Text der E-Mail und addiere Gewicht add $a0, $zero, $zero # Value von $a0 wird auf Null gesetzt add $a1, $zero, $zero # Value von $a1 wird auf Null gesetzt add $a2, $zero, $zero # Value von $a2 wird auf Null gesetzt add $a3, $zero, $zero # Value von $a3 wird auf Null gesetzt add $v0, $zero, $zero # Value von $v0 wird auf Null gesetzt la $t0, size #lade Addresse size auf $t0 la $t1, badwords_size #lade Addresse badwords_size auf $t1 for: beq $a0, $t0 , Endif # Wenn x/a0 == EmailWörter, wenn alle Email Wörter durchgelaufen wurden, beende loop beq $a1, $t1, Else2 # Wenn i/a1 == 20 gehe zu Else2 um das nächste Wort der Email zu benutzen bne email_buffer($a2), badwords_buffer($a3), Else3 # Email_buffer != badwords_buffer um das nächste Wort der Badwords zu benutzen beq email_buffer($a2), badwords_buffer($a3), Else # Wenn Email_buffer == badwords_buffer gehe zu else um Gewicht zu addieren j for # Schleifen wiederholung Else: # Gewichtung wird hochgezählt und zu Else2 verwiesen addi $v0, v0, 1 # v0/Gewicht wird hochgezählt j Else2 # Geht zu Else2 Else2: # Nächstes Email Wort wid ausgewählt und die Schleife wiederholt add $a1, $zero, $zero # i/$a1 wird auf Null gesetzt um wieder von vorne die Wörter durchlaufen zu können add $a3, $zero, $zero # $a3 wird auf Null gesetzt um wieder von vorne die Wörter durchlaufen zu können addi $a2, $a2, 4 # Wählt nächstes Email Wort aus addi $a0, $a0, 1 # x/a0 wird hochgezählt j for # Schleife wird wiederholt Else3: addi $a1, $a1, 1 # i/$a1 wird hochgezählt addi $a3, $a3, 4 # Wählt nächstes BadWort aus j for # Geht zu for Endif: #v0/Gewichtung wird zurückgegeben ### Rueckgabewert setzen lw $v0, 16($s1) addi $s1, $s1, 4 ### Register wieder herstellen jr $ra .data email_buffer: .asciiz "Hochverehrte Empfaenger,\r\n\r\nbei dieser E-Mail handelt es sich nicht um Spam sondern ich moechte Ihnen\r\nvielmehr ein lukratives Angebot machen: Mein entfernter Onkel hat mir mehr Geld\r\nhinterlassen als in meine Geldboerse passt. Ich muss Ihnen also etwas abgeben.\r\nVorher muss ich nur noch einen Spezialumschlag kaufen. Senden Sie mir noch\r\nheute BTC 1,000 per Western-Union und ich verspreche hoch und heilig Ihnen\r\nalsbald den gerechten Teil des Vermoegens zu vermachen.\r\n\r\nHochachtungsvoll\r\nAchim Mueller\r\nSekretaer fuer Vermoegensangelegenheiten\r\n" size: .word 550 badwords_buffer: .asciiz "Spam,5,Geld,1,ROrg,0,lukrativ,3,Kohlrabi,10,Weihnachten,3,Onkel,7,Vermoegen,2,Brief,4,Lotto,3" badwords_size: .word 93 spamscore_text: .asciiz "Der Spamscore betraegt: "

Assembler und Funktionsaufrufe

camper — Sat, 06 Jan 2018 21:31:36 GMT

CCat schrieb: Der Assembler sieht so aus: push ebp mov ebp, esp sub esp,0x18 and esp,0xffffffff0 mov eax,0x0 sub esp,eax mov DWORD PTR [esp+12], 0x4 mov DWORD PTR [esp+12], 0x3 mov DWORD PTR [esp+12], 0x2 mov DWORD PTR [esp+12], 0x1 call Ich nehme mal an, dass das kein copy&paste ist. Die Adressen der Funktionsargumente können so ja offensichtlich nicht stimmen. Mit welchem Compiler auf welchem System mit welchen Compiler-Einstellungen wurde dieser Code erzeugt? CCat schrieb: So, was ich nicht genau verstehe ist, warum macht man: and esp,0xffffffff0 mov eax,0x0 sub esp,eax Warum führt man auf dem esp ein logisches und mit dieser Zahl aus und warum schiebt man dann eine 0 ins eax und zieht diese von esp wieder ab? *Man* macht nicht, der Compiler hat sich in diesem speziellen Fall dazu entschieden, diesen Code zu erzeugen. Das and dürfte dazu dienen, den Stack auf 16 Byte auszurichten - gcc macht das z.B. einmalig in main, um dann ohne weiteren Aufwand mit automatischen SSE-Variablen umgehen zu können. Der Zweck des mov eax+sub erschließt sich daraus nicht; es könnte sich evtl. um Padding handeln, um Debugging zu erleichtern. CCat schrieb: Zweitens: sub esp,0x28 mov DWORD PTR [ebp-12], 0x7a69 ;das ist halt die 31337 in hexadezimal mov BYTE PTR [ebp-40], 0x41 ;ist das A in ASCII Hier werden ja durch sub esp,0x28 40 Byte resaviert. Warum 40? Der Int und die 10 char's des Arrays sind doch insgesamt nur 14 Byte, oder? Und warum schiebe ich die 0x7a69 ab der Stelle [ebp-12] in den RAM und nicht ab Stelle [ebp-4]? Der Compiler ist nicht gezwungen, Variablen direkt aufeinander folgend anzuordnen. Insbesondere um Arrays herum wird bei ausgelassener Optimierung gerne etwas Platz gelassen, um Bereichsüberschreitungen erkennen zu können.

IDD Personalausweis Prüfziffer berechnen in nasm

nachtfeuer — Sun, 10 Dec 2017 13:54:35 GMT

Das sieht doch für einen ersten Einstieg schon recht ordentlich aus. Der ein oder andere Flüchtlings Flüchtigkeitsfehler versteckt sich noch hier und da. 1. Es wird grundsätzlich bzw. immer implizit durch eax geteilt. 2. du willst ja Mod 10 haben 2a) das geht hier mit einer logischen Operation besser/schneller/eleganter: AND AL "0F" also 00001111 - fertig 2b) bei Wort - bzw. Bytegrößen geht die Division mit Rest über AH und AL (der Rest in AL). (2 c puristique: hier auch mit BCD-Zahlen herummachen, falls interessiert.) 3. Extra mit 1 multiplizieren braucht man gar nicht. 4. in dem Assemblertutbuch ("Programming from the Ground Up") von Jonathan Bartlett ist ein kleiner praktischer Handzettel für den GDB. 5. Einleseroutinen für Strings platzieren diese in aller Regel in den Speicher, aber Repetierbefehle benutzen u.a. Si und Di zum Indexieren (deswegen + x + y usw. mit LEA -> z.B. mehrdimensionale Tabellenanlagen. Mit DB oder DW werden in aller Regel Zeichenketten codiert, die im Speicher abgelegt werden, genau wie der Assemblercode bzw. kann die Zeichenkette genau das sein (-> Hexeditor).

Kleine Frage von Anfänger

nachtfeuer — Thu, 26 Oct 2017 13:57:06 GMT

ghjgh schrieb: 2. Da es ein 16 bit Befehl ist, werden 6 bit für den Befehl und 10 bit für die Zahl verwendet? Es gelten bei 16 Bit 8 Bit für den Sprung-Befehl und 8 Bit für die Sprunglänge. Einen 16 Bit-Befehl überspringen wäre dann bei 7E -> 7EFC. ghjgh schrieb: Zeile 1: speicher 00881038h in ebx, setze eip auf nächsten Befehl ?? (Es steht im Kommentar bzw. im Gesamttext, was genau passiert)

[x64 ASM] Kann man einen einzelnen Float direkt in xmm01 kopieren?

KratzKatz — Wed, 11 Oct 2017 13:36:05 GMT

Danke, hab's mit Hilfe dieser Seite nun ganz verstanden

[x64 ASM] MOVBE führt immer zu Exceptions

KratzKatz — Mon, 09 Oct 2017 14:05:16 GMT

camper schrieb: Hast du geprüft, ob dein Prozessor diese Instruktion überhaupt unterstützt (CPUID.01H:ECX.MOVBE[bit 22] gesetzt) ? Nicht unterstüztzt (i3-2100). Danke

Schleife&Verzweigung, Hilfe!!!!

KratzKatz — Mon, 09 Oct 2017 13:51:49 GMT

#include using namespace std; extern "C" __int64 _stdcall assembly(unsigned __int32 n); int main() { unsigned __int32 n = 0; cin >> n; cout << assembly(n) << endl; system("pause"); return 0; } .code MySegment segment read write execute backup_rax dq 0 backup_rbx dq 0 backup_rcx dq 0 assembly proc ; n ist in rcx mov backup_rax, rax ; mache Backup von rax mov backup_rbx, rbx ; mache Backup von rcx mov backup_rcx, rcx ; mache Backup von rbx mov rax, rcx ; kopiere rcx (n) in rax, weil rax zurückgegeben wird mov rbx, 3 ; kopiere 3 in rbx, weil mul keine immediate-Werte erlaubt start_: ; label für die While-Schleife cmp rax, 50 ; vergleiche rax (n) mit 50 jae ende ; wenn größer oder gleich, breche schleife ab mul rbx ; sonst multippliziere n mit 3 add rax, 2 ; addiere 2 zu n cmp rax, 50 ; vergleiche n mit 50 jbe start_ ; wenn kleiner oder gleich, wiederhole Schleife sub rax, 3 ; sonst subtrahiere 3 von rax jmp start_ ; wiederhole Schleife ende: ; Label nach der Schleife mov rbx, backup_rbx ; rbx wiederherstellen mov rcx, backup_rcx ; rcx wiederherstellen ret ; gebe den neuen Wert n wieder zurück mov rax, backup_rax ; rax wiederherstellen assembly endp MySegment ends end Man könnte Zeile 16 weglassen und imul rax, rax, 3 nehmen. Aber es war ja von unsigned die rede (imul beschreibt eine vorzeichenbehaftete Multiplikation)