Assembler – die besten Beiträge

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:)

Gibt es so etwas wie einen „Multi-Architektur“-Assembler, der eine weitgehend einheitliche Syntax verwendet und dabei unterschiedliche Architekturen unterstützt?

Dass sich der Befehlssatz und zulässige Adressierungsarten zwischen verschiedenen Prozessoren unterscheiden, ist natürlich klar, aber solch einen Unsinn wie verschiedene Mnemonics, die im Prinzip genau dasselbe bewirken (z.B. „sec“ vs. „stc“ für „set carry“ oder „eor“ vs. „xor“ für „exklusiv-oder“ oder „pop“ vs. „pull“, um einen Wert vom Stack zu holen) könnte man doch beseitigen und jeweils eine Variante festlegen, die dann für alle Architekturen gilt (sofern dies Teil ihres Befehlssatzes ist).

Ebenso könnte man festlegen, ob die Mnemonics selbst Informationen über die Addressierungsart, die Breite der Operanden etc. enthalten (als „Suffix“) oder ob sich dies aus der jeweiligen Schreibweise der Operanden ergeben soll (und ggf. „Dummy“-Operanden verwendet werden) und dies dann ebenfalls für alle Architekturen einheitlich machen.

Gibt es so etwas schon und wenn ja, wo?

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 brauche mehr fps, es ist wirklich wichtig. Die brechen immer ein wenn ich Chunks lade in Minecraft. Die CPU Auslastung durch den Treiber ist einfach zu hoch. Ich habe sogar eine Nvidia gt710. Also kann man ordentlich fps rausholen.

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?

Gehen wir davon aus, dass wir einen Eintaktprozessor haben. Nun soll der Eintaktprozessor so erweitert werden, dass er nach der Erweiterung auch einen neuen bestimmten Befehl ebenfalls ausführen kann. Dafür muss ich verstehen, wie all diese Komponenten zusammenhängen, um genau zu wissen, wo ich meinen neuen "Baustein" für den neuen Befehl hinzufügen kann.

Zum Beispiel kann dieser Eintaktprozessor die "add"-Operation ausführen, da er über Register-Dateien, einen Addierer, eine ALU, einen Multiplexer usw. verfügt. Da der Datenpfad für die "add"-Operation, die Operanden von den Registern zum Addierer leitet, das Ergebnis durch die ALU berechnet, und schließlich das Ergebnis in das Zielregister zurückführt...

Nun habe ich eine Beispiel-Aufgabe mit einer Lösung, bin mir aber unsicher, wie man zu dieser Lösung gelangt. Könnte mir jemand das erklären?

In dieser Aufgabe sollen Sie den dargestellten MIPS-Eintaktprozessor erweitern, sodass der neue Befehl Read Word Until Zero (rwuz) unterstützt wird. Der abgebildete Prozessor unterscheidet sich leicht von dem Ihnen bekannten Eintaktprozessor.

rwuz unterscheidet sich von anderen MIPS-Befehlen dadurch, dass er von dem Prozessor automatisch mehrfach ausgeführt werden soll, solange das gelesene Datenwort nicht null war.

rwuz soll ein Befehl im I-Format sein.

Für rwuz soll der Opcode 0x11 verwendet werden.

Der Direktoperand (immediate) soll zu dem rs-Register hinzuaddiert werden. Das Ergebnis dieser Operation soll im rt-Register gespeichert werden.

Das rt-Register soll gleichzeitig als Adresse für einen Lesezugriff auf den Datenspeicher verwendet werden.

Solange der gelesene Wert aus dem Speicher nicht null ist, soll der selbe rwuz-Befehl im nächsten Taktzyklus erneut ausgeführt werden (PC bleibt gleich). Falls der gelesene Datenwert null ist, soll die nächste Instruktion ausgeführt werden (PC um 4 erhöhen).

Das aus dem Speicher gelesene Datenwort soll nicht in einem Register abgelegt werden.

Tipp: Das Signal rZero zeigt an, ob das aus dem Speicher gelesene Datenwort null ist

Selbst wenn niemand in der Lage ist, mir dies genau zu erklären, kann mir jemand Quellen, Videos oder Bücher empfehlen, damit ich ein besseres Verständnis dafür entwickeln kann?

Im Unterricht wurde uns über die MIPS-Architektur gelehrt. Also die MIPS-Befehle sind ja von fester Länge. Die Standard-Befehlsgröße ist 32 Bits bsw. 4 Bytes. Dies gilt für R-type, I-type und J-type Befehle. Also würde ja jeder Befehlsausführung den Program Counter (PC) um 4 erhöhen, bis auf die Ausnahmen jump / branch. Wo liegt also der Fehler in dieser Aussage?

Hey, also ich habe einen 32Bit Prozessor mit folgender Register und Speicherbelegung:

Nun soll ich erklären was in register t2 steht. Ich habe es so interpretiert, dass der Inhalt von s1 als Speicheradresse interpretiert wird. lhu läd einen 16bit wert von Adresse s1 + 0 in t2. Also läd es doch von der Speicheradresse 0x119 2 Byte. Aber es gibt doch nicht diese Speicherstelle?

