Assembler programmieren in der Essembly
Du wolltest schon immer wissen, wie Programme auf der CPU eines Computers ausgeführt werden? Dann ist unser Assembler-Workshop genau das Richtige für dich. Anhand des Open-Source-Instruktionssatzes RISC-V schauen wir uns an, wie eine CPU funktioniert und wie du selbst dafür Programme schreiben kannst. Alles, was du mitbringen musst, ist ein Laptop, um den webbasierten CPU-Simulator zu bedienen.
Anmeldung
Bitte melde dich mit einer Email an anmeldung@essembly.de an.
Kosten
Die Teilnahme ist kostenlos.
Spenden ermöglichen uns auch in Zukunft unsere Workshops kostenlos anzubieten.
Wo kann ich mich über zukünftige Veranstaltungen informieren lassen?
Auf unserer Kontakt-Seite findest du unseren Newsletter. Außerdem veröffentlichen wir alle Veranstaltungen in unserem Matrix-Chat, auf Mastodon, Instagram oder X (twitter).
Wann?
Am 02. Mai 2026 von 13:00 bis 16:00 Uhr
Bitte melde dich per Mail an.
Wo?
Essembly - Der Technikraum in Esslingen
Milchstraße 17
73728 Esslingen
Workshop Unterlagen
Arithmetik
Subtraction zweier Zahlen
addi x1, x0, 23
addi x2, x0, 42
sub x3, x1, x2
Kombination von drei Zahlen
addi x1, x0, 23
addi x2, x0, 42
addi x3, x0, 89
add x4, x1, x2
sub x5, x3, x4
Tauschen von zwei Registern mit XOR
addi x1, x0, 23
addi x2, x0, 42
xor x1, x1, x2
xor x2, x1, x2
xor x1, x1, x2
x1 0101
x2 1111
xor --------
x1 1010
x1 1010
x2 1111
xor --------
x2 0101
x1 1010
x2 0101
xor --------
x1 1111
=>
x1 1111
x2 0101
Kontrollfluss
Labels
addi x1, x0, 23
addi x2, x0, 42
beq x1, x2, equal
not_equal:
addi x4, x0, 11
jal x0, end
equal:
addi x4, x0, 22
end:
addi x0, x0, 0
Multiplikation
addi x1, x0, 23 # x1 = 23
addi x2, x0, 42 # x2 = 42
addi x3, x0, 0 # result = 0
addi x4, x0, 0 # counter = 0
loop:
beq x4, x2, done # wenn counter == x2 → fertig
add x3, x3, x1 # result += x1
addi x4, x4, 1 # counter++
jal x0, loop # jump
done:
addi x0, x0, 0
Fibonacci
addi x1, x0, 4 # n = 4
addi x2, x0, 0 # a = 0
addi x3, x0, 1 # b = 1
beq x1, x0, done # if n == 0 → return 0
addi x4, x0, 1 # i = 1
loop:
beq x4, x1, done # if i == n → fertig
add x5, x2, x3 # temp = a + b
add x2, x3, x0 # a = b
add x3, x5, x0 # b = temp
addi x4, x4, 1 # i++
jal x0, loop
done:
# Ergebnis in x3 (für n >= 1)
# optional in x2 kopieren:
add x2, x3, x0
Speicher
Load
.data
arr: .word 0x01, 0x02
.text
addi x1, x0, 0x4
slli x1, x1, 12
lw x2, 0(x1)
addi x1, x1, 4
lw x2, 0(x1)
Store
.data
arr: .word 0x01, 0x02
.text
addi x1, x0, 0x4
slli x1, x1, 12
lw x2, 0(x1)
addi x1, x1, 4
lw x2, 0(x1)
sw x2, 0(x1)
Array aus dem Speicher summieren und zurückschreiben
.data
arr: .word 0x01, 0x02, 0x03, 0x04, 0x05, 0x06
.text
addi x1, x0, 6 # Länge (counter)
addi x2, x0, 0 # Summe
# Basisadresse laden (0x4000 wie im Beispiel)
lui x3, 0x4 # x3 = &arr
loop:
beq x1, x0, done # wenn counter == 0 → fertig
lw x4, 0(x3) # lade aktuelles Element
add x2, x2, x4 # summe += element
addi x3, x3, 4 # pointer auf nächstes Element
addi x1, x1, -1 # counter--
jal x0, loop
done:
# x3 zeigt jetzt direkt hinter das Array
sw x2, 0(x3) # Summe ans Ende schreiben
Maximum im Array finden und zurückschreiben
.data
arr: .word 0x01, 0x02, 0x03, 0x04, 0x05, 0x06
.text
addi x1, x0, 6 # Array-Länge
# Basisadresse laden
lui x3, 0x4 # x3 = &arr
# erstes Element als aktuelles Maximum laden
lw x2, 0(x3) # x2 = max
addi x3, x3, 4 # pointer auf zweites Element
addi x1, x1, -1 # ein Element wurde schon verarbeitet
loop:
beq x1, x0, done # wenn alle Elemente verarbeitet → fertig
lw x4, 0(x3) # aktuelles Element laden
blt x4, x2, skip # wenn x4 < max, nicht aktualisieren
add x2, x4, x0 # max = x4
skip:
addi x3, x3, 4 # pointer auf nächstes Element
addi x1, x1, -1 # counter--
jal x0, loop
done:
# x3 zeigt jetzt hinter das Array
sw x2, 0(x3) # Maximum hinter das Array schreiben
Subroutine
.data
arr: .word 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 # 0x4000
.text
lui sp, 0x8
addi t0, x0, 3 # a
addi t1, x0, 2 # b
# set args
addi a0, t0, 0
addi a1, t1, 0
# save to stack
sw t0, 0(sp)
addi sp, sp, -4
sw t1, 0(sp)
jal ra, mul
after_mul:
# pop from stack
lw t0, 0(sp)
addi sp, sp, 4
lw t1, 0(sp)
addi t2, a0, 0
addi x0, x0, 0
mul:
add t0, x0, a0 # a
add t1, x0, a1 # b
addi t2, x0, 0 # a*b
addi t3, t0, 0 # counter = a
mul_loop:
beq t3, x0, mul_end
add t2, t2, t1
addi t3, t3, -1
jal x0, mul_loop
mul_end:
addi a0, t2, 0
jalr x0, ra, 0