Assembler – die besten Beiträge

hi leute ich bedanke mich schon mal im voraus , denn dass hier bringt meinen kopf zum qualmen:

section .data

  window_class_name db "BlackScreenClass", 0

  window_title db "", 0

  WM_CLOSE equ 0x0010 ; Define WM_CLOSE

section .bss

  hwnd  resd 1

  hInstance resd 1

  lpMsg  resb 24

section .text

  global _start

  extern GetModuleHandleA, CreateWindowExA, ShowWindow, UpdateWindow, GetMessageA, TranslateMessage, DispatchMessageA, DefWindowProcA, ExitProcess, SetBkColor, GetSystemMetrics

_start:

  push  0

  call  GetModuleHandleA

  mov   [hInstance], eax

  push  0

  push  window_title

  push  window_class_name

  push  dword (WS_POPUPWINDOW | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX)

  push  0

  push  0

  push  SM_CXSCREEN

  call  GetSystemMetrics

  push  eax

  push  SM_CYSCREEN

  call  GetSystemMetrics

  push  eax

  push  0

  push  0

  push  [hInstance]

  push  0

  call  CreateWindowExA

  mov   [hwnd], eax

  push  0

  push  [hwnd]

  call  SetBkColor

  push  SW_SHOWNORMAL

  push  [hwnd]

  call  ShowWindow

  push  [hwnd]

  call  UpdateWindow

message_loop:

  lea   esi, [lpMsg]

  push  0

  push  0

  push  0

  push  esi

  call  GetMessageA

  cmp   eax, 0

  je   exit

  push  esi

  call  TranslateMessage

  push  esi

  call  DispatchMessageA

  jmp   message_loop

window_proc:

  cmp   dword [esi + 0], WM_CLOSE

  je   handle_close

  push  dword [esi + 4]

  push  dword [esi + 0]

  push  dword [esi + 8]

  push  dword [esi + 12]

  call  DefWindowProcA

  ret

handle_close:

  push  0

  call  ExitProcess

  ret

exit:

  push  0

  call  ExitProcess

WS_POPUPWINDOW equ 80000000h

WS_CAPTION equ 00C00000h

WS_SYSMENU equ 00080000h

WS_THICKFRAME equ 00040000h

WS_MINIMIZEBOX equ 00020000h

WS_MAXIMIZEBOX equ 00010000h

SW_SHOWNORMAL equ 1

SM_CXSCREEN equ 0

SM_CYSCREEN equ 1

ich bin erst anfänger und möchte wenn mit nasm versuchen den asm code zu obj zu machen aber dort kommt ganze zeit dieser fehler:

C:\Users\Rocke\Desktop\CoptixMW\Services>set FILEPATH=C:\Users\Rocke\Desktop\CoptixMW\Services\

C:\Users\Rocke\Desktop\CoptixMW\Services>C:\Users\Rocke\Desktop\CoptixMW\Services\nasm.exe -f win32 C:\Users\Rocke\Desktop\CoptixMW\Services\boot_window.asm -o boot_window.obj

C:\Users\Rocke\Desktop\CoptixMW\Services\boot_window.asm:36: error: operation size not specified

C:\Users\Rocke\Desktop\CoptixMW\Services\boot_window.asm:42: error: operation size not specified

C:\Users\Rocke\Desktop\CoptixMW\Services\boot_window.asm:46: error: operation size not specified

C:\Users\Rocke\Desktop\CoptixMW\Services\boot_window.asm:49: error: operation size not specified

C:\Users\Rocke\Desktop\CoptixMW\Services>pause

Drücken Sie eine beliebige Taste . . .

naja wie es so ist habe ich ki um rat gefragt MEHRMALS, sie konnte mir nicht weiterhelfen

, dieses skript soll vor dem login fenster in windows, ein anderes fenster drücber einblenden , es soll oben rechts ein kreuz haben zum schliessen , einen schwarzen hintergrund haben und im vollbild, natürlich teste ich es auf einer vm

DANKE IM VORAUS

Den Linux-Kernel kann man ja sehr tiefgehend konfigurieren.