Das Ergebnis ist : 0xa75a (in Sepicherstelle 0x118 , wahrscheinlich als little endian angegeben)

Gruß

Hey,

Ich will so langsam auch reverse Engineering lernen habe auch gut Kenntnisse mit Assembly. Ich weiß auch das man sowas macht damit mit z.b Exploits oder 0day Malware erstellen kann aber wozu auf Games anwenden und bringt es am Ende überhaupt etwas?

section .text
global main

main:
  mov esi, 10           ; ESI holds current number
  mov eax, 0           ; EAX holds sum of numbers
  push 10             ; Line feed for end of line (Stack is first in, last out -> Line feed will be last char)
  mov edi, 10           ; Divisor of 10 for seperating digits of number (used in divisionLoop)



; Sum numbers 1 through 10
sumLoop:
  add eax, esi          ; Add number to sum
  dec esi             ; Next number
  jnz sumLoop           ; Loop until 0



; Seperate eax into its digits, by dividing by 10 multiple times,
; where in each division the remainder will be a single digit 
; and the quotient will be the remaining digits used as dividend in next loop run
divisionLoop:
  mov edx, 0           ; Make sure edx is empty, as it is used as upper half of dividend
  div edi             ; Divide eax by edi (= 10) => quotient is in eax (= Rest of digits for next loop), remainder in edx (= Single digit)
  add edx, 48           ; Make edx (digit) a char representing its value by adding '0' to it
  push edx            ; Push char to stack for usage in print later

  cmp eax, 0           ; Loop until quotient is 0 (=> no more digits left)
  jne divisionLoop



; Print digits from Stack one by one
printLoop:
  mov eax, 4
  mov ebx, 1
  mov ecx, esp          ; Print top of stack (esp always points to top of stack)
  mov edx, 1           ; Length of 1 byte (= 1 char)
  int 80h

  pop esi             ; Remove top of stack
  cmp esi, 10           ; Loop until Line feed is reached
  jne printLoop


exit:
  mov eax, 1
  mov ebx, 0           ; Exit code 0
  int 80h

Hallo,

hier steht ein Programm in Assembler, dass die Zahlen von 1 bis 10 addiert.

Die 55 durch 10 teilt und die Reste der Division dann in einem Stack speichert.

push....

Am Ende wird alles über den Standardkanal ausgegeben auf der Konsole.

Wenn ich 55 / 10 teile ergibt das Quotient 5 steht in Register eax und der Rest hier auch 5 in edx Register. Bevor ich jetzt den Rest auf den Stack lege wird die Zahl mit 48 addiert. ergbit 53 ist das char Zeichen 5 im ASCII Code.

Heißt das jetzt, dass die Ergebnisse bei einer ganzzahligen Division im Assembler-Code immer in ASCII-Zeichen gespeichert sind?

Wie man in der Grafik sieht hat der Prozessor 8 Haupt-Register mit je 32-Bit, wo jeweils eine Zahl drinnen steht. Z. B. EAX, EBX...

Jetzt gibt es ja noch eine andere Möglichkeit, dass man z. B. diese AX, BX, ...Register mit 16-Bit nutzt/hat.

=> Ist es nun vom Prozessor abhängig, den ich nutze, ob ich diese EAX, EBX Register oder diese AX, BX Register habe?

=> Oder kann ich dies selber festlegen/programmieren/einstellen...?

Dritte Möglichkeit ist die Aufteilung der 16-Bit Register AX, BX in AH, AL oder BH, BL...

=> D. h. ich habe jetzt hier 2 Register zu je 8-Bit. 8-Bit in AH und 8-Bit in AL

=> Kann man jetzt hier auch wieder nur "eine" Zahl drinnen speichern oder jetzt "zwei"?

Increments 32-Bit register

=> Was soll das bedeuten, das man ein 32-bit register hier EBX um 1 erhöht?

32-bit sind 4 Byte. D. h. dort stehen vier Zeichen oder vier Zahlen, jede im Bereich 2^7 ist 0 bis 255.

inc [count]

=> Hier erhöhe ich den Inhalt/Wert der Variablen count um 1. In der Variablen count ist z. B. die Zahl 5, braucht 1-Byte als Hexa 0x5 abgespeichert. Mittels inc erhöht sich der Wert der Variablen um 1 also hat sie nun den Wert 0x6 => ist 6.

Richtig?

Ich nutze hier wieder mov eax, 4 sowie mov ebx, 1

dann berechne ich die Summe der Zahlen von 1 bis 10 = 55

Nun möchte ich dieses Ergebnis am Ende auf der Konsole ausgeben:

Mit mov eax, 1 sowie mov ebx, 0 int 80h

beende ich den Code

Warum wird jetzt das Ergebnis nicht auf der Konsole der VM ausgegeben?

Hallo, ich habe gelesen, dass Assembler Befehle beim Testen von Compilern eine Rolle spielen. Wie kann ich mir das vorstellen?