Overflow-und Carry-flags auf Z80

Habe ich so Runde um die Umsetzung der ADD A,r Satz von opcodes, die auf meinem Z80 Kern. Ich hatte ein wenig Verwirrung über das carry-und overflow-flags, die ich glaube, ich habe genagelt, aber ich wollte es der community, um zu überprüfen, dass ich im Recht bin.

Grundsätzlich von dem, was ich sehen kann, ist die ALU in der Z80 kümmert sich nicht darum, signed/unsigned-Operationen, es fügt nur bits. Dies bedeutet, dass, wenn zwei 8-bit-Werte addiert und zu einem 9-bit-Wert als Ergebnis Ihrer addition das carry-flag gesetzt wird. Dieser Zusatz enthält zwei negative zweier-Komplement-zahlen von beispielsweise -20 (11101100) und -40 (11011000), denn obwohl das Ergebnis -60 (11000100), das Ergebnis ist eigentlich ein 9-bit-Wert 1 1100 0100. Diese sicherlich bedeutet, wenn das hinzufügen zwei negative Zweierkomplement Werte, das carry-flag wird immer gesetzt, auch wenn es keine überlauf - habe ich Recht?

Zweitens, habe ich beschlossen, dass zur Erkennung von überlauf in dieser Anleitung, würde ich XOR bit 7 der beiden Operanden, und wenn das Ergebnis war 10000000, dann ist es auf jeden Fall keine überlauf - wenn das Ergebnis dies ist 00000000 dann könnte es ein überlauf, da die Anzeichen sind die gleichen, und daher würde ich XOR bit 7 des Ergebnisses der addition mit bit 7 von entweder operand ist, und wenn das Ergebnis ist 10000000 dann ein überlauf aufgetreten ist und ich die P/V overflow-flag. Bin ich hier richtig auch?

Sorry für so eine verwickelte Frage, ich bin mir ziemlich sicher, dass ich Recht habe, aber muss ich wissen, bevor ich auf unzählige weitere Anweisungen basierend auf dieser Logik. Vielen Dank.

InformationsquelleAutor PhilPotter1987 | 2011-11-07

Die bits des Ergebnisses sind, die aus der abgeschnitten Summe der vorzeichenlosen Ganzzahlen. Der add-Befehl kümmert sich nicht um die hier Unterschreiben, noch macht Sie sich über Ihre eigene interpretation der Integer als signed oder unsigned. Es fügt nur wie, wenn die zahlen ohne Vorzeichen.

Das carry-flag (oder borgen bei der Subtraktion) ist, dass nicht-existent 9. bit aus der addition der 8-bit unsigned Integer. Effektiv, dieses flag signalisiert einen überlauf/Unterlauf bei add/sub unsigned Integer. Wieder, fügen Sie kümmert sich nicht um die Zeichen, die hier überhaupt, es fügt nur wie, wenn die zahlen ohne Vorzeichen.

Hinzufügen von zwei negativen 2-Komplement-zahlen wird das Ergebnis in die Festsetzung des carry-flag auf 1, richtig.

Das overflow-flag zeigt an, ob oder nicht es wurde ein überlauf/Unterlauf bei add/sub-Ganzzahlen mit Vorzeichen. Um die überlauf-flag die Anleitung behandelt die Zahl als signed (genau wie es behandelt diese als unsigned für das carry-flag und der 8 bit des Ergebnisses).

Die Idee, die hinter der Einstellung der overflow-flag ist einfach. Angenommen, Sie melden Sie-erweitern Sie Ihre 8-bit-Ganzzahlen mit Vorzeichen zu 9 bits, das wird, kopieren Sie einfach das 7. bit in eine extra, 8. bit. Ein überlauf/Unterlauf tritt auf, wenn die 9-bit-Summe/Differenz dieser 9-bit-Ganzzahlen mit Vorzeichen hat unterschiedliche Werte in den bits 7 und 8, was bedeutet, dass die addition/Subtraktion verloren hat, das Ergebnis ist Zeichen im 7-bit und verwendet es für das Ergebnis der Größe ist, oder, in anderen Worten, die 8 bits können nicht genügend Platz für das Vorzeichen-bit und einem so großen Ausmaß.