Aber gibt es eigentlich auch eine Art Kernel-Framework, bei dem man noch deutlich tiefer ins System eingreifen kann (d.h. bis hin zur Speicher- und Prozessverwaltung)? Sodass man u.a. den Speicherschutz, das Paging, Multihreading (gar Multitasking) abstellen kann oder statt präemptiven auch kooperativen Multitasking einsetzen kann? Ein Framework, mit dem man seine eigene Philosophie in das Betriebssystem einbringen kann, d.h. was nicht zwingend unixod sein braucht, sondern ganz im Sinne des Entwicklers? Das heißt, dass man "auf die Schnelle" ein hochmodernes Betriebssystem wie Linux entwickeln kann, ein Betriebssystem nach seinen ganz eigenen Philosophien oder auch ein so derart einfaches wie DOS.

Habe eine Push und Pop Anweisung hinzugefügt und ein paar Rechtschreibfehler entfernt. Gibt es noch Verbesserungen die man vornehmen könnte?

[ENABLE]

alloc(Hase, 2048, "tutorial-x86_64.exe"+4D213)

label(Gans)

label(Ente)

label(Huhn)

label(Fuchs)

label(EnteLeben)

Hase:

 push rax

 push rcx

 push rdx

 cmp rax, EnteLeben

 je Ente

Huhn:

 mov ecx, [rax+60]

 cmp ecx, 1

 jle Fuchs

 mov [rax+60], 1

Fuchs:

 sub [rax+60], edx

 jmp Gans

Ente:

 add [rax+60], 1

 jmp Gans

Gans:

 pop rdx

 pop rcx

 pop rax

 jmp Gans

EnteLeben:

 dq 0160ABB0

Gans:

"tutorial-x86_64.exe"+4D213:

 jmp Hase

 nop

[DISABLE]

"tutorial-x86_64.exe"+4D213:

 sub [rax+60], edx

dealloc(Hase)

Habe extra jede Zeile kommentiert(Ehrlich jetzt, jede Zeile)

[ENABLE]

alloc(Hase, 2048, "tutorial-x86_64.exe"+4D213) Fügt die Bezeichnung Hase hinzu. 2048 Bytes werden reserviert für den Code des AA Scripts. Der exakte Prozessname ist tutorial-x86_64.exe"+4D213

label(Gans) Fügt die Bezeichnung Gans hinzu...

label(Ente) Ebenfalls eine Bezeichnung

label(Huhn) ....

label(Fuchs) ...

Hase: Bindet die Bezeichnung Hase in den Code ein

 cmp rax, EnteLeben prüft ob sich EnteLeben im rax Register befindet

 je Ente Wenn rax mit 0160ABB0 übereinstimmt springt es zu Ente weiter

