[llvm-dev] extending liveness of 'this' pointer via FAKE_USE opcode

[Smith, Kevin B via llvm-dev]

Why extend the live-range?

If it isn't already in memory (and for many architectures, it is already in memory), put the this pointer into memory, and change the
debug information so that the location-expression of the this parameter is marked to be that memory?

That has two nice properties:

1 - If you do this early (in the function IR, not necessarily in the pass ordering), it really only costs a single store, and doesn't otherwise really affect register allocation.  Mark the memory itself in such a way that it cannot be deleted.

2 - This is only required for architectures/calling conventions where the this ptr isn't already in memory, and where this extra debugging is required/desired.

Kevin Smith

From: llvm-dev [mailto:llvm-dev-bounces at lists.llvm.org] On Behalf Of Pieb, Wolfgang via llvm-dev
Sent: Monday, September 21, 2015 11:17 AM
To: llvm-dev at lists.llvm.org
Subject: [llvm-dev] extending liveness of 'this' pointer via FAKE_USE opcode

Hello!

At Sony we've seen some serious customer interest in having the 'this' pointer visible throughout an entire function during
debugging. However, optimizations may eliminate it after its last use, so we've been looking for a way to artificially extend its
liverange to the end of the function.

So far, the most compelling way we can think of, and one we have used successfully in the past in at least one other compiler,
is to create a 'fake use' of the 'this' pointer at the end of the function, compelling the rest of the compiler to not optimize it away.

At the moment there doesn't seem to be a good way to create such a fake use in LLVM (please enlighten us if you know of one), so we are
proposing to introduce a new intrinsic (e.g. llvm.fake_use), which would take a single value argument, representing a use of that value.
The intrinsic would be lowered to a new invariant TargetOpcode (e.g. FAKE_USE), which serves the same purpose at the MI level.
Code emission would simply ignore the new opcode.

Frontends could use the intrinsic to extend liveranges of variables as desired. As a first use case, clang would accept a new option
(e.g. -fkeep-this-ptr) which would cause a fake use of 'this' to be inserted at the end of a function, making it available for inspection
throughout the entire function body.

One important note is that since such an option would affect code generation, it cannot be automatically enabled by -g. However, should there be
eventually support for a -Og mode (optimize for debugging), that mode could enable it.

Any comments or alternative ideas are appreciated.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20150922/1fb1fae4/attachment.html>