gh-114058: Foundations of the Tier2 redundancy eliminator

[Fidget-Spinner]

This sets up the tier 2 optimizer's redundancy eliminator foundations.

It does the following:

• Aliasing information for types (not on all expressions though, that is too expensive)
• Basic Type propagation
• Basic Guard elimination

It's basically a port of #114059 over using Mark's DSL. Constant propagation and a lot of type propagation rules torn out, for the sake of simpler code for now. We can easily add more later. I just want to get the foundations in.

I expect no speedups for this, as for simpler reviewing, most of the code is torn out. However, I believe that #114059 already shows this approach has potential for speedups.

• Issue: Tier 2 optimizer's abstract interpreter #114058

[markshannon]

This looks much closer to what I think we need. Thanks.

What's the API for _Py_UOpsSymType? It isn't clear what's internal and what's API.

[markshannon]

You can use much the same layout as an actual frame and put the locals and stack at the end:

 ... _Py_UOpsSymType **stack_pointer; _Py_UOpsSymType *localsplus[1]} 

[Fidget-Spinner]

I initially did that, but this new layout is easier for inlining, because it actually models the state if all frames were to be inlined. So it makes things like calculating the new locals offset easier.

[markshannon]

But we aren't inlining yet, and we might choose a different approach. Making it a single struct would make memory management simpler.

[Fidget-Spinner]

Right now making it a single struct would make memory management a little more complex, because my "frames" are just an array of static sized structs. Their localsplus is just accessing a giant pool. frame->prev is just index--. It's all rather clean. And I just need to manage memory once instead of for 7 giant frames.

[markshannon]

Ideally, we won't be doing any allocations, just reusing a buffer on the thread-state. But's that future PR.
But we still need to manage the memory within that buffer, and monolithic frames will make that simpler.
This should be fine for now, though.

[markshannon]

How hard would it be to change the API to take PyTypeObject * for the types in the API? It would make it easier to use.

[Fidget-Spinner]

How hard would it be to change the API to take PyTypeObject * for the types in the API? It would make it easier to use.

Quite possible. I can just convert to the internal representation internally. (The representation is just to save space, and support unions in the future).

The only thing is there are some "types" that cant be represented using pytype object. In that case I will special case them.

[markshannon]

The only thing is there are some "types" that cant be represented using pytype object. In that case I will special case them.

It is probably best to add those cases to the API.
For example if you have "not NULL" or "NULL" as nodes in the lattice, then adding a new/set_null and new/set_not_null API would make sense.

[markshannon]

I don't like macros that assume context, and we rarely (maybe never) want to set the oparg or operand.

Suggested change

	#defineREPLACE_OP(op, arg, oper) \
	#defineREPLACE_OP(INST, OP) (INST)->opcode = (OP)

[Fidget-Spinner]

We will need operand once we start burning in _LOAD_CONST_INLINE and friends.

[markshannon]

Has this changed, or has it just moved?

[Fidget-Spinner]

I did not change it. It just moved.

[markshannon]

Why do you need to check PyErr_Occurred()? uop_redundancy_eliminator should not be returning -1 unless an error has occurred.

[Fidget-Spinner]

In the old code, constant propagation could raise MemoryError.

[markshannon]

Looks good now.