Huhn: Bindet die Bezeichnung Huhn in den Code ein

 mov ecx, [rax+60] verschiebt das Register [rax+60] in Register ecx

 cmp ecx, 1 Überprüft ob sich im Register ecx der Wert 1 befindet

 jle Schaden       Springt zu Fuchs, wenn sich im Register ecx der Wert 1 oder niedriger befindet

 mov [rax+60], 1    Verschiebt den Wert 1 in Register [rax+60]. Dies trifft nur zu, wenn sich im Register ecx der Wert 2 oder höher befindet(Weil ansonsten direkt zu Fuchs gesprungen wird

Fuchs: Bindet die Bezeichnung Fuchs in den Code ein

 sub [rax+60], edx   Originaler Code der Schaden verursacht

 jmp Gans Hier endet der Code für den Gegner und es wird zu Gans: gesprungen. Ansonsten würde es sich mit den weiteren Code von Ente: vermischen.

Ente: Bindet die Bezeichnung Ente in den Code ein

 add [rax+60], 1    Spieler erhält pro Treffer 1 Lebenspunkt. Alles über Spieler: und unter Gegner: wird ignoriert., wegen der je Anweisung.

 jmp Gans Hier endet der Code für den Spieler und es wird zu Gans: gesprungen. Ansonsten vermischt er sich mit den Gans: Code

EnteLeben: Bindet die Bezeichnung EnteLeben in den Code ein

 dq 0160ABB0      EnteLeben hat die Adresse 0160ABB0 Erspart das ständige abtippen der Adresse, indem man einfach die Bezeichnung EnteLeben verwendet. Eignet sich auch gut für Pointer Adressen

"tutorial-x86_64.exe"+4D213:

 jmp Hase Springt zu alloc(Hase, 2048, "tutorial-x86_64.exe"+4D213) und arbeitet sich runter Zeile für Zeile

 nop Die übrigen Bytes werden durch eine leere Anweisung ersetzt

Gans: Das ist das Ende vom Script. Danach läuft das Spiel ganz normal weiter

[DISABLE] Solange das Script aktiviert ist, werden die unteren Zeilen ignoriert. Das dient nur dazu, falls man das Script deaktiviert, damit der ursprüngliche Code wieder benutzt werden kann. Ansonsten wird das Spiel abstürzen.

"tutorial-x86_64.exe"+4D213:

 sub [rax+60], edx Hier steht der Originale Code, der jetzt deaktiviert ist.

dealloc(Hase) Ist ebenfalls solange deaktiviert, bis man dass Script deaktiviert. Es gibt den ursprünglichen Speicherplatz wieder frei, der für das geschriebene Script verwendet wurde

start:  LW R3, 1000(R0)   # Lade die Anzahl N der Paare in Register R3

     ADDI R4, R0, #1004  # Setze R4 auf die Startadresse der Paare (1004)

     ADD R6, R0, R0    # Setze R6 auf 0 (Zähler für Ungleich-Paare)

loop:   BEQZ R3, ende    # Wenn R3 (Anzahl der Paare) gleich 0, springe zu ende

     LW R1, 0(R4)     # Lade erstes Element des Paares in R1

     LW R2, 4(R4)     # Lade zweites Element des Paares in R2

     ADDI R4, R4, #8   # Erhöhe R4 um 8, um auf das nächste Paar zu zeigen

     SUBI R3, R3, #1   # Verringere die Anzahl der verbleibenden Paare um 1

     SLE R5, R1, R2    # Setze R5 auf 1, wenn R1 <= R2, sonst 0

     XORI R5, R5, #1   # Invertiere R5 (1 wird zu 0, 0 wird zu 1)

     ADD R6, R6, R5    # Inkrementiere R6, wenn R1 > R2 (R5 ist 1)

     J loop        # Springe zurück zu loop

ende:   SW 0(R4), R6     # Speichere den Zähler der Ungleich-Paare in Speicher

ist das Flussdiagramm richtig was ich gemacht habe, oder fehlt noch was oder ist etwas ganz falsch?

.data
  n: .word 13
.text
.globl solution

solution:
# Call function with argument n
lw a0, n
addi sp,sp,-4
sw ra, 0(sp)
jal ra, fib3
lw ra, 0(sp)
addi sp,sp,4
# Output restult
li a7, 36
ecall
# Exit program
li a7, 10
ecall
ret

fib3:
 
  blez a0, end #Base-case a0 kleiner gleich 0 gehe ende
  addi sp, sp, -8       # Speicher auf dem Stack für a0 und ra sichern (Stackpointer verschieben)
  sw ra, 4(sp)          # Sicher ra im Stack
  sw a0, 0(sp)          # Sicher a0 im Stack
 
 
  addi t0, a0, -3       # Wert für Rekursive Rechnung (zwischenspeicherung in t0)
  addi t1, a0, -1       # Wert für Rekursive Rechnung (zwischenspeicherung in t0)
 
 
 jal ra, fib3 # Rekursion (gehe zum Rekursionsanfang)

  lw a0, 0(sp)          # lade a0 vom Stack
  add a0, t0, t1        # addiere die rekursiven werte
  lw ra, 4(sp)          # lade Rücksprungadresse
  addi sp, sp, 8        # Stackpointer verschieben (zurrücksetzen)
  ret # return fertig

end:
  ret

Warum? Irgendwo verschiebe ich den sp wohl falsch aber ich weiß nicht wo

Ich interessiere mich sehr für Hardwarenahe Programmierung, also zwischen Software und Hardware (sowie die Umsetzung von Firmware). Mit C und C++ bin ich bereits einigermaßen vertraut (bin noch am lernen).

Nun möchte ich mit Assembly anfangen (zumindest für einen Einblick, da heutzutage ja mehr auch hochsprachen gesetzt wird), aber sehe dass es verschieden Variationen gibt? NASM, Gnu Assembler, MASM/TASM...

Welchen würdet ihr mir empfehlen? Insebesondere in Richtung Firmware, allgemeine Geräte (z.B. embedded Systems), modernere Programmierung. Welcher ist am beliebtesten?

Hallo zusammen, 

ich arbeite an einem C-Projekt, welches komplexe Bitmasken-Operationen mit selbst implemntierten Speicherpools kombiniert. Ich benutze volatile Zeiger in einem Multithreading-Setup und versuche, die Performance durch Inline-Assembler und Register-Pinning zu optimieren. Wie kann ich am besten Speicherbarrieren in einer atomaren Compare-and-Swap Routine handeln, um Race Conditions in einem nicht-blockierenden Queue-Algorithmus zu vermeiden? 

Zusätzlich würde ich gerne wissen, wie sich die Verwendung von Duff's Device auf die Pipeline-Prediction und Cache-Lokalität auswirkt.

Danke im Voraus!

mov kann bezüglich quelle eine direkten Datenadresse oder ein registerer indirekte Adresse auch ein konstanter Wert sein, es müssen doch im opcodebereich bits existieren, die dafür sorgen, dass innerhalb des microprogramm, nennen wir es mov, in den abschnitt für quelloperand ist ram adresse oder konstante springen, bitte mit eigenen worten erklären und keine verweise angeben, wo ich infos erhalte,

wenn das mikroprogramm cpu befehl dekodiert, muss doch im opcode stehen ob daten nach opcode, beispiel 001101 eine konstante, eine adresse register oder ram adresse ist

#include "TM4C123.h"
.global main
main:
/*GPIOF PORT AKTIVIEREN*/
ldr r0,=0x400FE608
ldr r1,=0x20
str r1,[r0]
/*GPIO DIR*/
ldr r0,=0x40025400
ldr r1,=0x0E
str r1, [r0]
/*GPIO DEN*/
ldr r0,=0x4002551C
ldr r1,=0x1F
str r1,[r0]
/*GPIO AFSEL*/
ldr r0,=0x40025420
ldr r1,=0x00
str r1,[r0]
  
/*GPIO DATA*/
ldr r0,=0x400253FC
ldr r1,=0x00
str r1,[r0]
/*Pull Up Widerstand aktivieren*/
ldr r0,=0x40025510
ldr r1,=0x10
str r1,[r0]
Check_Input:
ldr r0,=0x400253FC
ldr r1,[r0]
lsr r2,r1,#4
cmp r2, #0
beq loop
b Check_Input
loop:
/*Rote LED einschalten*/
ldr r0,=0x400253FC
ldr r1,=0x02
str r1,[r0]
bl delay
ldr r0,=0x400253FC
ldr r1,=0x00
str r1,[r0]
bl delay
/*Grüne LED einschalten*/
ldr r0,=0x400253FC
ldr r1,=0x04
str r1,[r0]
bl delay
ldr r0,=0x400253FC
ldr r1,=0x00
str r1,[r0]
bl delay
/*Blaue LED einschalten*/
ldr r0,=0x400253FC
ldr r1,=0x08
str r1,[r0]
bl delay
ldr r0,=0x400253FC
ldr r1,=0x00
str r1,[r0]
bl delay
b loop
delay:
/*Wert setzen*/
ldr r0,=0xE000E014
ldr r1,=0x000C34FF
str r1,[r0]
/*Warten auf Timerablauf*/
ldr r0,=0xE000E010
ldr r1,=0x01
str r1,[r0]
/*Timer-durchlauf*/
Wait_loop:
ldr r0,=0xE000E018
ldr r1,[r0]
cmp r1, #0
bne Wait_loop
bx lr

Kann mir jemand erklären warum im Debug Modus der Taster berücksichtigt wird, also mit Step Into und wenn ich auf Continue drücke nicht ? Danke schonmal:)

