For every xLOAD n, find all local variable slots that are aliases of n using an AliasingAnalyzer and change the instruction to xLOAD m where m is the smallest alias. This leaves behind potentially stale xSTORE n instructions, which are then eliminated by eliminateStaleStoresAndRewriteSomeIntrinsics.

When a POP instruction has a single producer, remove the POP and eliminate the producer by bubbling up the POPs. For example, given ILOAD 1; ILOAD 2; IADD; POP we first eliminate the POP, then the IADD, then its inputs, so the entire sequence goes away. If a producer cannot be eliminated (need to keep side-effects), a POP is inserted.

A special case eliminates the creation of unused objects with side-effect-free constructors: NEW scala/Tuple1; DUP; ALOAD 0; INVOKESPECIAL scala/Tuple1.<init>; POP The POP has a single producer (the DUP), it's easy to eliminate these two. A special case is needed to eliminate the INVOKESPECIAL and NEW.

Returns (pushPopChanged, castAdded, nullCheckAdded)

Eliminate xSTORE instructions that have no consumer. If the instruction can be completely eliminated, it is replaced by a POP. The eliminatePushPop cleans up unnecessary POPs.

Also rewrites some intrinsics (done here because a ProdCons analysis is available):

• ClassTag(classOf[X]).newArray is rewritten to new Array[X]

Finally there's an interesting special case that complements the inliner heuristics. After the rewrite above, if the new Array[X] is used in a ScalaRuntime.array_apply/update call, inline that method. These methods have a big pattern match for all primitive array types, and we only inline them if we statically know the array type. In this case, all the non-matching branches are later eliminated by eliminateRedundantCastsAndRewriteSomeIntrinsics.

Note that an ASOTRE can not always be eliminated: it removes a reference to the object that is currently stored in that local, which potentially frees it for GC (scala/bug#5313). Therefore we replace such stores by POP; ACONST_NULL; ASTORE x - except if the store precedes an xRETURN, in which case it can be removed.

Returns (staleStoreRemoved, intrinsicRewritten, callInlined).

Remove xSTORE n; xLOAD n pairs if

• the local variable n is not used anywhere else in the method (1), and
• there are no executable instructions and no live labels (jump targets) between the two (2)

Note: store-load pairs that cannot be eliminated could be replaced by DUP; xSTORE n, but that's just cosmetic and doesn't help for anything.

(1) This could be made more precise by running a prodCons analysis and checking that the load is the only user of the store. Then we could eliminate the pair even if the variable is live (except for ASTORE, scala/bug#5313). Not needing an analyzer is more efficient, and catches most cases.

(2) The implementation uses a conservative estimation for liveness (if some instruction uses local n, then n is considered live in the entire method). In return, it doesn't need to run an Analyzer on the method, making it more efficient.

This method also removes ACONST_NULL; ASTORE n if the local n is not live. This pattern is introduced by eliminateStaleStoresAndRewriteSomeIntrinsics.

The implementation is a little tricky to support the following case: ISTORE 1; ISTORE 2; ILOAD 2; ACONST_NULL; ASTORE 3; ILOAD 1 The outer store-load pair can be removed if two the inner pairs can be.