Optimizer: improve the load-copy-to-borrow optimization and implement it in swift

[eeckstein]

The optimization replaces a load [copy] with a load_borrow if possible.

  %1 = load [copy] %0
  // no writes to %0
  destroy_value %1

->

  %1 = load_borrow %0
  // no writes to %0
  end_borrow %1

The new implementation uses alias-analysis (instead of a simple def-use walk), which is much more powerful.
Also, implement load-borrow-immutability checkin in the swift verifier.

rdar://115315849

[eeckstein]

@swift-ci test

[eeckstein]

@swift-ci benchmark

[eeckstein]

@swift-ci test

[eeckstein]

@swift-ci test macos

[nate-chandler]

LGTM, modulo the question of completing lifetimes inside out.

[nate-chandler]

Is now a good time to add a parameter to control whether lifetimes end at the availability or lifetime boundary?

[nate-chandler]

Generally, lifetimes need to be completed inside out/bottom up (as in SILGenCleanup::completeOSSALifetimes). I haven't come up with an example where that would be a problem in this usage, but I'm not confident it's not.

One way to do this would be to collect all the loads first. If any are found, complete all lifetimes inside out. Then determine which of the discovered loads are optimizable and optimize them.

[eeckstein]

As discussed offline, I'm now using computeKnownLiveness instead.

[eeckstein]

@swift-ci test

[eeckstein]

@swift-ci test

[atrick]

Observations and future suggestions...

--- Liverange::collectUses ---

InteriorUseWalker::init does not actually need visitInnerUses: Bool because it could just have a visitInnerUses entry point that does:

innerScopeHandler = { return visitUsesOfOuter(value: $0) }

Liverange::collectUses is just doing what I would call "forwarding-liveness". We could standardize that: basically a combination of computeLinearLiveness and ForwardingDefUseWalker.

findAdditionalUsesInDeadEndBlocks can be eliminated with complete OSSA... ok, I just noticed a TODO says the same thing. But until then, it seems like it might be as efficient to call completeLife(of:) first for each owned values, then simply look for endsLifetime uses. Note that you do need to handle ExtendLifetimeInst, just like computeLinearLiveness does.

--- LoadBorrowInst::verify ---

Small note on load-borrow-immutability verification:

At some point, I would like to centralize the definition of legal address uses in one place. So isMutatedAddress would be alongside AddressUseVisitor::classifyAddress. Also note that, unlike the incorrectly named AddressDefUseWalker::leafUse, AddressUseVisitor::leafAddressUse is actually a leaf use, so you could probably just check mayWrite instead of switching over opcodes.

Then verification should be improved so it does not ignore "unknown" uses (although in this particular verification, we always need to ignore known escaping uses).

[eeckstein]

InteriorUseWalker::init does not actually need visitInnerUses: Bool because it could just have a visitInnerUses entry point that does:

👍. Though the drawback is that this is an escaping closure and needs memory allocation for its context. It's potentially called many times (for each load). So this might affect compile time.

so you could probably just check mayWrite instead of switching over opcodes.

That doesn't work because mayWrite is less precise than what the load-copy-to-borrow optimization does using alias analysis. It would result in false alarms.