Bezogen auf diesen Thread habe ich mich jetzt doch entschieden, Multiplikation, Division und Modulo in Hardware zu implementieren.
Wie Multiplikation funktioniert ist mir klar und ich weiß auch schon genau, wie ich das machen werde.
Mit der Division bin ich aber leicht überfordert. Ich habe einige Erklärungen zu iterativen Algorithmen gefunden, aber ich brauche ein Verfahren, das immer "gleich lange dauert", also ich lege die Spannungen an den Eingängen an und habe sofort (natürlich mit einer kleinen Verzögerung) das Ergebnis an den Ausgängen.


Und ich habe ein weiteres Problem:
Bei der Multiplikation C = A * B sind A und B 8-Bit Werte und das Ergebnis C ein 16-Bit Wert. Das macht Sinn.
Aber wie sieht es bei der Division C = A / B aus? Da C nie größer A sein kann (weil B nicht kleiner 1 sein kann), würde es Sinn machen, wenn A ein 16-Bit Wert ist und B und C ein 8-Bit Wert, sodass man die Multiplikation vom Prinzip her genau umdrehen kann. Aber da man auch durch 1 dividieren kann, kann es Sinn machen, dass C auch ein 16-Bit Wert ist.

Wie müsste eine Schaltung aussehen? Am besten wäre es, wenn diese Schaltung mit einer Steuerleitung zwischen Division und Modulo umschalten kann. Wenn das nicht direkt geht, wäre es auch möglich, das Ergebnis der Division von A zu subtrahieren, aber das möchte ich vermeiden, wenn es anders geht.

@Artentus
Jeder Befehl hat eine feste Länge in Ticks. Zum Beispiel dauert das Kopieren von einem Register in ein anderes 4 Ticks (2 zum Lesen des OpCodes, 2 zum Kopieren des Wertes und zum Inkrementieren des ProgramCounters):

Dass ein Befehl unterschiedlich lange dauern kann ist nicht vorgesehen.

Ich hab keine Ahnung von Elektronik

Ein Funktionsprinzip würde mir schon reichen.

Also die binäre Division hab ich jetzt verstanden. Ich habe mich dazu entschieden, dass bei C = A / B A und C 16-Bit Zahlen sind und B eine 8-Bit Zahl ist. Dadurch kann es keinen Überlauf geben.
Das bedeutet, dass bei der Division 16 Schritte benötigt werden und ich bin draufgekommen, dass man diese 16 Schritte immer gleich machen kann.
Bei jedem Schritt wird das Zwischenergebnis vom vorigen Schritt genommen, rechts das nächste Bit aus A dran gehängt und das dann wird B davon subtrahiert. Ist das Ergebnis negativ (der Subtrahierer schaltet den Borrow-Ausgang auf logisch 1), dann ist das entsprechende Bit von C 0 und das nächste Zwischenergebnis ist das vorherige Zwischenergebnis mit dem drangehängten Bit. Ansonsten ist das Bit von C 1 und das nächste Zwischenergebnis ist das Ergebnis der Subtraktion.
Also Pseudocode-mäßig so:


Einen solchen Schritt in Hardware zu basteln ist nicht allzuschwierig, aber ich will versuchen, Bauteile zu sparen. Das heißt, für jeden Schritt einen ganzen 16-Bit Subtrahierer zu verwenden wäre übertrieben.
Ich bin mal alle möglichen Divisionen durchgegangen und habe die Zwischenergebnisse gespeichert. Das längste Zwischenergebnis ist 9 Bits lang. Kann das jemand bestätigen?
Der Code oben zeigt genau dieses Beispiel, also 35298 / 156 = 226 + 42 Rest.
Diese Division sieht so aus:


Ich bin jetzt gerade am Überlegen. Es müsste möglich sein, das Zwischenergebnis (welches nach dem letzten Schritt automatisch der Rest ist) zwischenzuspeichern und immer "häppchenweise" 4 Schritte zu machen. Dadurch würde man nur 4 Subtrahierer benötigen, dafür aber mehr Zeit, was aber OK ist.

OK, ich denke ich hab die Lösung.
Ich bin auch drauf gekommen, dass Multiplikation nach einem ähnlichen Prinzip in Zwischenschritte aufgeteilt werden kann, deshalb hab ich das gleich mit eingebaut. Das sieht vom Konzept her so aus:

Die grünen Leitungen sind Datenleitungen, die orangen sind Steuerleitungen. Also wenn beispielsweise bei Temp die W-Steuerleitung(W steht für Write) und bei Rest/ProduktH die R-Steuerleitung (R steht für Read) aktiv ist, dann wird der Wert von Rest/ProduktH nach Temp kopiert. Ist die R-Steuerleitung stattdessen nicht aktiv, wird 0 ins Temp Register geschrieben.
Die Addierer und Subtrahierer sehen so aus:

Also es werden immer 2 Bits pro Durchgang berechnet.
Da die Multiplikation zwei 8-Bit Zahlen zu einer 16-Bit Zahl verknüpft und das höherwertige Byte das letzte Zwischenergebnis ist, wird beim Multiplizieren nur eine Hälfte des Quotient/ProduktL-Registers gefüllt. Die andere hälfte bleibt unverändert. Das ist zwar nicht ganz so schön, aber einfacher zu implementieren. Und da man das Ergebnis sowieso nur Byte-weise angreifen kann, muss man sowieso zwei mal lesen.