Nun, bit 7 des Ergebnisses kann sich von der imaginären Zeichen bit 8 wenn und nur wenn das carry in bit 7 und die tragen in 8 bit (=carry out bit 7) unterschiedlich sind. Das ist, weil wir beginnen mit dem Summanden mit bit-7=bit-8 und nur unterschiedliche carry-ins, Sie können Sie beeinflussen in der Folge unterschiedliche Wege.

Also overflow-flag = carry-out-flag XOR von bit 6 ins bit 7.

Beide, meine und Ihre Wege zur Berechnung der überlauf-flag korrekt sind. In der Tat, beide sind beschrieben in der Z80-CPU Benutzerhandbuch im Abschnitt "Z80-Status-Anzeige-Flags".

Hier ist, wie können Sie emulieren die meisten ADC-Anweisung in C, wo Sie keinen direkten Zugriff auf CPU-flags und kann nicht nehmen Sie vollen Vorteil der Emulation der CPU ' s ADC Befehl:

#include <stdio.h>
#include <limits.h>

#if CHAR_BIT != 8
#error char expected to have exactly 8 bits.
#endif

typedef unsigned char uint8;
typedef signed char int8;

#define FLAGS_CY_SHIFT 0
#define FLAGS_OV_SHIFT 1
#define FLAGS_CY_MASK  (1 << FLAGS_CY_SHIFT)
#define FLAGS_OV_MASK  (1 << FLAGS_OV_SHIFT)

void Adc(uint8* acc, uint8 b, uint8* flags)
{
  uint8 a = *acc;
  uint8 carryIns;
  uint8 carryOut;

  //Calculate the carry-out depending on the carry-in and addends.
  //
  //carry-in = 0: carry-out = 1 IFF (a + b > 0xFF) or,
  //  equivalently, but avoiding overflow in C: (a > 0xFF - b).
  //
  //carry-in = 1: carry-out = 1 IFF (a + b + 1 > 0xFF) or,
  //  equivalently, (a + b >= 0xFF) or,
  //  equivalently, but avoiding overflow in C: (a >= 0xFF - b).
  //
  //Also calculate the sum bits.
  if (*flags & FLAGS_CY_MASK)
  {
    carryOut = (a >= 0xFF - b);
    *acc = a + b + 1;
  }
  else
  {
    carryOut = (a > 0xFF - b);
    *acc = a + b;
  }

#if 0
  //Calculate the overflow by sign comparison.
  carryIns = ((a ^ b) ^ 0x80) & 0x80;
  if (carryIns) //if addend signs are different
  {
    //overflow if the sum sign differs from the sign of either of addends
    carryIns = ((*acc ^ a) & 0x80) != 0;
  }
#else
  //Calculate all carry-ins.
  //Remembering that each bit of the sum =
  //  addend a's bit XOR addend b's bit XOR carry-in,
  //we can work out all carry-ins from a, b and their sum.
  carryIns = *acc ^ a ^ b;

  //Calculate the overflow using the carry-out and
  //most significant carry-in.
  carryIns = (carryIns >> 7) ^ carryOut;
#endif

  //Update flags.
  *flags &= ~(FLAGS_CY_MASK | FLAGS_OV_MASK);
  *flags |= (carryOut << FLAGS_CY_SHIFT) | (carryIns << FLAGS_OV_SHIFT);
}

void Sbb(uint8* acc, uint8 b, uint8* flags)
{
  //a - b - c = a + ~b + 1 - c = a + ~b + !c
  *flags ^= FLAGS_CY_MASK;
  Adc(acc, ~b, flags);
  *flags ^= FLAGS_CY_MASK;
}

const uint8 testData[] =
{
  0,
  1,
  0x7F,
  0x80,
  0x81,
  0xFF
};

