home *** CD-ROM | disk | FTP | other *** search
/ CP/M / CPM_CDROM.iso / enterprs / c128 / text / 64docs.arc / 64DOC.TXT next >
Text File  |  1993-09-16  |  60KB  |  1,414 lines
  1. ==============================================================================
  2. 64 Documentation
  3. by Jarkko Sonninen, Jouko Valta, John West, and Marko M"akel"a
  4.    (sonninen@lut.fi, jopi@stekt.oulu.fi, john@ucc.gu.uwa.edu.au,
  5.     msmakela@hylk.helsinki.fi)
  6.  
  7. [Ed's Note: I'm leaving this file as is because of its intention to
  8. serve as a reference guide, and not necessarily to be presented in
  9. article format. The detail and clarity with which the authors have
  10. presented the material is wonderful!!]
  11.  
  12. #
  13. # $Id: 64doc,v 1.3 93/06/21 13:37:18 jopi Exp $
  14. #
  15. # This file is part of Commodore 64 emulator
  16. #      and Program Development System.
  17. #
  18. # See README for copyright notice
  19. #
  20. # This file contains documentation for 6502/6510/8502 instruction set.
  21. #
  22. # Written by 
  23. #   Jarkko Sonninen (sonninen@lut.fi)
  24. #   Jouko Valta     (jopi@stekt.oulu.fi)
  25. #   John West       (john@ucc.gu.uwa.edu.au)
  26. #   Marko M"akel"a  (msmakela@hylk.helsinki.fi)
  27. #
  28. # $Log: 64doc,v $
  29. # Revision 1.3  93/06/21  13:37:18  jopi
  30. #  X64 version 0.2 PL 0
  31. # 
  32. # Revision 1.2  93/06/21  13:07:15  jopi
  33. # *** empty log message ***
  34. # 
  35. #
  36. #
  37.  
  38.                 6510 Instructions by Addressing Modes
  39.  
  40.         ++++++++ Positive ++++++++++    -------- Negative ----------
  41.         00      20      40      60      80      a0      c0      e0      mode
  42.  
  43. +00     BRK     JSR     RTI     RTS     NOP*    LDY     CPY     CPX  Impl/immed
  44. +01     ORA     AND     EOR     ADC     STA     LDA     CMP     SBC  (indir,x)
  45. +02      t       t       t       t      NOP*t   LDX     NOP*t   NOP*t  ? /immed
  46. +03     SLO*    RLA*    SRE*    RRA*    SAX*    LAX*    DCP*    ISB* (indir,x)
  47. +04     NOP*    BIT     NOP*    NOP*    STY     LDY     CPY     CPX  Zeropage
  48. +05     ORA     AND     EOR     ADC     STA     LDA     CMP     SBC     -"-
  49. +06     ASL     ROL     LSR     ROR     STX     LDX     DEC     INC     -"-
  50. +07     SLO*    RLA*    SRE*    RRA*    SAX*    LAX*    DCP*    ISB*    -"-
  51.  
  52. +08     PHP     PLP     PHA     PLA     DEY     TAY     INY     INX  Implied
  53. +09     ORA     AND     EOR     ADC     NOP*    LDA     CMP     SBC  Immediate
  54. +0a     ASL     ROL     LSR     ROR     TXA     TAX     DEX     NOP  Accu/impl
  55. +0b     ANC**   ANC**   ASR**   AR
  56.  Cancel 
  57.  
  58. /duck/mailserv/hacking> 
  59.  Interrupt 
  60.  
  61. /duck/mailserv/hacking> 
  62.  
  63.                 6510 Instructions by Addressing Modes
  64.  
  65.         ++++++++ Positive ++++++++++    -------- Negative ----------
  66.         00      20      40      60      80      a0      c0      e0      mode
  67.  
  68. +00     BRK     JSR     RTI     RTS     NOP*    LDY     CPY     CPX  Impl/immed
  69. +01     ORA     AND     EOR     ADC     STA     LDA     CMP     SBC  (indir,x)
  70. +02      t       t       t       t      NOP*t   LDX     NOP*t   NOP*t  ? /immed
  71. +03     SLO*    RLA*    SRE*    RRA*    SAX*    LAX*    DCP*    ISB* (indir,x)
  72. +04     NOP*    BIT     NOP*    NOP*    STY     LDY     CPY     CPX  Zeropage
  73. +05     ORA     AND     EOR     ADC     STA     LDA     CMP     SBC     -"-
  74. +06     ASL     ROL     LSR     ROR     STX     LDX     DEC     INC     -"-
  75. +07     SLO*    RLA*    SRE*    RRA*    SAX*    LAX*    DCP*    ISB*    -"-
  76.  
  77. +08     PHP     PLP     PHA     PLA     DEY     TAY     INY     INX  Implied
  78. +09     ORA     AND     EOR     ADC     NOP*    LDA     CMP     SBC  Immediate
  79. +0a     ASL     ROL     LSR     ROR     TXA     TAX     DEX     NOP  Accu/impl
  80. +0b     ANC**   ANC**   ASR**   ARR**   ANE**   LXA**   SBX**   SBC* Immediate
  81. +0c     NOP*    BIT     JMP     JMP     STY     LDY     CPY     CPX  Absolute
  82. +0d     ORA     AND     EOR     ADC     STA     LDA     CMP     SBC     -"-
  83. +0e     ASL     ROL     LSR     ROR     STX     LDX     DEC     INC     -"-
  84. +0f     SLO*    RLA*    SRE*    RRA*    SAX*    LAX*    DCP*    ISB*    -"-
  85.  
  86. +10     BPL     BMI     BVC     BVS     BCC     BCS     BNE     BEQ  Relative
  87. +11     ORA     AND     EOR     ADC     STA     LDA     CMP     SBC  (indir),y
  88. +12      t       t       t       t       t       t       t       t      ?
  89. +13     SLO*    RLA*    SRE*    RRA*    SHA**   LAX*    DCP*    ISB* (indir),y
  90. +14     NOP*    NOP*    NOP*    NOP*    STY     LDY     NOP*    NOP* Zeropage,x
  91. +15     ORA     AND     EOR     ADC     STA     LDA     CMP     SBC     -"-
  92. +16     ASL     ROL     LSR     ROR     STX y)  LDX y)  DEC     INC     -"-
  93. +17     SLO*    RLA*    SRE*    RRA*    SAX* y) LAX* y) DCP     ISB     -"-
  94.  
  95. +18     CLC     SEC     CLI     SEI     TYA     CLV     CLD     SED  Implied
  96. +19     ORA     AND     EOR     ADC     STA     LDA     CMP     SBC  Absolute,y
  97. +1a     NOP*    NOP*    NOP*    NOP*    TXS     TSX     NOP*    NOP* Implied
  98. +1b     SLO*    RLA*    SRE*    RRA*    SHS**   LAS**   DCP*    ISB* Absolute,y
  99. +1c     NOP*    NOP*    NOP*    NOP*    SHY**   LDY     NOP*    NOP* Absolute,x
  100. +1d     ORA     AND     EOR     ADC     STA     LDA     CMP     SBC     -"-
  101. +1e     ASL     ROL     LSR     ROR     SHX**y) LDX y)  DEC     INC     -"-
  102. +1f     SLO*    RLA*    SRE*    RRA*    SHA**y) LAX* y) DCP     ISB     -"-
  103.  
  104.         Legend:
  105.  
  106.         t       Jams the machine
  107.         *t      Jams very rarely
  108.         *       Undocumented command
  109.         **      Unusual operation
  110.         y)      indexed using IY instead of IX
  111.  
  112.  
  113.  
  114.                 6510/8502 Undocumented Commands
  115.  
  116.          -- A brief explanation about what may happen while
  117.                 using don't care states.
  118.  
  119.  
  120.         ANE $8B         AC = (AC | #$EE) & IX & #byte
  121.                         same as
  122.                         AC = ((AC & #$11 & IX) | ( #$EE & IX)) & #byte
  123.  
  124.                         In real 6510/8502 the internal parameter #$11 may
  125.                         occasionally be #$10, #$01 or even #$00. This occurs
  126.                         probably when the VIC halts the processor right between
  127.                         the two clock cycles of this instruction.
  128.  
  129.         LXA $AB         C=Lehti:   AC = IX = ANE
  130.                         Alternate: AC = IX = (AC & #byte)
  131.  
  132.                         TXA and TAX have to be responsible for these.
  133.  
  134.  
  135.         SHA $93,$9F     Store (AC & IX & (ADDR_HI + 1))
  136.         SHX $9E         Store (IX & (ADDR_HI + 1))
  137.         SHY $9C         Store (IY & (ADDR_HI + 1))
  138.         SHS $9B         SHA and TXS, where X is replaced by (AC & IX).
  139.  
  140.                         Note: The value to be stored is copied also
  141.                         to ADDR_HI if page boundary is crossed.
  142.  
  143.  
  144.         SBX $CB         Carry and Decimal flags are ignored but set in 
  145.                         substraction. This is due to the CMP command,
  146.                         which is executed instead of the real SBC.
  147.  
  148.  
  149.  Many undocumented commands do not use AND between registers, the CPU just
  150.  throws the bytes to a bus simultaneously and lets the open-collector drivers
  151.  perform the AND. I.e. the command called 'SAX', which is in the STORE section
  152.  (opcodes $A0...$BF), stores the result of (AC & IX) by this way.
  153.  
  154.  More fortunate is its opposite, 'LAX' which just loads a byte simultaeously
  155.  into both AC and IX.
  156.  
  157.  
  158.         $CB  SBX   IX <- (AC & IX) - Immediate
  159.  
  160.  The 'SBX' ($CB) may seem to be very complex operation, even though it is
  161.  combination of subtraction of accumulator and parameter, as in the 'CMP'
  162.  instruction, and the command 'DEX'. As a result, both AC and IX are connected
  163.  to ALU but only the subtraction takes place. Since the comparison logic was
  164.  used, the result of subtraction should be normally ignored, but the 'DEX' now
  165.  happily stores to IX the value of (AC & IX) - Immediate.
  166.  That is why this instruction does not have any decimal mode, and it does not
  167.  affect the V flag. Also Carry flag is ignored in the subtraction but set
  168.  according to the result.
  169.  
  170.  Proof:
  171.  
  172.  These test programs show if your machine is compatible with ours
  173.  regarding the opcode $CB. The first test, vsbx, shows that SBX does
  174.  not affect the V flag. The latter one, sbx, shows the rest of our
  175.  theory. The vsbx test tests 33554432 SBX combinations (16777216
  176.  different AC, IX and Immediate combinations, and two different V flag
  177.  states), and the sbx test doubles that amount (16777216*4 D and C flag
  178.  combinations). Both tests have run successfully on a C64 and a Vic20.
  179.  They ought to run on C16, +4 and the PET series as well. The tests
  180.  stop with BRK, if the opcode $CB does not work expectedly. Successful
  181.  operation ends in RTS. As the tests are very slow, they print dots on
  182.  the screen while running so that you know that the machine has
  183.  not jammed. On computers running at 1 MHz, the first test prints
  184.  approximately one dot every four seconds and a total of 2048 dots,
  185.  whereas the second one prints half that amount, one dot every seven seconds.
  186.  
  187.  If the tests fail on your machine, please let us know your processor's part
  188.  number and revision. If possible, save the executable (after it has stopped
  189.  with BRK) under another name and send it to us so that we know at which stage
  190.  the program stopped.
  191.  
  192.  The following program is a Commodore 64 executable that Marko M"akela
  193.  developed when trying to find out how the V flag is affected by SBX.
  194.  (It was believed that the SBX affects the flag in a weird way, and this
  195.  program shows how SBX sets the flag differently from SBC.)
  196.  You may find the subroutine at $C150 useful when researching other 
  197.  undocumented instructions' flags. Run the program in a machine language
  198.  monitor, as it makes use of the BRK instruction. The result tables will be
  199.  written on pages $C2 and $C3.
  200.  
  201.  Other undocumented instructions usually cause two preceding opcodes being
  202.  executed. However 'NOP' seems to completely disappear from 'SBC' code $EB.
  203.  
  204.  The most difficult to comprehend are the rest of the instructions located on
  205.  the '$0B' line.
  206.  
  207.  All the instructions located at the positive (left) side of this line should
  208.  rotate either memory or the accumulator, but the addressing mode turns out
  209.  to be immediate!
  210.  No problem. Just read the operand, let it be ANDed with the accumulator
  211.  and finally use accumulator addressing mode for the instructions above them.
  212.  
  213.  The rest two instructions on the same line, called 'ANE' and 'LXA' ($8B and
  214.  $AB respectively) often give quite unpredictable results.
  215.  However, the most usual operation is to store ((A | #$ee) & X & #$nn) to
  216.  accumulator. Note that this does not work reliably in a real 64!
  217.  On 8502 opcode $8B uses values 8C,CC, EE, and occasionally 0C and 8E for the
  218.  OR instead of EE,EF,FE and FF used by 6510. With 8502 running at 2 MHz #$EE is
  219.  always used.
  220.  Opcode $AB does not cause this OR taking place on 8502 while 6510 always 
  221.  performs it.  Note that this behaviour depends on chip revision.
  222.  
  223.  Let's take a closer look at $8B (6510).
  224.  
  225.         AC <- IX & D & (AC | VAL)
  226.  
  227.         where VAL comes from this table:
  228.  
  229.        IX high  D high  D low   VAL
  230.         even     even    ---    $EE (1)
  231.         even     odd     ---    $EE
  232.         odd      even    ---    $EE
  233.         odd      odd      0     $EE
  234.         odd      odd     not 0  $FE (2)
  235.  
  236.  (1) If the bottom 2 bits of AC are both 1, then the LSB of the result may
  237.     be 0. The values of IX and D are different every time I run the test.
  238.     This appears to be very rare.
  239.  (2) VAL is $FE most of the time. Sometimes it is $EE - it seems to be random,
  240.     not related to any of the data. This is much more common than (1).
  241.  
  242.   In decimal mode, VAL is usually $FE.
  243.  
  244.  
  245.  Two different functions has been discovered for LAX, opcode $AB. One is
  246.  AC = IX = ANE (see above) and the other, encountered with 6510 and 8502,
  247.  is less complicated AC = IX = (AC & #byte). However, according to what is
  248.  reported, the version altering only the lowest bits of each nybble seems to
  249.  be more common.
  250.  
  251.  What happens, is that $AB loads a value into both AC and IX, ANDing
  252.  the low bit of each nybble with the corresponding bit of the old AC. However,
  253.  there are exceptions. Sometimes the low bit is cleared even when AC contains
  254.  a '1', and sometimes other bits are cleared. The exceptions seem random (they
  255.  change every time I run the test). Oops - that was in decimal mode. Much
  256.  the same with D=0.
  257.  
  258.  What causes the randomness?  Probably it is that it is marginal logic levels -
  259.  when too much wired-anding goes on, some of the signals get very close to
  260.  the threshold. Perhaps we're seeing some of them step over it. The low bit
  261.  of each nybble is special, since it has to cope with carry differently
  262.  (remember decimal mode). We never see a '0' turn into a '1'.
  263.  
  264.  Since these instructions are unpredictable, they should not be used.
  265.  
  266.  
  267.  There is still very strange instruction left, the one named SHA/X/Y, which is
  268.  the only one with only indexed addressing modes. Actually, the commands 'SHA',
  269.  'SHX' and 'SHY' are generated by the indexing algorithm.
  270.  
  271.  While using indexed addressing, effective address for page boundary crossing
  272.  is calculated as soon as possible so it does not slow down operation.
  273.  As a result, in the case of SHA/X/Y, the address and data are prosessed at the
  274.  same time making AND between the to take place. Thus, the value to be stored
  275.  by SAX, for example, is in fact (AC & IX & (ADDR_HI + 1)).
  276.  On page boundary crossing the same value is copied also to high byte of the
  277.  effective address.
  278.  
  279.  
  280.  
  281.   Register selection for load and store
  282.  
  283.    bit1 bit0    AC IX IY
  284.     0   0             x
  285.     0   1          x
  286.     1   0       x
  287.     1   1       x  x
  288.  
  289.  So, AC and IX are selected by bits 1 and 0 respectively, while ~(bit1 | bit0)
  290.  enables IY.
  291.  
  292.  Indexing is determined by bit4, even in relative addressing mode, which
  293.  is one kind of indexing.
  294.  
  295.  Lines containing opcodes xxx000x1 (01 and 03) are treated as absolute after
  296.  the effective address has been loaded into CPU.
  297.  
  298.  Zeropage,y and Absolute,y (codes 10x1 x11x) are distinquished by bit5.
  299.  
  300.  
  301.                  Decimal mode in NMOS 6500 series
  302.  
  303.    Most sources claim that the NMOS 6500 series sets the N, V and Z flags
  304.  unpredictably. Of course, this is not true. While testing how the flags are
  305.  set, I also wanted to see what happens if you use illegal BCD values.
  306.  
  307.    ADC works in Decimal mode in a quite complicated way. It is amazing how it
  308.  can do that all in a single cycle. Here's a pseudo code version of the
  309.  instruction:
  310.  
  311.     AC    accumulator
  312.     AL    low nybble of accumulator
  313.     AH    high nybble of accumulator
  314.  
  315.     C    Carry flag
  316.     Z    Zero flag
  317.     V    oVerflow flag
  318.     N    Negative flag
  319.  
  320.     s    value to be added to accumulator
  321.  
  322.     AL = (AC & 15) + (s & 15) + C;        ! Calculate the lower nybble.
  323.  
  324.     if (AL > 9)                ! BCD fixup
  325.       AL += 6;                ! for lower nybble
  326.  
  327.     AH = (A >> 4) + (s >> 4) + (AL > 15);    ! Calculate the upper nybble.
  328.  
  329.     Z = (AC + s + C != 0);            ! Zero flag is set just
  330.                         ! like in Binary mode.
  331.  
  332.     ! Negative and Overflow flags are set with the same logic than in
  333.     ! Binary mode, but after fixing the lower nybble.
  334.  
  335.     N = (AH & 8 != 0);
  336.     V = ((AH & 8) ^ (A >> 4)) && (!(A ^ s) & 128);
  337.  
  338.     if (AH > 9)                ! BCD fixup
  339.       AH += 6;                ! for upper nybble
  340.  
  341.     
  342.  
  343.     ! Carry is the only flag set after fixing the result.
  344.  
  345.     C = (AH > 15);
  346.     AC = ((AH << 4) | (AL & 15)) & 255;
  347.  
  348.  
  349.    The C flag is set as the quiche eaters expect, but the N and V flags 
  350.  are set after fixing the lower nybble but before fixing the upper one.
  351.  They use the same logic than binary mode ADC. The Z flag is set before
  352.  any BCD fixup, so the D flag does not have any influence on it.
  353.  
  354.  Proof: The following test program tests all 131072 ADC combinations in
  355.         Decimal mode, and aborts with BRK if anything breaks this theory.
  356.         If everything goes well, it ends in RTS.
  357.  
  358.    All programs in this chapter have been successfully tested on a Vic20
  359.  and a Commodore 64. They should run on C16, +4 and on the PET series as
  360.  well. If not, please report the problem to Marko M"akel"a. Each test in
  361.  this chapter should run in less than a minute at 1 MHz.
  362.  
  363.    SBC is much easier. Just like CMP, its flags are not affected by
  364.  the D flag.
  365.  
  366.  Proof:
  367.  
  368.    The only difference in SBC's operation in decimal mode from binary mode
  369.  is the result-fixup:
  370.  
  371.     AC    accumulator
  372.     AL    low nybble of accumulator
  373.     AH    high nybble of accumulator
  374.  
  375.     C    Carry flag
  376.     Z    Zero flag
  377.     V    oVerflow flag
  378.     N    Negative flag
  379.  
  380.     s    value to be added to accumulator
  381.  
  382.     AL = (AC & 15) - (s & 15) - !C;        ! Calculate the lower nybble.
  383.  
  384.     if (AL & 16)                ! BCD fixup
  385.       AL -= 6;                ! for lower nybble
  386.  
  387.     AH = (AC >> 4) - (s >> 4) - (AL > 15);    ! Calculate the upper nybble.
  388.  
  389.     if (AH & 16)                ! BCD fixup
  390.       AH -= 6;                ! for upper nybble
  391.  
  392.     ! Flags are set just like in Binary mode.
  393.  
  394.     C = (AC - s - !C > 255);
  395.     Z = (AC - s - !C != 0);
  396.     V = ((AC - s - !C) ^ s) && ((AC ^ s) & 128);
  397.     N = ((AC - s - !C) & 128);
  398.  
  399.     AC = ((AH << 4) | (AL & 15)) & 255;
  400.  
  401.  
  402.    Again Z flag is set before any BCD fixup. The N and V flags are set
  403.  at any time before fixing the high nybble. The C flag may be set in any
  404.  phase.
  405.  
  406.    Decimal subtraction is easier than decimal addition, as you have to
  407.  make the BCD fixup only when a nybble flows over. In decimal addition,
  408.  you had to verify if the nybble was greater than 9. The processor has
  409.  an internal "half carry" flag for the lower nybble, and it uses it to
  410.  trigger the BCD fixup. When calculating with legal BCD values, the
  411.  lower nybble cannot flow over again when fixing it. So the processor
  412.  does not handle overflows while performing the fixup. Similarly, the
  413.  BCD fixup occurs in the high nybble only if the value flows over,
  414.  i.e. when the C flag will be cleared.
  415.  
  416.    Because SBC's flags are not affected by the Decimal mode flag, you
  417.  could guess that CMP uses the SBC logic, only setting the C flag
  418.  first. But the SBX instruction shows that CMP also temporarily clears
  419.  the D flag, although it is totally unnecessary.
  420.  
  421.    The following program, which tests SBC's result and flags,
  422.  contains the 6502 version of the pseudo code example above.
  423.  
  424.  
  425.    Obviously the undocumented instructions RRA (ROR+ADC) and ISB
  426.  (INC+SBC) have inherited also the decimal operation from the official
  427.  instructions ADC and SBC. The program droradc shows this statement
  428.  for ROR, and the dincsbc test shows this for ISB. Finally,
  429.  dincsbc-deccmp shows that ISB's and DCP's (DEC+CMP) flags are not
  430.  affected by the D flag.
  431.  
  432.  
  433.                                  6510 features
  434.    o  PHP always pushes the Break (B) flag as a `1' to the stack.
  435.       Jukka Tapanim"aki claimed in C=lehti issue 3/89, on page 27 that the
  436.       processor makes a logical OR between the status register's bit 4 
  437.       and the bit 8 of the stack register (which is always 1).
  438.  
  439.    o  Indirect addressing modes do not handle page boundary crossing at all.
  440.       When the parameter's low byte is $FF, the effective address wraps 
  441.       around and the CPU fetches high byte from $xx00 instead of $xx00+$0100.
  442.       E.g. JMP ($01FF) fetches PCL from $01FF and PCH from $0100,
  443.       and LDA ($FF),Y fetches the base address from $FF and $00.
  444.  
  445.    o  Indexed zero page addressing modes never fix the page address on
  446.       crossing the zero page boundary.
  447.       E.g. LDX #$01 : LDA ($FF,X) loads the effective address from $00 and $01.
  448.  
  449.    o  The processor always fetches the byte following a relative branch
  450.       instruction. If the branch is taken, the processor reads then the
  451.       opcode from the destination address. If page boundary is crossed, it
  452.       first reads a byte from the old page from a location that is bigger
  453.       or smaller than the correct address by one page.
  454.  
  455.    o  If you cross a page boundary in any other indexed mode,
  456.       the processor reads an incorrect location first, a location that is
  457.       smaller by one page.
  458.  
  459.    o  Read-Modify-Write instructions write unmodified data, then modified
  460.       (so INC effectively does LDX loc;STX loc;INX;STX loc)
  461.  
  462.    o  -RDY is ignored during writes
  463.       (This is why you must wait 3 cycles before doing any DMA -
  464.       the maximum number of consecutive writes is 3, which occurs
  465.       during interrupts except -RESET.)
  466.  
  467.    o  Some undefined opcodes may give really unpredictable results.
  468.  
  469.    o  All registers except the Program Counter remain the same after -RESET.
  470.       (This is why you must preset D and I flags in the RESET handler.)
  471.  
  472.  
  473.                 Different CPU types
  474.  
  475.  The Rockwell data booklet 29651N52 (technical information about R65C00 
  476.  microprocessors, dated October 1984), lists the following differences between
  477.  NMOS R6502 microprocessor and CMOS R65C00 family:
  478.  
  479.  1. Indexed addressing across page boundary.
  480.         NMOS: Extra read of invalid address.
  481.         CMOS: Extra read of last instruction byte.
  482.  
  483.  2. Execution of invalid op codes.
  484.         NMOS: Some terminate only by reset. Results are undefined.
  485.         CMOS: All are NOPs (reserved for future use).
  486.  
  487.  3. Jump indirect, operand = XXFF.
  488.         NMOS: Page address does not increment.
  489.         CMOS: Page address increments and adds one additional cycle.
  490.  
  491.  4. Read/modify/write instructions at effective address.
  492.         NMOS: One read and two write cycles.
  493.         CMOS: Two read and one write cycle.
  494.  
  495.  5. Decimal flag.
  496.         NMOS: Indeterminate after reset.
  497.         CMOS: Initialized to binary mode (D=0) after reset and interrupts.
  498.  
  499.  6. Flags after decimal operation.
  500.         NMOS: Invalid N, V and Z flags.
  501.         CMOS: Valid flag adds one additional cycle.
  502.  
  503.  7. Interrupt after fetch of BRK instruction.
  504.         NMOS: Interrupt vector is loaded, BRK vector is ignored.
  505.         CMOS: BRK is executed, then interrupt is executed.
  506.  
  507.  
  508.  
  509.                 6510 Instruction Timing
  510.  
  511.    The NMOS 6500 series uses a sort of pipelining. It always reads two
  512.  bytes for each instruction. If the instruction was only two cycles long,
  513.  the opcode for the next instruction can be fetched during the third cycle.
  514.  As most instructions are two or three bytes long, this is quite efficient.
  515.  But one-byte instructions take two cycles, even though they could be
  516.  performed in one.
  517.  
  518.    The following tables show what happens on the bus while executing different
  519.  kinds of instructions. The tables having "???" marks at any cycle may be
  520.  totally wrong, but the rest should be absolutely accurate.
  521.  
  522.  
  523.   Interrupts
  524.  
  525.      NMI and IRQ both take 7 cycles. Their timing diagram is much like
  526.      BRK's. IRQ will be executed only when the I flag is clear.
  527.      The processor will usually wait for the current instruction to
  528.      complete before executing the interrupt sequence.
  529.  
  530.      There is one exception to this rule: If a NMI occurs while the
  531.      processor is executing a BRK, the two interrupts may take 7 to 14
  532.      cycles to execute, and the processor may totally lose the BRK
  533.      instruction. Probably the results are similar also with IRQ.
  534.      Marko M"akel"a experimented with BRK/NMI, but he still hasn't
  535.      analyzed the results.
  536.  
  537.      RESET does not push program counter on stack, and we don't know how
  538.      long it lasts. But we know that RESET preserves all registers
  539.      (except PC).
  540.  
  541.  
  542.   Accumulator or implied addressing
  543.  
  544.      BRK
  545.  
  546.         #  address R/W description
  547.        --- ------- --- -----------------------------------------------
  548.         1    PC     R  fetch opcode, increment PC
  549.         2    PC     R  read next instruction byte (and throw it away),
  550.                increment PCR
  551.         3  $0100,S  W  push PCH on stack (with B flag set), decrement S
  552.         4  $0100,S  W  push PCL on stack, decrement S
  553.         5  $0100,S  W  push P on stack, decrement S
  554.         6   $FFFE   R  fetch PCL
  555.         7   $FFFF   R  fetch PCH
  556.  
  557.  
  558.      RTI
  559.  
  560.         #  address R/W description
  561.        --- ------- --- -----------------------------------------------
  562.         1    PCR    R  fetch opcode, increment PCR
  563.         2    PCR    R  read next instruction byte (and throw it away),
  564.                      increment PCR
  565.         3  $0100,S  R  increment S
  566.         4  $0100,S  R  pull P from stack, increment S
  567.         5  $0100,S  R  pull PCL from stack, increment S
  568.         6  $0100,S  R  pull PCH from stack
  569.  
  570.  
  571.      RTS
  572.  
  573.         #  address R/W description
  574.        --- ------- --- -----------------------------------------------
  575.         1    PCR    R  fetch opcode, increment PCR
  576.         2    PCR    R  read next instruction byte (and throw it away),
  577.                increment PCR
  578.         3  $0100,S  R  increment S
  579.         4  $0100,S  R  pull PCL from stack, increment S
  580.         5  $0100,S  R  pull PCH from stack
  581.         6    PCR    R  increment PCR
  582.  
  583.  
  584.      PHA, PHP
  585.  
  586.         #  address R/W description
  587.        --- ------- --- -----------------------------------------------
  588.         1    PCR    R  fetch opcode, increment PCR
  589.         2    PCR    R  read next instruction byte (and throw it away),
  590.                increment PCR
  591.         3  $0100,S  W  push register on stack, decrement S
  592.  
  593.  
  594.      PLA, PLP
  595.  
  596.         #  address R/W description
  597.        --- ------- --- -----------------------------------------------
  598.         1    PCR    R  fetch opcode, increment PCR
  599.         2    PCR    R  read next instruction byte (and throw it away),
  600.                increment PCR
  601.         3  $0100,S  R  increment S
  602.         4  $0100,S  R  pull register from stack
  603.  
  604.         Note: The 3rd cycle does NOT read from PCR.
  605.               Maybe it reads from $0100,S.
  606.  
  607.  
  608.      Other instructions
  609.  
  610.         #  address R/W description
  611.        --- ------- --- -----------------------------------------------
  612.         1    PCR    R  fetch opcode, increment PCR
  613.         2    PCR    R  read next instruction byte (and throw it away),
  614.                increment PCR
  615.  
  616.  
  617.   Immediate addressing
  618.  
  619.         #  address R/W description
  620.        --- ------- --- ------------------------------------------
  621.         1    PCR    R  fetch opcode, increment PCR
  622.         2    PCR    R  fetch value, increment PCR
  623.  
  624.  
  625.   Absolute addressing
  626.  
  627.      JMP
  628.  
  629.         #  address R/W description
  630.        --- ------- --- -------------------------------------------------
  631.         1    PCR    R  fetch opcode, increment PCR
  632.         2    PCR    R  fetch address's low byte to latch, increment PCR
  633.         3    PCR    R  copy latch to PCL, fetch address's high byte to
  634.                latch, increment PCR, copy latch to PCH
  635.  
  636.  
  637.      JSR
  638.  
  639.         #  address R/W description
  640.        --- ------- --- -------------------------------------------------
  641.         1    PCR    R  fetch opcode, increment PCR
  642.         2    PCR    R  fetch address's low byte to latch, increment PCR
  643.         3  $0100,S  R  store latch
  644.         4  $0100,S  W  push PCH on stack, decrement S
  645.         5  $0100,S  W  push PCL on stack, decrement S
  646.         6    PCR    R  copy latch to PCL, fetch address's high byte to
  647.                latch, increment PCR, copy latch to PCH
  648.  
  649.  
  650.      Read instructions (LDA, LDX, LDY, EOR, AND, ORA, ADC, SBC, CMP, BIT,
  651.                         LAX, NOP)
  652.  
  653.         #  address R/W description
  654.        --- ------- --- ------------------------------------------
  655.         1    PCR    R  fetch opcode, increment PCR
  656.         2    PCR    R  fetch low byte of address, increment PCR
  657.         3    PCR    R  fetch high byte of address, increment PCR
  658.         4  address  R  read from effective address
  659.  
  660.  
  661.      Read-Modify-Write instructions (ASL, LSR, ROL, ROR, INC, DEC,
  662.                                      SLO, SRE, RLA, RRA, ISB, DCP)
  663.  
  664.         #  address R/W description
  665.        --- ------- --- ------------------------------------------
  666.         1    PCR    R  fetch opcode, increment PCR
  667.         2    PCR    R  fetch low byte of address, increment PCR
  668.         3    PCR    R  fetch high byte of address, increment PCR
  669.         4  address  R  read from effective address
  670.         5  address  W  write the value back to effective address,
  671.                        and do the operation on it
  672.         6  address  W  write the new value to effective address
  673.  
  674.  
  675.      Write instructions (STA, STX, STY, SAX)
  676.     
  677.         #  address R/W description
  678.        --- ------- --- ------------------------------------------
  679.         1    PCR    R  fetch opcode, increment PCR
  680.         2    PCR    R  fetch low byte of address, increment PCR
  681.         3    PCR    R  fetch high byte of address, increment PCR
  682.         4  address  W  write register to effective address
  683.  
  684.  
  685.   Zero page addressing
  686.  
  687.      Read instructions (LDA, LDX, LDY, EOR, AND, ORA, ADC, SBC, CMP, BIT,
  688.                         LAX, NOP)
  689.  
  690.         #  address R/W description
  691.        --- ------- --- ------------------------------------------
  692.         1    PCR    R  fetch opcode, increment PCR
  693.         2    PCR    R  fetch address, increment PCR
  694.         3  address  R  read from effective address
  695.  
  696.  
  697.      Read-Modify-Write instructions (ASL, LSR, ROL, ROR, INC, DEC,
  698.                                      SLO, SRE, RLA, RRA, ISB, DCP)
  699.  
  700.         #  address R/W description
  701.        --- ------- --- ------------------------------------------
  702.         1    PCR    R  fetch opcode, increment PCR
  703.         2    PCR    R  fetch address, increment PCR
  704.         3  address  R  read from effective address
  705.         4  address  W  write the value back to effective address,
  706.                        and do the operation on it
  707.         5  address  W  write the new value to effective address
  708.  
  709.  
  710.      Write instructions (STA, STX, STY, SAX)
  711.     
  712.         #  address R/W description
  713.        --- ------- --- ------------------------------------------
  714.         1    PCR    R  fetch opcode, increment PCR
  715.         2    PCR    R  fetch address, increment PCR
  716.         3  address  W  write register to effective address
  717.  
  718.   Zero page indexed addressing
  719.  
  720.      Read instructions (LDA, LDX, LDY, EOR, AND, ORA, ADC, SBC, CMP, BIT,
  721.                         LAX, NOP)
  722.  
  723.         #   address  R/W description
  724.        --- --------- --- ------------------------------------------
  725.         1     PCR     R  fetch opcode, increment PCR
  726.         2     PCR     R  fetch address, increment PCR
  727.     3   address   R  read from address, add index register to it
  728.         4  address+I* R  read from effective address
  729.  
  730.        Notes: I denotes either index register (X or Y).
  731.  
  732.               * The high byte of the effective address is always zero,
  733.                 i.e. page boundary crossings are not handled.
  734.  
  735.  
  736.      Read-Modify-Write instructions (ASL, LSR, ROL, ROR, INC, DEC,
  737.                                      SLO, SRE, RLA, RRA, ISB, DCP)
  738.  
  739.         #   address  R/W description
  740.        --- --------- --- ---------------------------------------------
  741.         1     PCR     R  fetch opcode, increment PCR
  742.         2     PCR     R  fetch address, increment PCR
  743.     3   address   R  read from address, add index register X to it
  744.         4  address+X* R  read from effective address
  745.         5  address+X* W  write the value back to effective address,
  746.                          and do the operation on it
  747.         6  address+X* W  write the new value to effective address
  748.  
  749.        Note: * The high byte of the effective address is always zero,
  750.                i.e. page boundary crossings are not handled.
  751.  
  752.  
  753.      Write instructions (STA, STX, STY, SAX)
  754.  
  755.         #   address  R/W description
  756.        --- --------- --- -------------------------------------------
  757.         1     PCR     R  fetch opcode, increment PCR
  758.         2     PCR     R  fetch address, increment PCR
  759.     3   address   R  read from address, add index register to it
  760.         4  address+I* W  write to effective address
  761.  
  762.        Notes: I denotes either index register (X or Y).
  763.  
  764.               * The high byte of the effective address is always zero,
  765.                 i.e. page boundary crossings are not handled.
  766.  
  767.  
  768.   Absolute indexed addressing
  769.  
  770.      Read instructions (LDA, LDX, LDY, EOR, AND, ORA, ADC, SBC, CMP, BIT,
  771.                         LAX, LAE, SHS, NOP)
  772.  
  773.         #   address  R/W description
  774.        --- --------- --- ------------------------------------------
  775.         1     PCR     R  fetch opcode, increment PCR
  776.         2     PCR     R  fetch low byte of address, increment PCR
  777.         3     PCR     R  fetch high byte of address,
  778.                          add index register to low address byte,
  779.              increment PCR
  780.         4  address+I* R  read from effective address,
  781.                          fix the high byte of effective address
  782.         4+ address+I  R  re-read from effective address
  783.  
  784.        Notes: I denotes either index register (X or Y).
  785.  
  786.               * The high byte of the effective address may be invalid
  787.                 at this time, i.e. it may be smaller by $100.
  788.  
  789.               + This cycle will be executed only if the effective address
  790.                 was invalid during cycle #4, i.e. page boundary was crossed.
  791.  
  792.  
  793.      Read-Modify-Write instructions (ASL, LSR, ROL, ROR, INC, DEC,
  794.                                      SLO, SRE, RLA, RRA, ISB, DCP)
  795.  
  796.         #   address  R/W description
  797.        --- --------- --- ------------------------------------------
  798.         1    PCR      R  fetch opcode, increment PCR
  799.         2    PCR      R  fetch low byte of address, increment PCR
  800.         3    PCR      R  fetch high byte of address,
  801.                          add index register X to low address byte,
  802.                  increment PCR
  803.         4  address+X* R  read from effective address,
  804.                          fix the high byte of effective address
  805.         5  address+X  R  re-read from effective address
  806.         6  address+X  W  write the value back to effective address,
  807.                          and do the operation on it
  808.         7  address+X  W  write the new value to effective address
  809.  
  810.        Notes: * The high byte of the effective address may be invalid
  811.                 at this time, i.e. it may be smaller by $100.
  812.  
  813.  
  814.      Write instructions (STA, STX, STY, SHA, SHX, SHY)
  815.  
  816.         #   address  R/W description
  817.        --- --------- --- ------------------------------------------
  818.         1     PCR     R  fetch opcode, increment PCR
  819.         2     PCR     R  fetch low byte of address, increment PCR
  820.         3     PCR     R  fetch high byte of address,
  821.                          add index register to low address byte,
  822.              increment PCR
  823.         4  address+I* R  read from effective address,
  824.                          fix the high byte of effective address
  825.         5  address+I  W  write to effective address
  826.  
  827.        Notes: I denotes either index register (X or Y).
  828.  
  829.               * The high byte of the effective address may be invalid
  830.                 at this time, i.e. it may be smaller by $100. Because
  831.         the processor cannot undo a write to an invalid address,
  832.                 it always reads from the address first.
  833.  
  834.  
  835.   Relative addressing (BCC, BCS, BNE, BEQ, BPL, BMI, BVC, BVS)
  836.  
  837.         #   address  R/W description
  838.        --- --------- --- ---------------------------------------------
  839.         1     PCR     R  fetch opcode, increment PCR
  840.         2     PCR     R  fetch operand, increment PCR
  841.         3     PCR     R  Fetch opcode of next instruction,
  842.                          If branch is taken, add operand to PCL.
  843.              Otherwise increment PCR.
  844.         3+    PCR*    R  Fetch opcode of next instruction.
  845.                          Fix PCH. If it did not change, increment PCR.
  846.         3!    PCR     R  Fetch opcode of next instruction,
  847.              increment PCR.
  848.  
  849.        Notes: * The high byte of Program Counter (PCH) may be invalid
  850.                 at this time, i.e. it may be smaller or bigger by $100.
  851.  
  852.               + If branch is taken, this cycle will be executed.
  853.  
  854.               ! If branch occurs to different page, this cycle will be
  855.                 executed.
  856.  
  857.  
  858.   Indexed indirect addressing
  859.  
  860.      Read instructions (LDA, ORA, EOR, AND, ADC, CMP, SBC, LAX)
  861.  
  862.         #    address   R/W description
  863.        --- ----------- --- ------------------------------------------
  864.         1      PCR      R  fetch opcode, increment PCR
  865.         2      PCR      R  fetch pointer address, add X to it,
  866.                increment PCR
  867.         3      ???      R  internal operation
  868.         4   pointer+X   R  fetch effective address low
  869.         5  pointer+X+1  R  fetch effective address high
  870.         6    address    R  read from effective address
  871.  
  872.        Note: The effective address is always fetched from zero page,
  873.              i.e. the zero page boundary crossing is not handled.
  874.  
  875.      Read-Modify-Write instructions (SLO, SRE, RLA, RRA, ISB, DCP)
  876.  
  877.         #    address   R/W description
  878.        --- ----------- --- ------------------------------------------
  879.         1      PCR      R  fetch opcode, increment PCR
  880.         2      PCR      R  fetch pointer address, add X to it,
  881.                increment PCR
  882.         3      ???      R  internal operation
  883.         4   pointer+X   R  fetch effective address low
  884.         5  pointer+X+1  R  fetch effective address high
  885.         6    address    R  read from effective address
  886.         7    address    W  write the value back to effective address,
  887.                            and do the operation on it
  888.         8    address    W  write the new value to effective address
  889.  
  890.        Note: The effective address is always fetched from zero page,
  891.              i.e. the zero page boundary crossing is not handled.
  892.  
  893.      Write instructions (STA, SAX)
  894.  
  895.         #    address   R/W description
  896.        --- ----------- --- ------------------------------------------
  897.         1      PCR      R  fetch opcode, increment PCR
  898.         2      PCR      R  fetch pointer address, add X to it,
  899.                increment PCR
  900.         3      ???      R  internal operation
  901.         4   pointer+X   R  fetch effective address low
  902.         5  pointer+X+1  R  fetch effective address high
  903.         6    address    W  write to effective address
  904.  
  905.        Note: The effective address is always fetched from zero page,
  906.              i.e. the zero page boundary crossing is not handled.
  907.  
  908.   Indirect indexed addressing
  909.  
  910.      Read instructions (LDA, EOR, AND, ORA, ADC, SBC, CMP)
  911.  
  912.         #    address   R/W description
  913.        --- ----------- --- ------------------------------------------
  914.         1      PCR      R  fetch opcode, increment PCR
  915.         2      PCR      R  fetch pointer address, increment PCR
  916.         3    pointer    R  fetch effective address low
  917.         4   pointer+1   R  fetch effective address high,
  918.                            add Y to low byte of effective address
  919.         5   address+Y*  R  read from effective address,
  920.                            fix high byte of effective address
  921.         5+  address+Y   R  read from effective address
  922.  
  923.        Notes: The effective address is always fetched from zero page,
  924.               i.e. the zero page boundary crossing is not handled.
  925.  
  926.               * The high byte of the effective address may be invalid
  927.                 at this time, i.e. it may be smaller by $100.
  928.  
  929.               + This cycle will be executed only if the effective address
  930.                 was invalid during cycle #5, i.e. page boundary was crossed.
  931.  
  932.  
  933.      Read-Modify-Write instructions (SLO, SRE, RLA, RRA, ISB, DCP)
  934.  
  935.         #    address   R/W description
  936.        --- ----------- --- ------------------------------------------
  937.         1      PCR      R  fetch opcode, increment PCR
  938.         2      PCR      R  fetch pointer address, increment PCR
  939.         3    pointer    R  fetch effective address low
  940.         4   pointer+1   R  fetch effective address high,
  941.                            add Y to low byte of effective address
  942.         5   address+Y*  R  read from effective address,
  943.                            fix high byte of effective address
  944.         6   address+Y   W  write to effective address
  945.         7   address+Y   W  write the value back to effective address,
  946.                            and do the operation on it
  947.         8   address+Y   W  write the new value to effective address
  948.  
  949.        Notes: The effective address is always fetched from zero page,
  950.               i.e. the zero page boundary crossing is not handled.
  951.  
  952.               * The high byte of the effective address may be invalid
  953.                 at this time, i.e. it may be smaller by $100.
  954.  
  955.  
  956.      Write instructions (STA, SHA)
  957.  
  958.         #    address   R/W description
  959.        --- ----------- --- ------------------------------------------
  960.         1      PCR      R  fetch opcode, increment PCR
  961.         2      PCR      R  fetch pointer address, increment PCR
  962.         3    pointer    R  fetch effective address low
  963.         4   pointer+1   R  fetch effective address high,
  964.                            add Y to low byte of effective address
  965.         5   address+Y*  R  read from effective address,
  966.                            fix high byte of effective address
  967.         6   address+Y   W  write to effective address
  968.  
  969.        Notes: The effective address is always fetched from zero page,
  970.               i.e. the zero page boundary crossing is not handled.
  971.  
  972.               * The high byte of the effective address may be invalid
  973.                 at this time, i.e. it may be smaller by $100.
  974.  
  975.  
  976.   Absolute indirect addressing (JMP)
  977.  
  978.         #   address  R/W description
  979.        --- --------- --- ------------------------------------------
  980.         1     PCR     R  fetch opcode, increment PCR
  981.         2     PCR     R  fetch pointer address low, increment PCR
  982.         3     PCR     R  fetch pointer address high, increment PCR
  983.         4   pointer   R  fetch low address to latch
  984.         5  pointer+1* R  fetch PCH, copy latch to PCL
  985.  
  986.        Note: * The PCH will always be fetched from the same page
  987.                than PCL, i.e. page boundary crossing is not handled.
  988.  
  989.  
  990.  
  991.                 MEMORY MANAGEMENT
  992.  
  993.        normal                                                   ultimax
  994.         1111    101x    011x    001x    1110    0100    1100    xx01
  995.                 1000            00x0
  996. 10000
  997. ------------------------------------------------------------------------
  998.  F000
  999.         Kernal  RAM     Kernal  RAM     Kernal  Kernal  Kernal  module
  1000.  E000
  1001. ------------------------------------------------------------------------
  1002.  D000   I/O     I/O**   I/O     RAM     I/O     I/O     I/O     I/O
  1003. ------------------------------------------------------------------------
  1004.  C000   RAM     RAM     RAM     RAM     RAM     RAM     RAM      -
  1005. ------------------------------------------------------------------------
  1006.  B000
  1007.         BASIC   RAM     RAM     RAM     BASIC   module  module   -
  1008.  A000
  1009. ------------------------------------------------------------------------
  1010.  9000
  1011.         RAM     RAM     RAM     RAM     module  RAM     module  module
  1012.  8000
  1013. ------------------------------------------------------------------------
  1014.  7000
  1015.  
  1016.  6000
  1017.         RAM     RAM     RAM     RAM     RAM     RAM     RAM      -
  1018.  5000
  1019.  
  1020.  4000
  1021. ------------------------------------------------------------------------
  1022.  3000    
  1023.  
  1024.  2000
  1025.         RAM     RAM     RAM     RAM     RAM     RAM     RAM      RAM    
  1026.  1000
  1027.     
  1028.  0000
  1029. ------------------------------------------------------------------------
  1030.  
  1031.                 **) Chargen not accessible by the CPU
  1032.  
  1033.  
  1034.                 AUTOSTART CODE
  1035.  
  1036.   If memory places $8004 to $8008 contain 'CBM80' (C3 C2 CD 38 30),
  1037.   the RESET routine jumps to ($8000) and the default NMI handler jumps to
  1038.   ($8002).
  1039.  
  1040.  
  1041.                 HOW REAL PROGRAMMERS ACKNOWLEDGE INTERRUPTS
  1042.  
  1043.   With RMW instructions:
  1044.  
  1045.         ; beginning of combined raster/timer interrupt routine
  1046.         LSR $D019       ; clear VIC interrupts, read raster interrupt flag to C
  1047.         BCS raster      ; jump if VIC caused an interrupt
  1048.         ...             ; timer interrupt routine
  1049.  
  1050.         Operational diagram of LSR $D019:
  1051.  
  1052.           #  data  address  R/W  
  1053.          --- ----  -------  ---  ---------------------------------
  1054.           1   4E     PCR     R   fetch opcode
  1055.           2   19    PCR+1    R   fetch address low
  1056.           3   D0    PCR+2    R   fetch address high
  1057.           4   xx    $D019    R   read memory
  1058.           5   xx    $D019    W   write the value back, rotate right
  1059.           6  xx/2   $D019    W   write the new value back
  1060.  
  1061.     The 5th cycle acknowledges the interrupt by writing the same
  1062.     value back. If only raster interrupts are used, the 6th cycle
  1063.     has no effect on the VIC.
  1064.  
  1065.  
  1066.   With indexed addressing:
  1067.  
  1068.         ; acknowledge interrupts to both CIAs
  1069.         LDX #$10
  1070.         LDA $DCFD,X
  1071.  
  1072.         Operational diagram of LDA $DCFD,X:
  1073.  
  1074.           #  data  address  R/W  description
  1075.          --- ----  -------  ---  ---------------------------------
  1076.           1   BD     PCR     R   fetch opcode
  1077.           2   FD    PCR+1    R   fetch address low
  1078.           3   DC    PCR+2    R   fetch address high, add X to address low
  1079.           4   xx    $DC0D    R   read from address, fix high byte of address
  1080.           5   yy    $DD0D    R   read from right address
  1081.  
  1082.  
  1083.         ; acknowledge interrupts to CIA 2
  1084.         LDX #$10
  1085.         STA $DDFD,X
  1086.  
  1087.         Operational diagram of STA $DDFD,X:
  1088.  
  1089.           #  data  address  R/W  description
  1090.          --- ----  -------  ---  ---------------------------------
  1091.           1   9D     PCR     R   fetch opcode
  1092.           2   FD    PCR+1    R   fetch address low
  1093.           3   DC    PCR+2    R   fetch address high, add X to address low
  1094.           4   xx    $DD0D    R   read from address, fix high byte of address
  1095.           5   ac    $DE0D    W   write to right address
  1096.  
  1097.  
  1098.   With branch instructions:
  1099.  
  1100.         ; acknowledge interrupts to CIA 2
  1101.                 LDA #$00  ; clear N flag
  1102.                 JMP $DD0A
  1103.         DD0A    BPL $DC9D ; branch
  1104.         DC9D    BRK       ; return
  1105.  
  1106.         You need the following preparations to initialize the CIA registers:
  1107.  
  1108.                 LDA #$91  ; argument of BPL
  1109.                 STA $DD0B
  1110.                 LDA #$10  ; BPL
  1111.                 STA $DD0A
  1112.                 STA $DD08 ; load the ToD values from the latches
  1113.                 LDA $DD0B ; jam the ToD display
  1114.                 LDA #$7F
  1115.                 STA $DC0D ; assure that $DC0D is $00
  1116.  
  1117.         Operational diagram of BPL $DC9D:
  1118.  
  1119.           #  data  address  R/W  description
  1120.          --- ----  -------  ---  ---------------------------------
  1121.           1   10    $DD0A    R   fetch opcode
  1122.           2   91    $DD0B    R   fetch argument
  1123.           3   xx    $DD0C    R   fetch opcode, add argument to PCL
  1124.           4   yy    $DD9D    R   fetch opcode, fix PCH
  1125.         ( 5   00    $DC9D    R   fetch opcode )
  1126.  
  1127.  
  1128.         ; acknowledge interrupts to CIA 1
  1129.                 LDA #$00  ; clear N flag
  1130.                 JMP $DCFA
  1131.         DCFA    BPL $DD0D
  1132.         DD0D    BRK
  1133.  
  1134.         ; Again you need to set the ToD registers of CIA 1 and the
  1135.         ; Interrupt Control Register of CIA 2 first.
  1136.  
  1137.         Operational diagram of BPL $DD0D:
  1138.  
  1139.           #  data  address  R/W  description
  1140.          --- ----  -------  ---  ---------------------------------
  1141.           1   10    $DCFA    R   fetch opcode
  1142.           2   11    $DCFB    R   fetch argument
  1143.           3   xx    $DCFC    R   fetch opcode, add argument to PCL
  1144.           4   yy    $DC0D    R   fetch opcode, fix PCH
  1145.         ( 5   00    $DD0D    R   fetch opcode )
  1146.  
  1147.  
  1148.         ; acknowledge interrupts to CIA 2 automagically
  1149.                 ; preparations
  1150.                 LDA #$7F
  1151.                 STA $DD0D       ; disable CIA 2's all interrupt sources
  1152.                 LDA $DD0E
  1153.                 AND #$BE        ; ensure that $DD0C remains constant
  1154.                 STA $DD0E       ; and stop the timer
  1155.                 LDA #$FD
  1156.                 STA $DD0C       ; parameter of BPL
  1157.                 LDA #$10
  1158.                 STA $DD0B       ; BPL
  1159.                 LDA #$40
  1160.                 STA $DD0A       ; RTI/parameter of LSR
  1161.                 LDA #$46
  1162.                 STA $DD09       ; LSR
  1163.                 STA $DD08       ; load the ToD values from the latches
  1164.                 LDA $DD0B       ; jam the ToD display
  1165.                 LDA #$09
  1166.                 STA $0318
  1167.                 LDA #$DD
  1168.                 STA $0319       ; change NMI vector to $DD09
  1169.                 LDA #$FF        ; Try changing this instruction's operand
  1170.                 STA $DD05       ; (see comment below).
  1171.                 LDA #$FF
  1172.                 STA $DD04       ; set interrupt frequency to 1/65536 cycles
  1173.                 LDA $DD0E
  1174.                 AND #$80
  1175.                 ORA #$11
  1176.                 LDX #$81
  1177.                 STX $DD0D       ; enable timer interrupt
  1178.                 STA $DD0E       ; start timer
  1179.  
  1180.                 LDA #$00        ; To see that the interrupts really occur,
  1181.                 STA $D011       ; use something like this and see how
  1182.         LOOP    DEC $D020       ; changing the byte loaded to $DD05 from
  1183.                 BNE LOOP        ; #$FF to #$0F changes the image.
  1184.  
  1185.         When an NMI occurs, the processor jumps to Kernal code, which jumps to
  1186.         ($0318), which points to the following routine:
  1187.  
  1188.         DD09    LSR $40         ; clear N flag
  1189.                 BPL $DD0A       ; Note: $DD0A contains RTI.
  1190.  
  1191.         Operational diagram of BPL $DD0A:
  1192.  
  1193.           #  data  address  R/W  description
  1194.          --- ----  -------  ---  ---------------------------------
  1195.           1   10    $DD0B    R   fetch opcode
  1196.           2   11    $DD0C    R   fetch argument
  1197.           3   xx    $DD0D    R   fetch opcode, add argument to PCL
  1198.           4   40    $DD0A    R   fetch opcode, (fix PCH)
  1199.  
  1200.  
  1201.   With RTI:
  1202.  
  1203.         ; the fastest possible interrupt handler in the 6500 family
  1204.                 ; preparations
  1205.         SEI
  1206.         LDA $01        ; disable ROM and enable I/O
  1207.         AND #$FD
  1208.         ORA #$05
  1209.         STA $01
  1210.                 LDA #$7F
  1211.                 STA $DD0D       ; disable CIA 2's all interrupt sources
  1212.                 LDA $DD0E
  1213.                 AND #$BE        ; ensure that $DD0C remains constant
  1214.                 STA $DD0E       ; and stop the timer
  1215.                 LDA #$40
  1216.                 STA $DD0C       ; store RTI to $DD0C
  1217.                 LDA #$0C
  1218.                 STA $FFFA
  1219.                 LDA #$DD
  1220.                 STA $FFFB       ; change NMI vector to $DD0C
  1221.                 LDA #$FF        ; Try changing this instruction's operand
  1222.                 STA $DD05       ; (see comment below).
  1223.                 LDA #$FF
  1224.                 STA $DD04       ; set interrupt frequency to 1/65536 cycles
  1225.                 LDA $DD0E
  1226.                 AND #$80
  1227.                 ORA #$11
  1228.                 LDX #$81
  1229.                 STX $DD0D       ; enable timer interrupt
  1230.                 STA $DD0E       ; start timer
  1231.  
  1232.                 LDA #$00        ; To see that the interrupts really occur,
  1233.                 STA $D011       ; use something like this and see how
  1234.         LOOP    DEC $D020       ; changing the byte loaded to $DD05 from
  1235.                 BNE LOOP        ; #$FF to #$0F changes the image.
  1236.  
  1237.         When an NMI occurs, the processor jumps to Kernal code, which jumps to
  1238.         ($0318), which points to the following routine:
  1239.  
  1240.         DD0C    RTI
  1241.  
  1242.         How on earth can this clear the interrupts? Remember, the processor
  1243.         always fetches two successive bytes for each instruction.
  1244.  
  1245.         A little more practical version of this is redirecting the NMI (or IRQ)
  1246.         to your own routine, whose last instruction is JMP $DD0C or JMP $DC0C.
  1247.         If you want to confuse more, change the 0 in the address to a
  1248.         hexadecimal digit different from the one you used when writing the RTI.
  1249.  
  1250.         Or you can combine the latter two methods:
  1251.  
  1252.         DD09    LSR $xx         ; xx is any appropriate BCD value 00-59.
  1253.                 BPL $DCFC
  1254.         DCFC    RTI
  1255.  
  1256.         This example acknowledges interrupts to both CIAs.
  1257.  
  1258.  
  1259.    If you want to confuse the examiners of your code, you can use any of
  1260.  these techniques. Although these examples use no undefined opcodes, they do
  1261.  not run correctly on CMOS processors. However, the RTI example should run on
  1262.  65C02 and 65C816, and the latter branch instruction example might work as
  1263.  well.
  1264.  
  1265.    The RMW instruction method has been used in some demos, others were
  1266.  developed by Marko M"akel"a. His favourite is the automagical RTI method,
  1267.  although it does not have any practical applications, except for some
  1268.  time dependent data decryption routines for very complicated copy protections.
  1269.  
  1270.  
  1271.  
  1272.                 MAKING USE OF THE I/O REGISTERS
  1273.  
  1274.    If you are making a resident program and want to make as invisible to the
  1275.  system as possible, probably the best method is keeping most of your code
  1276.  under the I/O area (in the RAM at $D000-$DFFF). You need only a short routine
  1277.  in the normally visible RAM that pushes the current value of the processor's
  1278.  I/O register $01 on stack, switches I/O and ROMs out and jumps to this area.
  1279.  Returning from the $D000-$DFFF area is easy even without any routine in the
  1280.  normally visible RAM area. Just write a RTS to an I/O register and return
  1281.  through it.
  1282.  
  1283.    But what if your program needs to use I/O? And how can you write the RTS
  1284.  to an I/O register while the I/O area is switched off? You need a swap area
  1285.  for your program in normally visible memory. The first thing your routine at
  1286.  $D000-$DFFF does is copying the I/O routines (or the whole program) to
  1287.  normally visible memory, swapping the bytes. For instance, if your I/O
  1288.  routines are initially at $D200-$D3FF, exchange the bytes at $D200-$D3FF
  1289.  with the contents of $C000-$C1FF. Now you can call the I/O routines from
  1290.  your routine at $D000-$DFFF, and the I/O routines can switch the I/O area
  1291.  temporarily on to access the I/O circuitry. And right before exiting your
  1292.  program at $D000-$DFFF swaps the old contents of that I/O routine area in,
  1293.  e.g. exchanges the memory areas $D200-$D3FF and $C000-$C1FF again.
  1294.  
  1295.    What I/O registers can you use for the RTS? There are two alternatives:
  1296.  8-bit VIC sprite registers or CIA serial port register. The CIA register is
  1297.  usually better, as changing the VIC registers might change the screen layout.
  1298.  However, also the SP register has some drawbacks: If the machine's CNT1 and
  1299.  CNT2 lines are connected to a frequency source, you must stop either CIA's
  1300.  Timer A to use the SP register method. Normally the 1st CIA's Timer A is the
  1301.  main hardware interrupt source. And if you use the Kernal's RS232, you cannot
  1302.  stop the 2nd CIA's Timer A either. Also, if you don't want to lose any CIA
  1303.  interrupts, remember that the RTS at SP register causes also the Interrupt
  1304.  Control Register to be read.
  1305.  
  1306.    Also keep in mind that the user could press RESTORE while the Kernal ROM
  1307.  and I/O areas are disabled. You could write your own NMI handler (using
  1308.  the NMI vector at $FFFA), but a fast loader that uses very tight timing
  1309.  would still stop working if the user pressed RESTORE in wrong time. So, to
  1310.  make a robust program, you have to disable NMI interrupts. But how is this
  1311.  possible? They are Non-Maskable after all. The NMI interrupt is
  1312.  edge-sensitive, the processor jumps to NMI handler only when the -NMI line
  1313.  drops from +5V to ground. Just cause a NMI with CIA2's timer, but don't
  1314.  read the Interrupt Control register. If you need to read $DD0D in your
  1315.  program, you must add a NMI handler just in case the user presses RESTORE.
  1316.  And don't forget to raise the -NMI line upon exiting the program. This can
  1317.  be done automatically by the latter two of the three following examples.
  1318.  
  1319.  
  1320.         ; Returning via VIC sprite 7 X coordinate register
  1321.  
  1322.         Initialization:   ; This is executed when I/O is switched on
  1323.                 LDA #$60
  1324.                 STA $D015 ; Write RTS to VIC register $15.
  1325.  
  1326.         Exiting:          ; NOTE: This procedure must start at VIC register
  1327.                           ; $12. You have multiple alternatives, as the VIC
  1328.                           ; appears in memory at $D000+$40*n, where $0<=n<=$F.
  1329.  
  1330.                 PLA       ; Pull the saved 6510 I/O register state from stack
  1331.                 STA $01   ; Restore original memory bank configuration
  1332.                           ; Now the processor fetches the RTS command from the
  1333.                           ; VIC register $15.
  1334.  
  1335.  
  1336.         ; Returning via CIA 2's SP register (assuming that CNT2 is stable)
  1337.  
  1338.         Initialization:   ; This is executed when I/O is switched on
  1339.                 LDA $DD0E ; CIA 2's Control Register A
  1340.                 AND #$BF  ; Set Serial Port to input
  1341.                 STA $DD0E ; (make the SP register to act as a memory place)
  1342.                 LDA #$60
  1343.                 STA $DD0C ; Write RTS to CIA 2 register $C.
  1344.  
  1345.         Exiting:          ; NOTE: This procedure must start at CIA 2 register
  1346.                           ; $9. As the CIA 2 appears in memory at $DD00+$10*n,
  1347.                           ; where 0<=n<=$F, you have sixteen alternatives.
  1348.                 PLA
  1349.                 STA $01   ; Restore original memory bank configuration
  1350.                           ; Now the processor fetches the RTS command from
  1351.                           ; the CIA 2 register $C.
  1352.  
  1353.  
  1354.         ; Returning via CIA 2's SP register, stopping the Timer A
  1355.         ; and forcing SP2 and CNT2 to output
  1356.  
  1357.         Initialization:   ; This is executed when I/O is switched on
  1358.                 LDA $DD0E ; CIA 2's Control Register A
  1359.                 AND #$FE  ; Stop Timer A
  1360.                 ORA #$40  ; Set Serial Port to output
  1361.                 STA $DD0E ; (make the SP register to act as a memory place)
  1362.                 LDA #$60
  1363.                 STA $DD0C ; Write RTS to CIA register $C.
  1364.  
  1365.         Exiting:          ; NOTE: This procedure must start at CIA 2 register
  1366.                           ; $9. As the CIA 2 appears in memory at $DD00+$10*n,
  1367.                           ; where, 0<=n<=$F, you have sixteen alternatives.
  1368.                 PLA
  1369.                 STA $01   ; Restore original memory bank configuration
  1370.                           ; Now the processor fetches the RTS command from
  1371.                           ; the CIA 2 register $C.
  1372.  
  1373.         
  1374.    For instance, if you want to make a highly compatible fast loader, make
  1375.  the ILOAD vector ($0330) point to the beginning of the stack area. Remember
  1376.  that the BASIC interpreter uses the first bytes of stack while converting
  1377.  numbers to text. A good address is $0120. Robust programs practically never
  1378.  use so much stack that it could corrupt this routine. Usually only crunched
  1379.  programs (demos and alike) use all stack in the decompression phase. They
  1380.  also make use of the $D000-$DFFF area.
  1381.  
  1382.    This stack routine will jump to your routine at $D000-$DFFF, as described
  1383.  above. For performance's sake, copy the whole byte transfer loop to the swap
  1384.  area, e.g. $C000-$C1FF, and call that subroutine after doing the preliminary
  1385.  work. But what about files that load over $C000-$C1FF? Wouldn't that destroy
  1386.  the transfer loop and jam the machine? Not necessarily. If you copy those
  1387.  bytes to your swap area at $D000-$DFFF, they will be loaded properly, as
  1388.  your program restores the original $C000-$C1FF area.
  1389.  
  1390.    If you want to make your program user-friendly, put a vector initialization
  1391.  routine to the stack area as well, so that the user can restore the fast
  1392.  loader by issuing a SYS command, rather than loading it each time he has
  1393.  pressed STOP & RESTORE or RESET.
  1394.  
  1395.  
  1396.  
  1397.                 NOTES
  1398.  
  1399.  See MCS 6500 Microcomputer Family Programming Manual for more information.
  1400.  There is also a table showing functional description and timing for complete
  1401.  6510 instruction set on C=Hacking magazine issue 1/92 (available via FTP at
  1402.  ccosun.caltech.edu:/pub/rknop/hacking.mag/ and
  1403.  nic.funet.fi:/pub/cbm/c=hacking/).
  1404.  
  1405.  
  1406.  References:
  1407.   C64 Memory Maps       C64 Programmer's Reference Guide pp. 262-267
  1408.   6510 Block Diagram    C64 Programmer's Reference Guide  p. 404
  1409.   Instruction Set       C64 Programmer's Reference Guide pp. 416-417
  1410.                         C=Hacking Volume 1, issue #1, 1/92
  1411.                         C=Lehti magazine 4/87
  1412. =============================================================================
  1413.  
  1414.