Ich habe dieses Wort noch nie gehört. Das ist mir vorhin aber bei einem OPCode aufgetaucht. Wofür steht  cvttss2si? Und was macht das genau?

Kann mir jemand helfen diese aufgabe zu lösen, beim ersten befehl steht im inhalt jump marke drauf (C3) , das heisst doch das der IP auf die 45 und auch als inhalt interpretiert wird, was passiert dann? Wie führe ich den 2. Befehl dann aus , da es kein opcode fuer die zahl 45 gibt , Oder habe ich etwas falsch verstanden ?

Kann mir jemand erklären und hilfen wie man die untere tabelle ausfüllt und wo oder was man schauen muss um die tabelle auszufüllen?

Jetzt mal Hand aufs Herz. Wir wollen doch alle Geschwindigkeit oder nicht. Warum das also wegwerfen? Man könnte ja zumindest nutzen was schon erreicht wurde.

Ich weiß gleich kommen die folgenden Argumente:

- Es lohne sich nicht, da Hardware günstiger sei:

-> Das stimmt nicht. Milliarden Nutzer * 1500€ sind mehr als die Entwicklungskosten einee optimierung. Außerdem wäre das Wirtschaft und es heißt ja ComputerSCIENCE

- Es sei nicht nötig sich die Mühe zu machen da Computer das heute alles packen:

