Wie der Rechner rechnet
Rechnen mit Binärzahlen
Die Addition
Beginnen wir einfach damit, zwei Binärzahlen zu addieren.
%00010000 <- 16
%00011010 <- 26
--------- >> Addition
%00101010 => 42
Wir addieren also so, wie wir es in der Schule gelernt haben. Nur dass wir hier schon ab %10 (bzw. 2 dezimal) einen Übertrag für die nächste Stelle erhalten.
Der Übertrag, den wir schon vom Dezimal-System aus der Schule kennen:
17
+18
---
5 >> 7+8 = 15, also bleibt 5 und ein Übertrag von 1
35 >> 1+1+1(vom Übertrag) = 3
Im Binärsystem funktioniert das genau so:
%0101
+%0111
------
0 >> %1+%1 = %10, also bleibt %0 und ein Übertrag von %1
00 >> %1+%0+%1(vom Übertrag) = %10, wieder %0 + Übertrag %1
100 >> %1+%1+%1(vom Übertrag) = %11, also %1 + Übertrag %1
1100 >> %0+%0+%1(vom Übertrag) = %1, also %1 und KEIN Übertag
Kurzer Hardware-Ausflug: Passt das Ergebnis nicht mehr in 8-Bit, so wird im Statusregister des Prozessors das Carry-Flag (Übertrag) gesetzt (= 1), passt das Ergebnis in 8-Bit wird das Carry-Flag gelöscht (= 0). Das Carry-Flag dient also so zu sagen aushilfsweise als neuntes Bit. Mit dem Carry-Flag können wir z. B. 16-Bit (und höher) Additionen realisieren, die unsere 8-Bit CPU ja nicht beherrscht.
Die Subtraktion
Der Prozessor ist übrigens sehr dumm, dass er nicht mal „normal“ subtrahieren kann, er addiert stattdessen immer eine negative Zahl.
Der Prozessor addiert immer eine negative Zahl, um zu subtrahieren. Dazu wird das Zweierkomplement der subtrahierten Zahl gebildet, indem jeder Bitwert umgekehrt und 1 addiert wird.
Da unsere 8-Bit nur 256 mögliche Zustände abbilden können, müssen wir uns überlegen, wie wir negative Zahlen darstellen können. Hierfür wird das höchstwertige Bit (das sogenannte Vorzeichenbit) als Sign-Bit genutzt. Ist dieses Bit auf 0 gesetzt, bedeutet das eine positive Zahl, ist es auf 1 gesetzt, handelt es sich um eine negative Zahl.
Negatives Vorzeichen
Um negative Zahlen darzustellen, verwendet der Prozessor das höchste Bit (Bit-7), auch bekannt als Sign-Bit, um zwischen positiven und negativen Zahlen zu unterscheiden. Das Sign-Bit gibt an, ob es sich um eine positive (0) oder negative (1) Zahl handelt. Jedoch müssen wir beachten, dass das Sign-Bit auch für positive Zahlen, die größer als 127 sind, genutzt wird, weshalb die Interpretation davon abhängt, wie wir die Zahlen betrachten wollen - vorzeichenbehaftet oder vorzeichenlos.
Um das Vorzeichen zu erkennen, gibt es im Prozessor ein spezielles Flag, das Negativ-Flag. Dieses Flag wird immer dann gesetzt (= 1), wenn das höchste Bit gesetzt ist und somit eine negative Zahl vorliegt. Andernfalls wird das Flag gelöscht (= 0). Das Negativ-Flag entspricht also dem höchsten Bit der Zahl, mit der wir gerade arbeiten.
Durch die Verwendung des Sign-Bits können wir mit unseren 8-Bit Zahlen einen vorzeichenbehafteten Wertebereich von -128 bis +127 abbilden.
In der folgenden Tabelle könnt ihr sehen, wie sich die unterschiedliche Interpretation des höchsten Bits auf die Darstellung der Zahlen auswirkt.
Binär Hex ohne Vorz. mit Vorzeichen
------------------------------------------
%00000000 $00 0 0
%00000001 $01 1 1
%00000010 $02 2 2
%00000011 $03 3 3
...
%01111100 $7C 124 124
%01111101 $7D 125 125
%01111110 $7E 126 126
%01111111 $7F 127 127
%10000000 $80 128 -128
%10000001 $81 129 -127
%10000010 $82 130 -126
%10000011 $83 131 -125
...
%11111100 $FC 252 -4
%11111101 $FD 253 -3
%11111110 $FE 254 -2
%11111111 $FF 255 -1
Die Vorzeichenumkehr (Zweierkomplement)
Wie kann man nun die Vorzeichenumkehr durchführen?
Als Beispiel dient mal wieder die gute alte 42 / $2A / % 0010 1010. Versuchen wir nun, das Vorzeichen umzukehren, um auf -42 zu kommen.
Da wir schon wissen, dass das höchste Bit zur Kennzeichnung einer negativen Zahl verwendet wird, könnte man nun meinen, dass es reicht dieses einfach zu setzen.
%00101010 <- 42
%10101010 <- ist das -42???
--------- >> addieren wir zur Gegenprobe beide Zahlen
%11010100 => -44, eigentlich sollte (42 + -42) 0 ergeben!
Wie wir an der Gegenprüfung, durch Addition der beiden Zahlen sehen, stimmt das nicht, statt 0 kommt -44 raus. Es muss also einen anderen Weg geben.
Die CPU bildet als erstes das sog.
Einerkomplement
Wie bildet man das Einerkomplement?
Das Einerkomplement wird gebildet, wenn man alle Ziffern negiert. Aus der Ziffer 0 wird 1, aus der 1 wird 0. Die Darstellung der Dezimalzahl -8 im Einerkomplement wäre 1111 0111., d. h. wir kehren die Nullen und Einsen einfach um. Dabei wird wieder, wie eben, automatisch das höchste Bit gesetzt, wenn wir von plus nach minus wechseln, bzw. im umgekehrten Fall gelöscht.
%00101010 <- 42
%11010101 <- Einerkomplement
--------- >> Addition
%11111111 => -1, schon dicht dran, aber immer noch nicht 0
Endlich! Wie erhofft, kommt bei unserer Gegenprüfung 0 heraus. Den Übertrag können wir hier bei unserer 8-Bit-Addition ignorieren. Wir müssen uns allerdings darum kümmern, wenn wir beispielsweise 16-Bit-Operationen implementieren möchten.
Da ich behauptet habe, dass die CPU nur addieren kann, muss das Vorzeichen auch bei einer negativen Zahl korrekt umgewandelt werden, indem das Zweierkomplement gebildet wird. Wenn wir beispielsweise 42 - (-42) berechnen möchten, kehrt der Prozessor (wie oben erwähnt) das Vorzeichen der zweiten Zahl um und addiert sie zur ersten. Es wird also 42 + 42 gerechnet. Lassen Sie uns nun überprüfen, ob die Umkehr des Vorzeichens auch bei einer negativen Zahl funktioniert.
// %11010110 <- wir beginnen mit -42
NOT %11010110
----------
%00101001 <- Einerkomplement
+%00000001 <- +%1 für Zweierkomplement
----------
%00101010 => und wir erhalten wieder 42
Overflow
Da haben wir es also: Wir haben nun das Addieren und Subtrahieren gemeistert, kennen uns mit dem Carry- und Negativ-Flag aus. Lassen Sie uns unser neues Wissen doch gleich noch einmal anwenden und eine Aufgabe lösen. Was ist, wenn wir zwei Zahlen addieren möchten, die auch negativ sein können? Doch wie es der Zufall so will, haben wir jetzt zwei positive Zahlen, die wir addieren möchten...
%01000011 ( 67)
+%01000111 ( 71)
-----------------
%10001010 (-118) <- ???
Ups, was ist hier denn passiert?
Bei der Addition wurde das höchste Bit (Bit-7) gesetzt. Das bedeutet, dass das Vorzeichenbit unbeabsichtigt auf 1 gesetzt wurde und somit das Ergebnis als negative Zahl interpretiert wird. Hier zeigt sich erneut, dass es von uns abhängt, wie wir die Zahlen interpretieren möchten. Wenn wir von vorzeichenbehafteten Zahlen ausgehen, ist das Ergebnis offensichtlich falsch. Denn in diesem Fall liegt der Wertebereich zwischen -128 und +127. Unser Ergebnis liegt jedoch außerhalb dieses Bereichs und es kommt zu einem Overflow (Überlauf). Wenn wir jedoch das Vorzeichen ignorieren und die Zahl als 138 interpretieren, wäre das Ergebnis korrekt.
Hardware-Alarm: Um den Overflow zu erkennen, gibt es wieder ein Flag im Statusregister. Es ist das
OVerflow-Flag. Nun wird es aber nicht einfach immer gesetzt, wenn wir einen Übertrag von Bit-6 nach 7 haben, sondern nur unter den folgenden Bedingungen:
⍟ 1.Es findet nur ein Übertrag von Bit-6 nach 7 statt, aber kein gleichzeitiger Übertrag ins Carry-Flag. Das trifft auf unser Beispiel von eben mit 67+71 zu!
⍟ 2.Es findet kein Übertrag von Bit-6 nach 7 statt, aber einer ins Carry-Flag.Dies ist z. B. bei der Addition von zwei negativen Zahlen möglich:
%10000000 (-128)
+ %11100000 ( -32)
--------------------
%(1)01100000 ( +96)
Hier wurde „versehentlich“ Bit-7 gelöscht und wir erhalten plötzlich eine positive Zahl. Es hat zwar einen Übertrag ins Carry-Flag gegeben, aber von Bit-6 nach 7 gab es keinen, daher wird das Overflow-Flag gesetzt.
Beim Programmieren ist es wichtig, sich bewusst zu machen, welche Werte für eine bestimmte Rechnung benötigt werden und welche Werte zurückgegeben werden. Wenn beispielsweise die Punktzahl eines Spielers erhöht wird, wird die Punktzahl nie negativ sein (höchstens werden Strafpunkte abgezogen, aber die Punktzahl wird nie unter Null fallen). Wenn jedoch eine Wirtschaftssimulation entwickelt wird, bei der das Konto zeitweise negativ sein kann, muss man sich zwangsläufig um die negativen Zahlen kümmern. Ein weiteres Problem besteht darin, dass ein maximaler Wert von 255 für beide Zwecke zu klein ist. Einige dieser Probleme können durch die Verwendung von 16 oder 32 Bit Zahlen umgangen werden. Da wir jedoch einen 8-Bit-Prozessor haben, müssen wir uns selbst um die Probleme kümmern, ohne dabei die Geschwindigkeit unseres Programms zu vernachlässigen.
Multiplizieren und dividieren
Wie bereits erwähnt, unterstützt der 6510-Prozessor keine Multiplikation oder Division. Wenn Ihr Code jedoch solche Rechenoperationen erfordert, müsst Ihr sie selbst implementieren oder auf vorhandene Routinen zurückgreifen (z. B. aus dem BASIC). Die Umsetzung in Assembler erfordert fortgeschrittene Kenntnisse.
Zusätzlich sollte beachtet werden, dass der Prozessor auch keine Kommazahlen verarbeiten kann. Hier gilt dasselbe Prinzip: Wenn Ihr Code Kommazahlen erfordert, müsst Ihr sie selbst implementieren oder auf vorhandene Lösungen zurückgreifen.
Es ist wichtig zu beachten, dass spätere CPUs mehr Möglichkeiten beim Umgang mit Zahlen bieten, einschließlich mathematischer Co-Prozessoren und der Integration dieser in die CPU.
Mit diesen grundlegenden Kenntnissen solltet Ihr nun bereit sein, um mit der Programmierung auf dem 6510-Prozessor zu beginnen.