int main(void)
{
  unsigned aidx, bidx, c;

  printf("ADC:\n");
  for (c = 0; c <= 1; c++)
    for (aidx = 0; aidx < sizeof(testData)/sizeof(testData[0]); aidx++)
      for (bidx = 0; bidx < sizeof(testData)/sizeof(testData[0]); bidx++)
      {
        uint8 a = testData[aidx];
        uint8 b = testData[bidx];
        uint8 flags = c << FLAGS_CY_SHIFT;
        printf("%3d(%4d) + %3d(%4d) + %u = ",
               a, (int8)a, b, (int8)b, c);
        Adc(&a, b, &flags);
        printf("%3d(%4d) CY=%d OV=%d\n",
               a, (int8)a, (flags & FLAGS_CY_MASK) != 0, (flags & FLAGS_OV_MASK) != 0);
      }

  printf("SBB:\n");
  for (c = 0; c <= 1; c++)
    for (aidx = 0; aidx < sizeof(testData)/sizeof(testData[0]); aidx++)
      for (bidx = 0; bidx < sizeof(testData)/sizeof(testData[0]); bidx++)
      {
        uint8 a = testData[aidx];
        uint8 b = testData[bidx];
        uint8 flags = c << FLAGS_CY_SHIFT;
        printf("%3d(%4d) - %3d(%4d) - %u = ",
               a, (int8)a, b, (int8)b, c);
        Sbb(&a, b, &flags);
        printf("%3d(%4d) CY=%d OV=%d\n",
               a, (int8)a, (flags & FLAGS_CY_MASK) != 0, (flags & FLAGS_OV_MASK) != 0);
      }

  return 0;
}

Ausgabe:

ADC:
  0(   0) +   0(   0) + 0 =   0(   0) CY=0 OV=0
  0(   0) +   1(   1) + 0 =   1(   1) CY=0 OV=0
  0(   0) + 127( 127) + 0 = 127( 127) CY=0 OV=0
  0(   0) + 128(-128) + 0 = 128(-128) CY=0 OV=0
  0(   0) + 129(-127) + 0 = 129(-127) CY=0 OV=0
  0(   0) + 255(  -1) + 0 = 255(  -1) CY=0 OV=0
  1(   1) +   0(   0) + 0 =   1(   1) CY=0 OV=0
  1(   1) +   1(   1) + 0 =   2(   2) CY=0 OV=0
  1(   1) + 127( 127) + 0 = 128(-128) CY=0 OV=1
  1(   1) + 128(-128) + 0 = 129(-127) CY=0 OV=0
  1(   1) + 129(-127) + 0 = 130(-126) CY=0 OV=0
  1(   1) + 255(  -1) + 0 =   0(   0) CY=1 OV=0
127( 127) +   0(   0) + 0 = 127( 127) CY=0 OV=0
127( 127) +   1(   1) + 0 = 128(-128) CY=0 OV=1
127( 127) + 127( 127) + 0 = 254(  -2) CY=0 OV=1
127( 127) + 128(-128) + 0 = 255(  -1) CY=0 OV=0
127( 127) + 129(-127) + 0 =   0(   0) CY=1 OV=0
127( 127) + 255(  -1) + 0 = 126( 126) CY=1 OV=0
128(-128) +   0(   0) + 0 = 128(-128) CY=0 OV=0
128(-128) +   1(   1) + 0 = 129(-127) CY=0 OV=0
128(-128) + 127( 127) + 0 = 255(  -1) CY=0 OV=0
128(-128) + 128(-128) + 0 =   0(   0) CY=1 OV=1
128(-128) + 129(-127) + 0 =   1(   1) CY=1 OV=1
128(-128) + 255(  -1) + 0 = 127( 127) CY=1 OV=1
129(-127) +   0(   0) + 0 = 129(-127) CY=0 OV=0
129(-127) +   1(   1) + 0 = 130(-126) CY=0 OV=0
129(-127) + 127( 127) + 0 =   0(   0) CY=1 OV=0
129(-127) + 128(-128) + 0 =   1(   1) CY=1 OV=1
129(-127) + 129(-127) + 0 =   2(   2) CY=1 OV=1
129(-127) + 255(  -1) + 0 = 128(-128) CY=1 OV=0
255(  -1) +   0(   0) + 0 = 255(  -1) CY=0 OV=0
255(  -1) +   1(   1) + 0 =   0(   0) CY=1 OV=0
255(  -1) + 127( 127) + 0 = 126( 126) CY=1 OV=0
255(  -1) + 128(-128) + 0 = 127( 127) CY=1 OV=1
255(  -1) + 129(-127) + 0 = 128(-128) CY=1 OV=0
255(  -1) + 255(  -1) + 0 = 254(  -2) CY=1 OV=0
  0(   0) +   0(   0) + 1 =   1(   1) CY=0 OV=0
  0(   0) +   1(   1) + 1 =   2(   2) CY=0 OV=0
  0(   0) + 127( 127) + 1 = 128(-128) CY=0 OV=1
  0(   0) + 128(-128) + 1 = 129(-127) CY=0 OV=0
  0(   0) + 129(-127) + 1 = 130(-126) CY=0 OV=0
  0(   0) + 255(  -1) + 1 =   0(   0) CY=1 OV=0
  1(   1) +   0(   0) + 1 =   2(   2) CY=0 OV=0
  1(   1) +   1(   1) + 1 =   3(   3) CY=0 OV=0
  1(   1) + 127( 127) + 1 = 129(-127) CY=0 OV=1
  1(   1) + 128(-128) + 1 = 130(-126) CY=0 OV=0
  1(   1) + 129(-127) + 1 = 131(-125) CY=0 OV=0
  1(   1) + 255(  -1) + 1 =   1(   1) CY=1 OV=0