-> Das sah bei GTA6 jetzt nicht so aus! Und was ist mif skalierungsmöglichkeiten, Multitasking und Massendatenverarbeiting, Ernergiekosten, Überlastungen von Rechensystemen... Umweltschutz und Die Herstellung neuer Computerbauteile?

- Es liegt alles an OOP und Web:

-> Das gibts es schon ewig. Es erklärt nicht so wirklich viel davon.

- Geplante Alterung sei Notwendig da die Firmen sonst Pleite gehen:

-> Den Firmen die das tun platzt das Geld aus den Hosentaschen. Und außerdem geht das auch anders. Man kann auch alle paar Jahre eine Lizens erneuern oder es teuerer machen, aber ich denke nicht das Geld das Problem ist? Selbst wenn - Es wird immer zwischen den Themen herumgeschaukelt. Ich sehe das schon, Ich bin nicht auf den Kopf gefallen.

- Zeit zur Veröffentlichung und Marketing sei wichtiger:

-> Ich sprach nicht von dem Azubi nem Becker seine Webseite erstellt.

- Es war früher nicht schneller:

-> Doch war es erinnere dich bitte

- Die Hardware kann nicht mehr:

-> Doch kann Sie, alte Software beweißt es.

- Linux sei die Lösung

-> Schön wärs. Leider nur leichter aber nicht schneller.

- Treiber kann man nicht schreiben:

-> Wenn man sich nicht drüber unrerhällt kann man auch nichts gewinnen. Nicht versucht ist schon verloren.

Ds wird immer ständig zwischen diesen Punkten herumgereicht.

Hab ich was vergessen? Nun Realtalk mal bitte, es muss sich doch was ändern! Ihr könnt mir nicht erzählen das ihr das so wollt...

Ich kann den hate dagegen garnicht nachvollziehen. Geachwindigkeit ist doch wichtig. Und wenn man schon direkt die passende Struktur hat muss man nachher nicht alles umschreiben.

Ich nehme mal an es geht wieder nur ums Geld. Aber deswegen ist es ja noch lange nicht "dumm" oder "schlecht"?

Es heißt immer so wenn Programme geschrieben werden dass man Entwickler nicht für Optimierung bezahlt, sondern nur für das Ergebnis und schnelle Fertigstellung.

Aber ein Programm muss doch immer am Limit seiner Leistung laufen.

Hallo und mir ist es bewusst, dass ein Betriebssystem zu machen ziemlich schwer sein kann, aber ich würde sowas machen als ein Hobby.

Aber ich meine nicht Linux zu nehmen, sondern ein eigenes Betriebssystem zu machen, aber keines mit GUI, sondern einfach ein Terminal, sowie MS-DOS, C64, ZX Spectrum usw. Vielleicht simuliere ich auch eine eigene “simple” CPU oder nehme ein 8 oder 16 Bit Prozessor (wie Zilog Z80, MOS 6502 oder Motorola 68k) und simuliere es damit.

Warum ich auf diese Idee gekommen bin? Weil ich mal ein YouTube eine Person gesehen habe, der ein 16 Bit CPU gemacht hat mit „Logisim Evolution“ und schrieb sogar ein Emulator, Compiler, renderer, Circuit (Schaltkreise) und Programmiersprache. Ich will nicht alles davon machen, aber ich würde gerne mein Betriebssystem in Logisim simulieren und es auch programmieren.

Hier der GitHub Link von meiner Inspiration: https://github.com/sam-astro/Astro8-Computer

Mir ist es bewusst, dass man Assembly Kenntnisse braucht und auf jeden Prozessor, ob von Intel, AMD usw., ist die Programmiersprache auch etwas anders.

Also, wie kann ich anfangen?

Wie löse ich solche Aufgaben? Beispiel:

andi $t0, $a0, 15 zu Maschinencode in Binär und Dezimal,

Der Opcode wäre Binär 001100, also in Dezimal 12, da ich in der MIPS-Referenztabelle nachschauen kann, welchen Opcode jede Funktion hat:

Außerdem weiß ich bereits, dass der Immediate-Wert 15 ist. Aber wie lese ich auch $t0 und $a0 ab, wie komm ich darauf?

Ich habe außerdem eine Musterlösung für diese Aufgaben, kann sie mir aber selbst nicht erklären:

Besonders verstehe ich nicht ganz, wie man darauf kommen soll, was L2 und L1 bei Adresse 58 und Adresse 82 sein sollen. Danke im Voraus für jegliche Erklärung/Hilfe!