[llvm-dev] DW_OP_implicit_pointer design/implementation in general

David Blaikie via llvm-dev llvm-dev at lists.llvm.org
Thu Nov 14 13:33:59 PST 2019

On Thu, Nov 14, 2019 at 1:27 PM Adrian Prantl <aprantl at apple.com> wrote:

> > On Nov 14, 2019, at 1:21 PM, David Blaikie <dblaikie at gmail.com> wrote:
> >
> > Hey folks,
> >
> > Would you all mind having a bit of a design discussion around the
> feature both at the DWARF level and the LLVM implementation? It seems like
> what's currently being proposed/reviewed (based on the DWARF feature as
> spec'd) is a pretty big change & I'm not sure I understand the motivation,
> exactly.
> >
> > The core point of my confusion: Why does describing the thing a pointer
> points to require describing a named variable that it points to? What if it
> doesn't point to a named variable?
> Without having looked at the motivational text when the feature was
> proposed to DWARF, my assumption was that this is similar to how bounds for
> variable-length arrays are implemented, where a (potentially) artificial
> variable is created by the compiler in order to have something to refer to.

I /sort/ of see that case as a bit different, because the array type needs
to refer back into the function potentially (to use frame-relative, etc). I
could think of other ways to do that in hindsight (like putting the array
type definition inside the function to begin with & having the count
describe the location directly, for instance).

> In retrospect I find the entire specification of DW_OP_implicit_pointer to
> be strangely specific/limited (why one hard-coded offset instead of an
> arbitrary expression?), but that ship has sailed for DWARF 5 and I'm to
> blame for not voicing that concern earlier.

Sure, but we don't have to implement it if we don't find it to be super
useful/worthwhile, right? (if something else would be particularly more
general/useful we could instead implement that as an extension, though of
course there's cost to that in terms of consumer support, etc)

> -- adrian
> >
> > Seems like there should be a way to describe that situation - and that
> doing so would be a more general solution than one limited to only
> describing pointers that point to named variables. And would be a simpler
> implementation in LLVM - without having to deconstruct variables during
> optimizations, etc, to track one variable's value being concretely related
> to another variable's value.
> >
> > - David
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20191114/2784c5cb/attachment.html>

More information about the llvm-dev mailing list