While not as universally useful as a single-byte instruction,

does the same thing...

You kind of need a "clc" as well then, and then might as well just use the "clc" alone. There are a lot of two byte options. A branch-0 is maybe a decent true nop, that doesn't affect flags, in two bytes.

Even if there's no true "nop" though, the utility of having one more nearly-nop instruction is probably high enough to make it worthwhile.

Good point! or, and, eor then. Still, flags are modified.

Branch *-2 does not consume a consistent number of clock cycles depending upon page boundaries.

We may also remove ORA (and use AND and EOR instead), ROL (use ADC), INC (use ADC), BNE (use BEQ and JMP), and BCS.

_________________
my blog about processors

The ROL instruction is probably easiest to implement as an ADC internally any way, so no need for both.

If you're feeling enthusiastic, remove ORA and AND and EOR and replace them with a single NAND...

Neil

_________________
Want to design a PCB for your project? I strongly recommend KiCad. Its free, its multiplatform, and its easy to learn!
Also, I maintain KiCad libraries of Retro Computing and Arduino components you might find useful.

Back in the day I sprinkled NOP instructions in my code during debugging to allow patching in place without the need to reassemble. That saved time as the NOPs allow for keeping branch offsets the same while inserting or removing instructions. That's probably less relevant with modern hardware, but they're also useful for adjusting timing as well. So I think a do nothing instruction of some sort is needed.

George's idea of BRA 0 as a NOP replacement would certainly be a possibility, but at two bytes it might be a little awkward during a patch in place scenario.


That would work and fits my Turing Tarpit Challenge, and I kinda like it. But it doesn't meet the challenge in this thread, and might be a tad rough for many people.

ooooh, this is a pretty neat topic!

hmm, am i missing something? to me that adds up to 18 instructions (22 total opcodes)
also personally i like counting opcodes more than "instructions" as it seems less ambiguous.

anyways you could replace INC A with ADC # since it has the same function, but can also decrement.
personally I would drop JMP (abs) and NOP, i just don't find them that useful
and do you really need both types of branches (set and clear)? couldn't you make do with just BCS and BEQ, and then simulate the function of BCC and BNE via a macro or by reordering code?

that would bring the total down to 18 opcodes:

you could get it down to 16 opcodes if you cut the indirect LDA/STA instructions.

hmm, thinking about it a bit more... technically LDA # and ADC # aren't needed either. assuming the code is located in ROM immediate values will also be in ROM inlined with the code, therefore you could simply put those values somewhere else in the ROM and use absolute addressing modes to get them.

basically, this:

is functionally the same as this:

therefore immediate addressing modes can be cut if an absolute version already exists.

anyways i really doubt you could get all the way down to 8 opcodes without severely limiting the CPU's functionality (and basically turning it into a slightly more fancy turing machine).
but 32 seems like it would be perfect, as that gives you enough opcodes to re-add some useful stuff.
example that i quickly threw together:

sadly (zp),x doesn't exist. that would've been useful.

This is intriguing to me. I ran across this topic some time ago, but now I'm suddenly interested.

I've been looking at One-Instruction Computers, something from Wikipedia. A common one is "subleq" which grabs, subtracts, stores, then branches. Apparently it's "Turing-Complete"?

Anyways, here's my little list, though I haven't tested it all myself to see if it would be enough or not. I am choosing immediate addressing for nearly all instructions with the idea that you can use self-manipulating code to achieve other addressing modes.



If you use BMI/BPL instead of BCC/BCS you don't need a carry flag necessarily. It would act more like BIT, checking bit #7 to branch or not branch.

I think CMP isn't absolutely needed if you have SBC. And somewhere above it was suggested to simply use NAND instead of AND, ORA, and EOR.

I saw someone else saying ADC #$00 would be a good replacement for NOP. That's clever

I think the original purpose was to have this still *useful* but I wonder if you could sorta replicate that "subleq" instruction using only LDA, SBC, STA, and BMI.

Interesting mind game. Thank you!

Chad

ROR might be of more use than ROL (which is just adding the accumulator to itself).

Neil

I didn't see your reply earlier, but I was counting all variations of an instruction as a single instruction. So LDA immediate and LDA (ZP) count as one instruction, but obviously more than one opcode. The same for STA, JMP and JSR. You're right that you can drop INC, but I kept it because I was trying to emulate the PDP-8.



That's a really spartan set of instructions. Now go over to my Turing Tarpit thread in programming and write a program using that subset!


Good point.

If you're feeling particularly masochistic, consider that ORA and EOR can be synthesized with the use of AND and ADC/SBC, SBC can be substituted by twos-complementing the subtrahend and using ADC, and CMP is just an SBC that doesn't save the result...

Removed by author

6502 has a fixed depth hardware stack, just like low-end PICs, except that it is bigger. If you reserve all of page 1 for the stack, you don't need to initialize the stack pointer. It will start at a random position, and just wrap around when it reaches the page boundary.

_________________
http://WilsonMinesCo.com/ lots of 6502 resources
The "second front page" is http://wilsonminesco.com/links.html .
What's an additional VIA among friends, anyhow?