127( 127) +   0(   0) + 1 = 128(-128) CY=0 OV=1
127( 127) +   1(   1) + 1 = 129(-127) CY=0 OV=1
127( 127) + 127( 127) + 1 = 255(  -1) CY=0 OV=1
127( 127) + 128(-128) + 1 =   0(   0) CY=1 OV=0
127( 127) + 129(-127) + 1 =   1(   1) CY=1 OV=0
127( 127) + 255(  -1) + 1 = 127( 127) CY=1 OV=0
128(-128) +   0(   0) + 1 = 129(-127) CY=0 OV=0
128(-128) +   1(   1) + 1 = 130(-126) CY=0 OV=0
128(-128) + 127( 127) + 1 =   0(   0) CY=1 OV=0
128(-128) + 128(-128) + 1 =   1(   1) CY=1 OV=1
128(-128) + 129(-127) + 1 =   2(   2) CY=1 OV=1
128(-128) + 255(  -1) + 1 = 128(-128) CY=1 OV=0
129(-127) +   0(   0) + 1 = 130(-126) CY=0 OV=0
129(-127) +   1(   1) + 1 = 131(-125) CY=0 OV=0
129(-127) + 127( 127) + 1 =   1(   1) CY=1 OV=0
129(-127) + 128(-128) + 1 =   2(   2) CY=1 OV=1
129(-127) + 129(-127) + 1 =   3(   3) CY=1 OV=1
129(-127) + 255(  -1) + 1 = 129(-127) CY=1 OV=0
255(  -1) +   0(   0) + 1 =   0(   0) CY=1 OV=0
255(  -1) +   1(   1) + 1 =   1(   1) CY=1 OV=0
255(  -1) + 127( 127) + 1 = 127( 127) CY=1 OV=0
255(  -1) + 128(-128) + 1 = 128(-128) CY=1 OV=0
255(  -1) + 129(-127) + 1 = 129(-127) CY=1 OV=0
255(  -1) + 255(  -1) + 1 = 255(  -1) CY=1 OV=0
SBB:
  0(   0) -   0(   0) - 0 =   0(   0) CY=0 OV=0
  0(   0) -   1(   1) - 0 = 255(  -1) CY=1 OV=0
  0(   0) - 127( 127) - 0 = 129(-127) CY=1 OV=0
  0(   0) - 128(-128) - 0 = 128(-128) CY=1 OV=1
  0(   0) - 129(-127) - 0 = 127( 127) CY=1 OV=0
  0(   0) - 255(  -1) - 0 =   1(   1) CY=1 OV=0
  1(   1) -   0(   0) - 0 =   1(   1) CY=0 OV=0
  1(   1) -   1(   1) - 0 =   0(   0) CY=0 OV=0
  1(   1) - 127( 127) - 0 = 130(-126) CY=1 OV=0
  1(   1) - 128(-128) - 0 = 129(-127) CY=1 OV=1
  1(   1) - 129(-127) - 0 = 128(-128) CY=1 OV=1
  1(   1) - 255(  -1) - 0 =   2(   2) CY=1 OV=0
