OnceReduction: Optimize idempotent functions

[kripken]

OnceReduction finds functions that execute once, then removes later
calls to them,

initJavaClass();
initJavaClass();

=>

initJavaClass();
; // optimized out

This PR makes it do the same for idempotent-marked calls.

So far this only handles the simple case of no params or results.

[tlively]

I wonder how complicated it would be to do a proper interprocedural control flow analysis that would let us find all idempotent operations (e.g. idempotent function calls, sets of globals that are only ever set to a single value, etc.) dominated by previous copies of the same operation. That would let us uniformly optimize all the idempotent operations we could want without special-casing "once" functions or being limited to single basic blocks.

[tlively]

As a drive-by, it might be nice to rename this to onceFuncGlobals, since the values are globals.

[kripken]

Good idea, done.

[tlively]

It's not clear to me that we should allow removing calls to idempotent functions when there are arbitrary side effects between the calls and their preceding calls. For example, gcc's pure annotation does not allow optimization when there are intervening side effects.

[kripken]

I commented on the discussion to get feedback:

#7574 (comment)

[kripken]

If we can't optimize like this, then the OnceReduction pass may not be the right place to do this, as "once" functions can be optimized in this way.

[kripken]

I added a comment to clarify that in the linked discussion we are leaning towards allowing this optimization.

(We can reconsider later if this is a problem, and perhaps add a parameter to this intrinsic, as both use cases might matter.)

[kripken]

I wonder how complicated it would be to do a proper interprocedural control flow analysis that would let us find all idempotent operations (e.g. idempotent function calls, sets of globals that are only ever set to a single value, etc.) dominated by previous copies of the same operation. That would let us uniformly optimize all the idempotent operations we could want without special-casing "once" functions or being limited to single basic blocks.

OnceReduction already does that: it uses a DomTree to find all dominated second calls, and removes them.

Maybe you're thinking of LocalCSE which is limited to a single basic block? It is worth improving that one.