GeezerVison

Note: this doesn't yet support cache effects in the macro definition itself (e.g. macro(X) = counter/1 + FOO + BAR + unused/2). That seems something for a follow-up (we don't even have a use case for the current thing yet).

Details

(From two original commits that were since merged.)

Super-instructions can now have cache effects.

To do this I mostly just had to move the cache effects code into
Instr*.write_body(), reducing the responsibilities of Instr*.write().
(I also had to fiddle a bit with indents.)

For macros the same approach would almost work, except that
next_instr might point in the middle of the cache when we encounter
DEOPT_IF() or ERROR_IF() in a second or further component.
I have to think more about that.

NOTES:

• There is no test example yet (I manually tested it with a fake new
  super-instruction).
• The cache-related generated code is in different place.
  This shouldn't matter.

Macro instructions can now also have cache effects.

We pass the initial cache offset into write_body().

This is a little fiddly because everything is different
for super-instructions vs macros:

• For super, cache_adjust is always zero because we
  bump next_instr after each op.
• For macro, cache_adjust accumulates previous cache offsets,
  and we bump next_instr at the end.

Also, I had to move the bump of next_instr back into Instr*.write().
It is better placed there anyway because that function avoids the bump
if the C code already ends in a goto, return or DISPATCH*() call.
(The previous commit emitted one unreachable bump, which is now fixed.)

Tested manually.

NOTES

There's more refactoring coming.

Also included:

• Fix dedent of comments in to_text()
• Flatten InstDef
• Improve CLI help output
• Other refactoring (quite a bit, sorry)

• Issue: Generate the interpreter #98831