127( 127) -   0(   0) - 0 = 127( 127) CY=0 OV=0
127( 127) -   1(   1) - 0 = 126( 126) CY=0 OV=0
127( 127) - 127( 127) - 0 =   0(   0) CY=0 OV=0
127( 127) - 128(-128) - 0 = 255(  -1) CY=1 OV=1
127( 127) - 129(-127) - 0 = 254(  -2) CY=1 OV=1
127( 127) - 255(  -1) - 0 = 128(-128) CY=1 OV=1
128(-128) -   0(   0) - 0 = 128(-128) CY=0 OV=0
128(-128) -   1(   1) - 0 = 127( 127) CY=0 OV=1
128(-128) - 127( 127) - 0 =   1(   1) CY=0 OV=1
128(-128) - 128(-128) - 0 =   0(   0) CY=0 OV=0
128(-128) - 129(-127) - 0 = 255(  -1) CY=1 OV=0
128(-128) - 255(  -1) - 0 = 129(-127) CY=1 OV=0
129(-127) -   0(   0) - 0 = 129(-127) CY=0 OV=0
129(-127) -   1(   1) - 0 = 128(-128) CY=0 OV=0
129(-127) - 127( 127) - 0 =   2(   2) CY=0 OV=1
129(-127) - 128(-128) - 0 =   1(   1) CY=0 OV=0
129(-127) - 129(-127) - 0 =   0(   0) CY=0 OV=0
129(-127) - 255(  -1) - 0 = 130(-126) CY=1 OV=0
255(  -1) -   0(   0) - 0 = 255(  -1) CY=0 OV=0
255(  -1) -   1(   1) - 0 = 254(  -2) CY=0 OV=0
255(  -1) - 127( 127) - 0 = 128(-128) CY=0 OV=0
255(  -1) - 128(-128) - 0 = 127( 127) CY=0 OV=0
255(  -1) - 129(-127) - 0 = 126( 126) CY=0 OV=0
255(  -1) - 255(  -1) - 0 =   0(   0) CY=0 OV=0
  0(   0) -   0(   0) - 1 = 255(  -1) CY=1 OV=0
  0(   0) -   1(   1) - 1 = 254(  -2) CY=1 OV=0
  0(   0) - 127( 127) - 1 = 128(-128) CY=1 OV=0
  0(   0) - 128(-128) - 1 = 127( 127) CY=1 OV=0
  0(   0) - 129(-127) - 1 = 126( 126) CY=1 OV=0
  0(   0) - 255(  -1) - 1 =   0(   0) CY=1 OV=0
  1(   1) -   0(   0) - 1 =   0(   0) CY=0 OV=0
  1(   1) -   1(   1) - 1 = 255(  -1) CY=1 OV=0
  1(   1) - 127( 127) - 1 = 129(-127) CY=1 OV=0
  1(   1) - 128(-128) - 1 = 128(-128) CY=1 OV=1
  1(   1) - 129(-127) - 1 = 127( 127) CY=1 OV=0
  1(   1) - 255(  -1) - 1 =   1(   1) CY=1 OV=0
127( 127) -   0(   0) - 1 = 126( 126) CY=0 OV=0
127( 127) -   1(   1) - 1 = 125( 125) CY=0 OV=0
127( 127) - 127( 127) - 1 = 255(  -1) CY=1 OV=0
127( 127) - 128(-128) - 1 = 254(  -2) CY=1 OV=1
127( 127) - 129(-127) - 1 = 253(  -3) CY=1 OV=1
127( 127) - 255(  -1) - 1 = 127( 127) CY=1 OV=0
128(-128) -   0(   0) - 1 = 127( 127) CY=0 OV=1
128(-128) -   1(   1) - 1 = 126( 126) CY=0 OV=1
128(-128) - 127( 127) - 1 =   0(   0) CY=0 OV=1
128(-128) - 128(-128) - 1 = 255(  -1) CY=1 OV=0
128(-128) - 129(-127) - 1 = 254(  -2) CY=1 OV=0
128(-128) - 255(  -1) - 1 = 128(-128) CY=1 OV=0
129(-127) -   0(   0) - 1 = 128(-128) CY=0 OV=0
129(-127) -   1(   1) - 1 = 127( 127) CY=0 OV=1
129(-127) - 127( 127) - 1 =   1(   1) CY=0 OV=1
129(-127) - 128(-128) - 1 =   0(   0) CY=0 OV=0
129(-127) - 129(-127) - 1 = 255(  -1) CY=1 OV=0
129(-127) - 255(  -1) - 1 = 129(-127) CY=1 OV=0
255(  -1) -   0(   0) - 1 = 254(  -2) CY=0 OV=0
255(  -1) -   1(   1) - 1 = 253(  -3) CY=0 OV=0
255(  -1) - 127( 127) - 1 = 127( 127) CY=0 OV=1
255(  -1) - 128(-128) - 1 = 126( 126) CY=0 OV=0
255(  -1) - 129(-127) - 1 = 125( 125) CY=0 OV=0
255(  -1) - 255(  -1) - 1 = 255(  -1) CY=1 OV=0

Können Sie ändern #if 0 zu #if 1 verwenden die Zeichen-Vergleich basierende Methode für überlauf Berechnung. Das Ergebnis wird das gleiche sein. Auf den ersten Blick ist es etwas überraschend, dass die sign-based-Methode kümmert sich um das carry-in zu.

Bitte beachten Sie, dass durch meine Methode, welche ich zur Berechnung aller carry-ins, die in bits 0 bis 7 erhalten Sie auch gratis den Wert der half-carry - flag (carry von bit 3 auf bit 4), die nötig ist, damit die DAA Unterricht.

EDIT: ich habe eine Funktion für die Subtraktion mit borrow (SBC/SBB-Anweisung) und die Ergebnisse für Sie.

Das ist perfekt - vielen Dank 🙂 ich wusste, dass ich in die richtige Richtung. Danke auch für dein code-Beispiel. Ich bin tatsächlich mit Java (als ich bin mit dem Ziel für diese eine komplett cross-Plattform-master-system-emulator, wenn es fertig ist), aber ich kann genug verstehen, um C um zu sehen, was Sie bist auf etwa. Sorry, wenn meine Frage schien einfach, es ist nur, dass ich habe, um mir beibringen, eine Menge von binären Mathematik-wie gehe ich mit diesem Projekt, so weit ich scheinen verstanden zu haben, es aber nicht 🙂
Danke für deine Erklärung, es ist wirklich präzise. Ich habe herausgefunden, das halfcarry-flag-by-doing - halfCarryOut = carryIn ? ((a & 0x0F) >= 0x0F - (a & 0x0F)) : ((a & 0x0F) > 0x0F - (a & 0x0F)); halfCarryOut = ((res ^ a ^ b) >> 4) ^ halfCarryOut; ist, sollte es korrigieren.
Wenn Sie es getestet haben und es funktioniert, OK, (ich werde nicht um ihn zu bestätigen). Aber es geht auch einfacher, da ich am Ende der Antwort. Verwenden Sie die code-Variante zwischen #else und #endif. Nach carryIns = *acc ^ a ^ b; tun halfCarryOut = (carryIns >> 4) & 1;, das ist alles, was Sie brauchen, um hinzuzufügen.
Ja, mein code ist ganz anders, so dass ich nur readapted meine Implementierung zu schreiben, mein Kommentar. Nein, ich werde keine Anfragen, die überprüfung, war ich versucht, um Ihre Antwort zum nachlesen 🙂
Tatsächlich, ich denke, es könnte ein bug hier. Sollte nicht 255 + 1 + c0 ein überlauf (da sollte die Antwort 256 aber endet als 0)?
255+1+0=0 ist, gibt Sie unsigned überlauf in CF, aber nicht geben Ihnen unterzeichnet überlauf in DER da, wenn Sie interpretiert wird als vorzeichenbehaftete es ist effektiv -1+1+0=0, also, was gibt es da zu überlaufen?
Für diejenigen, die die Umsetzung eines GAMEBOY-Z80:ich wollte nur hinzufügen, meine Tests zu diesem. In der gameboy-version des Z80, ein half-carry-flag UND carry-flag wird erzeugt, die für 255+1 Operationen.

InformationsquelleAutor Alexey Frunze

5

Anderen Weg, um zu sehen diese, die ist vielleicht einfacher zu verstehen. Bei der Durchführung einer Summe:
- Zeichen immer auf bit 7 des Ergebnisses
- Null wird gesetzt, wenn das Ergebnis 0x00
- Die Hälfte-tragen wird gesetzt, wenn das Rechte nibble Summe der Operanden überläufe
- Überlauf wird gesetzt, wenn beide Operanden positiv sind und die unterzeichnete Summe negativ ist oder beide Operanden negativ sind und die unterzeichnete Summe positiv ist
- Add/Sub zurückgesetzt
- Tragen ist gesetzt, wenn der vorzeichenlose Summe 0xFF überläuft
- Nettes recap. Um zu klären, nur ein bisschen weiter: "Add/Sub "zurückgesetzt", weil N bekommt explizit nur set, wenn die Letzte operation war eine Subtraktion. (Ich denke, dies ist für die DAA instruction nur.)
- Was meinst du mit 'bit 7'? 7. rückwärts gezählt, beginnend bei 0?
InformationsquelleAutor Sklivvz

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.