llvm dev - May 2015 - [LLVMdev] [cfe-dev] What does "debugger tuning" mean?

This is basically a reboot of the previous thread titled
  About the "debugger target"
except that "target" was really too strong a term for what I had
intended
to use this feature for.  "Debugger tuning" is more like it.  You
don't
need to have read the previous thread, I'll recap here.

Fundamentally, Clang/LLVM uses DWARF as the specification for the _format_
of information provided by the compiler to a variety of "consumers,"
which
primarily means debuggers (but not exclusively).  [For a long time it was 
the only format supported by LLVM. Lately, Microsoft debug info has started
appearing, but being a less widely used format, the issues that DWARF runs 
into aren't a concern for that format.  So "debugger tuning" is
unlikely
to be an issue for Microsoft debug info.]

DWARF is a permissive standard, meaning that it does not rigidly require
that source-language construct X must be described using the DWARF 
construct Y.  Instead, DWARF says something more like, "If you have a 
source construct that means something like X, here's a mechanism Y that 
you could use to describe it."  While this gives compilers a lot of nice 
flexibility, it does mean that there's a lot of wiggle room for how a 
compiler describes something and in how a debugger interprets that 
description.  Compilers and debuggers therefore need to do a bit of 
negotiation in determining how the debug-info "contract" will work,
when
it comes to nitty-gritty details.  DWARF itself (the standard, as well 
as the committee that owns the standard) refuses to get involved in this 
negotiation, referring to all that as "quality of implementation
issues."

It is readily apparent that different debuggers have different ideas
about certain DWARF features, for example whether they are useful or
irrelevant, or whether a certain source construct should be described
this way or that way.  As these generally fall into the QOI realm, the
DWARF spec itself is no help, and it comes down to a matter of opinion
about whether "the debugger should just know this" or "the
compiler
really ought to just emit it that way."

Clang/LLVM is in the position of being a compiler that wants to support
several different debuggers, all of which have slightly different ideas
about what they want from the DWARF info for a program.  Our first line
of defense of course is the DWARF standard itself, but as we've seen,
that is not a universally definitive reference.

LLVM already emits DWARF slightly differently for different *targets*;
primarily Darwin, in a few cases PS4.  But in at least some cases, the
target is just a (somewhat unreliable) proxy for which *debugger* the
compiler expects to be consuming the DWARF.  The most instructive case
is the exact DWARF expression used to describe the location of a thread-
local variable.  DWARF v3 defined an operator to find the base address
of the thread-local storage area; however, GDB has never learned to
recognize it.  Therefore, for targets where we "know" GDB isn't
used,
we can emit the standard operator; for targets where GDB *might* be
used, we need to emit the equivalent (non-standard) GNU operator.

It would be semantically more meaningful to base decisions like this on
whether we expected the debugger to be X or Y or Z.  Therefore I've
proposed (http://reviews.llvm.org/D8506) a "debugger tuning" option
that
will make the reasoning behind these choices more obvious, and ultimately
give users a way to control the tuning themselves, when the platform's
default isn't what they want. (I'll have a follow-up patch exposing the
tuning option to the Clang driver.)

So, what kinds of things should be based on the debugger tuning option?
Are there still things that should be based on the target platform?
Simplest to consider these questions together, because it is often clear
which criterion is important if you consider (a) the same debugger run
on different targets, versus (b) different debuggers running on the same
target.  Basically, if the same debugger on different targets wants to
have something a certain way, that's probably a debugger-tuning thing.
And if different debuggers on the same target doesn't mean you should
change how the DWARF looks, that's likely a platform-specific thing.

The most obvious example of a debugger-tuning consideration is the TLS
operator mentioned above. That's something that GDB insists on having.
(It turns out that the standard operator was defined in DWARF 3, so we
also have to emit the GNU operator if we're producing DWARF 2.  Tuning
considerations don't trump what the standard says.)

Another example would be .debug_pubnames and .debug_pubtypes sections.
Currently these default to omitted for Darwin and PS4, but included
everywhere else. My initial patch for "tuning" changes the PS4
platform
criterion to the SCE debugger predicate; quite likely the "not Darwin"
criterion ought to be "not LLDB" or in other words "on for GDB
only."
And having the code actually reflect the correct semantic purpose seems
like an overall goodness.

An example of a target-dependent feature might be the .debug_aranges
section. As it happens, we don't emit this section by default, because
apparently no debugger finds it useful, although there's a command-line 
option (-gdwarf-aranges) for it.  But, for PS4 we do want to emit it, 
because we have non-debugger tools that find it useful.  We haven't yet 
done the work to make that change on llvm.org, but it's on the list.
I would conditionalize this on the target, not the debugger, because
the debugger is not why we want to generate the section.

Okay, so I've been pretty long-winded about all this, can I possibly
codify it all into a reasonably succinct set of guidelines?  (which 
ought to be committed to the repo somewhere, although whether it's as
a lump of text in a docs webpage or a lump of commentary in some source
file is not clear; opinions welcome.)

o Emit standard DWARF if possible.
o Omitting standard DWARF features that nobody uses is fine.
  (example: DW_AT_sibling)
o Extensions are okay, but think about the circumstances where they 
  would be useful (versus just wasting space).  These are probably a
  debugger tuning decision, but might be a target-based decision.
  (example: DW_AT_APPLE_* attributes)
o If some debugger can't tolerate some piece of standard DWARF, that's
  a missing feature or a bug in the debugger.  Accommodating that in
  the compiler is a debugger tuning decision.
  (example: DW_OP_form_tls_address not understood by GDB)
o If some debugger has no use for some piece of standard DWARF, and
  it saves space to omit it, that's a debugger tuning decision.
  (example: .debug_pubnames/.debug_pubtypes sections)
o If a debugger wants things a certain way regardless of the target,
  that's probably a debugger tuning decision.
o If "system" software on a target (other than the debugger) wants
  things a certain way regardless of which debugger you're using,
  that's NOT a debugger tuning decision, but a target-based decision.
  (example: .debug_aranges section)

Let me know if this all seems reasonable, and especially if you have
a good idea where to keep the guidelines.
Thanks,
--paulr

Sounds reasonable to me.

A few more things that vote for debugger tuning:

- LLDB doesn't like to have DWARF that has a class A that inherits from
class B, but only a forward declaration of class B is provided.
- LLDB wants the .apple_XXX accelerator tables, GDB wants
.debug_pubnames/.debug_pubtypes

So it would be great to have a "-debugger" flag that could be
specified

-debugger=lldb
-debugger=gdb

Not sure on the option name, but I do like the idea.

Greg
> On May 1, 2015, at 1:06 PM, Robinson, Paul <Paul_Robinson at
playstation.sony.com> wrote:
> 
> This is basically a reboot of the previous thread titled
>  About the "debugger target"
> except that "target" was really too strong a term for what I had
intended
> to use this feature for.  "Debugger tuning" is more like it.  You
don't
> need to have read the previous thread, I'll recap here.
> 
> Fundamentally, Clang/LLVM uses DWARF as the specification for the _format_
> of information provided by the compiler to a variety of
"consumers," which
> primarily means debuggers (but not exclusively).  [For a long time it was 
> the only format supported by LLVM. Lately, Microsoft debug info has started
> appearing, but being a less widely used format, the issues that DWARF runs 
> into aren't a concern for that format.  So "debugger tuning"
is unlikely
> to be an issue for Microsoft debug info.]
> 
> DWARF is a permissive standard, meaning that it does not rigidly require
> that source-language construct X must be described using the DWARF 
> construct Y.  Instead, DWARF says something more like, "If you have a 
> source construct that means something like X, here's a mechanism Y that
> you could use to describe it."  While this gives compilers a lot of
nice
> flexibility, it does mean that there's a lot of wiggle room for how a 
> compiler describes something and in how a debugger interprets that 
> description.  Compilers and debuggers therefore need to do a bit of 
> negotiation in determining how the debug-info "contract" will
work, when
> it comes to nitty-gritty details.  DWARF itself (the standard, as well 
> as the committee that owns the standard) refuses to get involved in this 
> negotiation, referring to all that as "quality of implementation
issues."
> 
> It is readily apparent that different debuggers have different ideas
> about certain DWARF features, for example whether they are useful or
> irrelevant, or whether a certain source construct should be described
> this way or that way.  As these generally fall into the QOI realm, the
> DWARF spec itself is no help, and it comes down to a matter of opinion
> about whether "the debugger should just know this" or "the
compiler
> really ought to just emit it that way."
> 
> Clang/LLVM is in the position of being a compiler that wants to support
> several different debuggers, all of which have slightly different ideas
> about what they want from the DWARF info for a program.  Our first line
> of defense of course is the DWARF standard itself, but as we've seen,
> that is not a universally definitive reference.
> 
> LLVM already emits DWARF slightly differently for different *targets*;
> primarily Darwin, in a few cases PS4.  But in at least some cases, the
> target is just a (somewhat unreliable) proxy for which *debugger* the
> compiler expects to be consuming the DWARF.  The most instructive case
> is the exact DWARF expression used to describe the location of a thread-
> local variable.  DWARF v3 defined an operator to find the base address
> of the thread-local storage area; however, GDB has never learned to
> recognize it.  Therefore, for targets where we "know" GDB
isn't used,
> we can emit the standard operator; for targets where GDB *might* be
> used, we need to emit the equivalent (non-standard) GNU operator.
> 
> It would be semantically more meaningful to base decisions like this on
> whether we expected the debugger to be X or Y or Z.  Therefore I've
> proposed (http://reviews.llvm.org/D8506) a "debugger tuning"
option that
> will make the reasoning behind these choices more obvious, and ultimately
> give users a way to control the tuning themselves, when the platform's
> default isn't what they want. (I'll have a follow-up patch exposing
the
> tuning option to the Clang driver.)
> 
> So, what kinds of things should be based on the debugger tuning option?
> Are there still things that should be based on the target platform?
> Simplest to consider these questions together, because it is often clear
> which criterion is important if you consider (a) the same debugger run
> on different targets, versus (b) different debuggers running on the same
> target.  Basically, if the same debugger on different targets wants to
> have something a certain way, that's probably a debugger-tuning thing.
> And if different debuggers on the same target doesn't mean you should
> change how the DWARF looks, that's likely a platform-specific thing.
> 
> The most obvious example of a debugger-tuning consideration is the TLS
> operator mentioned above. That's something that GDB insists on having.
> (It turns out that the standard operator was defined in DWARF 3, so we
> also have to emit the GNU operator if we're producing DWARF 2.  Tuning
> considerations don't trump what the standard says.)
> 
> Another example would be .debug_pubnames and .debug_pubtypes sections.
> Currently these default to omitted for Darwin and PS4, but included
> everywhere else. My initial patch for "tuning" changes the PS4
platform
> criterion to the SCE debugger predicate; quite likely the "not
Darwin"
> criterion ought to be "not LLDB" or in other words "on for
GDB only."
> And having the code actually reflect the correct semantic purpose seems
> like an overall goodness.
> 
> An example of a target-dependent feature might be the .debug_aranges
> section. As it happens, we don't emit this section by default, because
> apparently no debugger finds it useful, although there's a command-line
> option (-gdwarf-aranges) for it.  But, for PS4 we do want to emit it, 
> because we have non-debugger tools that find it useful.  We haven't yet
> done the work to make that change on llvm.org, but it's on the list.
> I would conditionalize this on the target, not the debugger, because
> the debugger is not why we want to generate the section.
> 
> Okay, so I've been pretty long-winded about all this, can I possibly
> codify it all into a reasonably succinct set of guidelines?  (which 
> ought to be committed to the repo somewhere, although whether it's as
> a lump of text in a docs webpage or a lump of commentary in some source
> file is not clear; opinions welcome.)
> 
> o Emit standard DWARF if possible.
> o Omitting standard DWARF features that nobody uses is fine.
>  (example: DW_AT_sibling)
> o Extensions are okay, but think about the circumstances where they 
>  would be useful (versus just wasting space).  These are probably a
>  debugger tuning decision, but might be a target-based decision.
>  (example: DW_AT_APPLE_* attributes)
> o If some debugger can't tolerate some piece of standard DWARF,
that's
>  a missing feature or a bug in the debugger.  Accommodating that in
>  the compiler is a debugger tuning decision.
>  (example: DW_OP_form_tls_address not understood by GDB)
> o If some debugger has no use for some piece of standard DWARF, and
>  it saves space to omit it, that's a debugger tuning decision.
>  (example: .debug_pubnames/.debug_pubtypes sections)
> o If a debugger wants things a certain way regardless of the target,
>  that's probably a debugger tuning decision.
> o If "system" software on a target (other than the debugger)
wants
>  things a certain way regardless of which debugger you're using,
>  that's NOT a debugger tuning decision, but a target-based decision.
>  (example: .debug_aranges section)
> 
> Let me know if this all seems reasonable, and especially if you have
> a good idea where to keep the guidelines.
> Thanks,
> --paulr
> 
> 
> _______________________________________________
> lldb-dev mailing list
> lldb-dev at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/lldb-dev

On Fri, May 1, 2015 at 1:06 PM, Robinson, Paul <
Paul_Robinson at playstation.sony.com> wrote:
> This is basically a reboot of the previous thread titled
>   About the "debugger target"
> except that "target" was really too strong a term for what I had
intended
> to use this feature for.  "Debugger tuning" is more like it.  You
don't
> need to have read the previous thread, I'll recap here.
>
> Fundamentally, Clang/LLVM uses DWARF as the specification for the _format_
> of information provided by the compiler to a variety of
"consumers," which
> primarily means debuggers (but not exclusively).  [For a long time it was
> the only format supported by LLVM. Lately, Microsoft debug info has started
> appearing, but being a less widely used format, the issues that DWARF runs
> into aren't a concern for that format.  So "debugger tuning"
is unlikely
> to be an issue for Microsoft debug info.]
>
> DWARF is a permissive standard, meaning that it does not rigidly require
> that source-language construct X must be described using the DWARF
> construct Y.  Instead, DWARF says something more like, "If you have a
> source construct that means something like X, here's a mechanism Y that
> you could use to describe it."  While this gives compilers a lot of
nice
> flexibility, it does mean that there's a lot of wiggle room for how a
> compiler describes something and in how a debugger interprets that
> description.  Compilers and debuggers therefore need to do a bit of
> negotiation in determining how the debug-info "contract" will
work, when
> it comes to nitty-gritty details.  DWARF itself (the standard, as well
> as the committee that owns the standard) refuses to get involved in this
> negotiation, referring to all that as "quality of implementation
issues."
>
> It is readily apparent that different debuggers have different ideas
> about certain DWARF features, for example whether they are useful or
> irrelevant, or whether a certain source construct should be described
> this way or that way.  As these generally fall into the QOI realm, the
> DWARF spec itself is no help, and it comes down to a matter of opinion
> about whether "the debugger should just know this" or "the
compiler
> really ought to just emit it that way."
>
> Clang/LLVM is in the position of being a compiler that wants to support
> several different debuggers, all of which have slightly different ideas
> about what they want from the DWARF info for a program.  Our first line
> of defense of course is the DWARF standard itself, but as we've seen,
> that is not a universally definitive reference.
>
> LLVM already emits DWARF slightly differently for different *targets*;
> primarily Darwin, in a few cases PS4.  But in at least some cases, the
> target is just a (somewhat unreliable) proxy for which *debugger* the
> compiler expects to be consuming the DWARF.  The most instructive case
> is the exact DWARF expression used to describe the location of a thread-
> local variable.  DWARF v3 defined an operator to find the base address
> of the thread-local storage area; however, GDB has never learned to
> recognize it.  Therefore, for targets where we "know" GDB
isn't used,
> we can emit the standard operator; for targets where GDB *might* be
> used, we need to emit the equivalent (non-standard) GNU operator.
>
> It would be semantically more meaningful to base decisions like this on
> whether we expected the debugger to be X or Y or Z.  Therefore I've
> proposed (http://reviews.llvm.org/D8506) a "debugger tuning"
option that
> will make the reasoning behind these choices more obvious, and ultimately
> give users a way to control the tuning themselves, when the platform's
> default isn't what they want. (I'll have a follow-up patch exposing
the
> tuning option to the Clang driver.)
>
> So, what kinds of things should be based on the debugger tuning option?
> Are there still things that should be based on the target platform?
> Simplest to consider these questions together, because it is often clear
> which criterion is important if you consider (a) the same debugger run
> on different targets, versus (b) different debuggers running on the same
> target.  Basically, if the same debugger on different targets wants to
> have something a certain way, that's probably a debugger-tuning thing.
> And if different debuggers on the same target doesn't mean you should
> change how the DWARF looks, that's likely a platform-specific thing.
>
> The most obvious example of a debugger-tuning consideration is the TLS
> operator mentioned above. That's something that GDB insists on having.
> (It turns out that the standard operator was defined in DWARF 3, so we
> also have to emit the GNU operator if we're producing DWARF 2.  Tuning
> considerations don't trump what the standard says.)
>
> Another example would be .debug_pubnames and .debug_pubtypes sections.
> Currently these default to omitted for Darwin and PS4, but included
> everywhere else. My initial patch for "tuning" changes the PS4
platform
> criterion to the SCE debugger predicate; quite likely the "not
Darwin"
> criterion ought to be "not LLDB" or in other words "on for
GDB only."
>
"not LLDB" wouldn't be "on for GDB only" (it'd be
"on for GDB and SCE"
given the current debuggers)

Eric, Adrian, and I hit another case of positive/negative checking recently
for some DWARF feature... local anonymous unions. GDB likes to have
explicit (possibly artificial) local variables for the unions members, LLDB
can manage without them.

Eric & I discussed that there's a bit of a sliding scale of
compatibility
we should bother with - how much LLVM bends over backwards to cope with
debugger bugs/limitations. I was inclined to just say it's a debugger bug
and only enable the workaround when targeting that debugger specifically,
and Eric wasn't. We came to the conclusion/agreement that maybe having it
on by defaut but off if targeting any /specific/ non-GDB debugger.

> And having the code actually reflect the correct semantic purpose seems
> like an overall goodness.
>
> An example of a target-dependent feature might be the .debug_aranges
> section. As it happens, we don't emit this section by default, because
> apparently no debugger finds it useful, although there's a command-line
> option (-gdwarf-aranges) for it.  But, for PS4 we do want to emit it,
> because we have non-debugger tools that find it useful.  We haven't yet
> done the work to make that change on llvm.org, but it's on the list.
> I would conditionalize this on the target, not the debugger, because
> the debugger is not why we want to generate the section.
>
> Okay, so I've been pretty long-winded about all this, can I possibly
> codify it all into a reasonably succinct set of guidelines?  (which
> ought to be committed to the repo somewhere, although whether it's as
> a lump of text in a docs webpage or a lump of commentary in some source
> file is not clear; opinions welcome.)
>
In the source, probably - somewhere near the enum or major entry point to
querying it.

We might want to talk a bit more about when to err on the side of caution &
put something in for every debugger by default, an opt out of it when
tuning for a debugger that doesn't need it.

>
> o Emit standard DWARF if possible.
> o Omitting standard DWARF features that nobody uses is fine.
>   (example: DW_AT_sibling)
> o Extensions are okay, but think about the circumstances where they
>   would be useful (versus just wasting space).  These are probably a
>   debugger tuning decision, but might be a target-based decision.
>   (example: DW_AT_APPLE_* attributes)
> o If some debugger can't tolerate some piece of standard DWARF,
that's
>   a missing feature or a bug in the debugger.  Accommodating that in
>   the compiler is a debugger tuning decision.
>   (example: DW_OP_form_tls_address not understood by GDB)
> o If some debugger has no use for some piece of standard DWARF, and
>   it saves space to omit it, that's a debugger tuning decision.
>   (example: .debug_pubnames/.debug_pubtypes sections)
> o If a debugger wants things a certain way regardless of the target,
>   that's probably a debugger tuning decision.
> o If "system" software on a target (other than the debugger)
wants
>   things a certain way regardless of which debugger you're using,
>   that's NOT a debugger tuning decision, but a target-based decision.
>   (example: .debug_aranges section)
>
> Let me know if this all seems reasonable, and especially if you have
> a good idea where to keep the guidelines.
> Thanks,
> --paulr
>
>
> _______________________________________________
> cfe-dev mailing list
> cfe-dev at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/cfe-dev
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20150501/e625fa88/attachment.html>

> A few more things that vote for debugger tuning:
> 
> - LLDB doesn't like to have DWARF that has a class A that inherits from
> class B, but only a forward declaration of class B is provided.
Hmm do we emit that kind of thing today?  In a naïve test, I'm seeing
the full description of class B.
> - LLDB wants the .apple_XXX accelerator tables, GDB wants
> .debug_pubnames/.debug_pubtypes
Agreed.
> So it would be great to have a "-debugger" flag that could be
specified
> 
> -debugger=lldb
> -debugger=gdb
> 
> Not sure on the option name, but I do like the idea.
We'll bikeshed the name later but yes, that's the plan.
Thanks,
--paulr
> 
> Greg
> 
> > On May 1, 2015, at 1:06 PM, Robinson, Paul
> <Paul_Robinson at playstation.sony.com> wrote:
> >
> > This is basically a reboot of the previous thread titled
> >  About the "debugger target"
> > except that "target" was really too strong a term for what I
had
> intended
> > to use this feature for.  "Debugger tuning" is more like it.
You don't
> > need to have read the previous thread, I'll recap here.
> >
> > Fundamentally, Clang/LLVM uses DWARF as the specification for the
> _format_
> > of information provided by the compiler to a variety of
"consumers,"
> which
> > primarily means debuggers (but not exclusively).  [For a long time it
> was
> > the only format supported by LLVM. Lately, Microsoft debug info has
> started
> > appearing, but being a less widely used format, the issues that DWARF
> runs
> > into aren't a concern for that format.  So "debugger
tuning" is unlikely
> > to be an issue for Microsoft debug info.]
> >
> > DWARF is a permissive standard, meaning that it does not rigidly
require
> > that source-language construct X must be described using the DWARF
> > construct Y.  Instead, DWARF says something more like, "If you
have a
> > source construct that means something like X, here's a mechanism Y
that
> > you could use to describe it."  While this gives compilers a lot
of nice
> > flexibility, it does mean that there's a lot of wiggle room for
how a
> > compiler describes something and in how a debugger interprets that
> > description.  Compilers and debuggers therefore need to do a bit of
> > negotiation in determining how the debug-info "contract"
will work, when
> > it comes to nitty-gritty details.  DWARF itself (the standard, as well
> > as the committee that owns the standard) refuses to get involved in
this
> > negotiation, referring to all that as "quality of implementation
> issues."
> >
> > It is readily apparent that different debuggers have different ideas
> > about certain DWARF features, for example whether they are useful or
> > irrelevant, or whether a certain source construct should be described
> > this way or that way.  As these generally fall into the QOI realm, the
> > DWARF spec itself is no help, and it comes down to a matter of opinion
> > about whether "the debugger should just know this" or
"the compiler
> > really ought to just emit it that way."
> >
> > Clang/LLVM is in the position of being a compiler that wants to
support
> > several different debuggers, all of which have slightly different
ideas
> > about what they want from the DWARF info for a program.  Our first
line
> > of defense of course is the DWARF standard itself, but as we've
seen,
> > that is not a universally definitive reference.
> >
> > LLVM already emits DWARF slightly differently for different *targets*;
> > primarily Darwin, in a few cases PS4.  But in at least some cases, the
> > target is just a (somewhat unreliable) proxy for which *debugger* the
> > compiler expects to be consuming the DWARF.  The most instructive case
> > is the exact DWARF expression used to describe the location of a
thread-
> > local variable.  DWARF v3 defined an operator to find the base address
> > of the thread-local storage area; however, GDB has never learned to
> > recognize it.  Therefore, for targets where we "know" GDB
isn't used,
> > we can emit the standard operator; for targets where GDB *might* be
> > used, we need to emit the equivalent (non-standard) GNU operator.
> >
> > It would be semantically more meaningful to base decisions like this
on
> > whether we expected the debugger to be X or Y or Z.  Therefore
I've
> > proposed (http://reviews.llvm.org/D8506) a "debugger tuning"
option that
> > will make the reasoning behind these choices more obvious, and
> ultimately
> > give users a way to control the tuning themselves, when the
platform's
> > default isn't what they want. (I'll have a follow-up patch
exposing the
> > tuning option to the Clang driver.)
> >
> > So, what kinds of things should be based on the debugger tuning
option?
> > Are there still things that should be based on the target platform?
> > Simplest to consider these questions together, because it is often
clear
> > which criterion is important if you consider (a) the same debugger run
> > on different targets, versus (b) different debuggers running on the
same
> > target.  Basically, if the same debugger on different targets wants to
> > have something a certain way, that's probably a debugger-tuning
thing.
> > And if different debuggers on the same target doesn't mean you
should
> > change how the DWARF looks, that's likely a platform-specific
thing.
> >
> > The most obvious example of a debugger-tuning consideration is the TLS
> > operator mentioned above. That's something that GDB insists on
having.
> > (It turns out that the standard operator was defined in DWARF 3, so we
> > also have to emit the GNU operator if we're producing DWARF 2. 
Tuning
> > considerations don't trump what the standard says.)
> >
> > Another example would be .debug_pubnames and .debug_pubtypes sections.
> > Currently these default to omitted for Darwin and PS4, but included
> > everywhere else. My initial patch for "tuning" changes the
PS4 platform
> > criterion to the SCE debugger predicate; quite likely the "not
Darwin"
> > criterion ought to be "not LLDB" or in other words "on
for GDB only."
> > And having the code actually reflect the correct semantic purpose
seems
> > like an overall goodness.
> >
> > An example of a target-dependent feature might be the .debug_aranges
> > section. As it happens, we don't emit this section by default,
because
> > apparently no debugger finds it useful, although there's a
command-line
> > option (-gdwarf-aranges) for it.  But, for PS4 we do want to emit it,
> > because we have non-debugger tools that find it useful.  We
haven't yet
> > done the work to make that change on llvm.org, but it's on the
list.
> > I would conditionalize this on the target, not the debugger, because
> > the debugger is not why we want to generate the section.
> >
> > Okay, so I've been pretty long-winded about all this, can I
possibly
> > codify it all into a reasonably succinct set of guidelines?  (which
> > ought to be committed to the repo somewhere, although whether it's
as
> > a lump of text in a docs webpage or a lump of commentary in some
source
> > file is not clear; opinions welcome.)
> >
> > o Emit standard DWARF if possible.
> > o Omitting standard DWARF features that nobody uses is fine.
> >  (example: DW_AT_sibling)
> > o Extensions are okay, but think about the circumstances where they
> >  would be useful (versus just wasting space).  These are probably a
> >  debugger tuning decision, but might be a target-based decision.
> >  (example: DW_AT_APPLE_* attributes)
> > o If some debugger can't tolerate some piece of standard DWARF,
that's
> >  a missing feature or a bug in the debugger.  Accommodating that in
> >  the compiler is a debugger tuning decision.
> >  (example: DW_OP_form_tls_address not understood by GDB)
> > o If some debugger has no use for some piece of standard DWARF, and
> >  it saves space to omit it, that's a debugger tuning decision.
> >  (example: .debug_pubnames/.debug_pubtypes sections)
> > o If a debugger wants things a certain way regardless of the target,
> >  that's probably a debugger tuning decision.
> > o If "system" software on a target (other than the debugger)
wants
> >  things a certain way regardless of which debugger you're using,
> >  that's NOT a debugger tuning decision, but a target-based
decision.
> >  (example: .debug_aranges section)
> >
> > Let me know if this all seems reasonable, and especially if you have
> > a good idea where to keep the guidelines.
> > Thanks,
> > --paulr
> >
> >
> > _______________________________________________
> > lldb-dev mailing list
> > lldb-dev at cs.uiuc.edu
> > http://lists.cs.uiuc.edu/mailman/listinfo/lldb-dev

Another example would be .debug_pubnames and .debug_pubtypes sections.
Currently these default to omitted for Darwin and PS4, but included
everywhere else. My initial patch for "tuning" changes the PS4
platform
criterion to the SCE debugger predicate; quite likely the "not Darwin"
criterion ought to be "not LLDB" or in other words "on for GDB
only."

"not LLDB" wouldn't be "on for GDB only" (it'd be
"on for GDB and SCE" given the current debuggers)

Poorly phrased on my part.  The "not Darwin" part would become
"not LLDB" and _when combined with the existing "not SCE"
part_ could be refactored into "on for GDB only."

Re extra artificial entries, the specific example being variables for local
anonymous unions:

I was inclined to just say it's a debugger bug and only enable the
workaround when targeting that debugger specifically, and Eric wasn't. We
came to the conclusion/agreement that maybe having it on by defaut but off if
targeting any /specific/ non-GDB debugger.

Well, that's consistent with the default tuning being for GDB.  Emitting it
under GDB means you do get them by default but not if you're knowingly
targeting something else.

If you're envisioning a "no specific tuning" mode, I flip-flopped
on that one a couple times while I was working up the idea, and came down on the
side of not doing it.  Not opposed to having it, but we haven't really
thought about what it would look like.  (Emit every kind of standard thing we
know about, and no non-standard things at all?  So we'd get pubnames and
pubtypes and aranges but no Apple attributes or accelerator tables and not the
GNU TLS opcode.  Is that a useful mode to have?)

Re where to put the guidelines:

ought to be committed to the repo somewhere, although whether it's as
a lump of text in a docs webpage or a lump of commentary in some source
file is not clear; opinions welcome.)

In the source, probably - somewhere near the enum or major entry point to
querying it.

By the definitions of the predicate functions, WFM.

We might want to talk a bit more about when to err on the side of caution &
put something in for every debugger by default, an opt out of it when tuning for
a debugger that doesn't need it.

That part of the visioning would imagine a new debugger (there are more of them
out there in the world) and how to phrase the condition to work in the way, how
to say this, least likely to be a problem.  The TLS opcode should default to
standard, except GDB.  Soon enough I'll be using the tuning feature to turn
off linkage names for SCE, but it'll be on by default.  Like that.
--paulr

From: David Blaikie [mailto:dblaikie at gmail.com]
Sent: Friday, May 01, 2015 1:58 PM
To: Robinson, Paul
Cc: cfe-dev at cs.uiuc.edu Developers (cfe-dev at cs.uiuc.edu); LLVM Developers
Mailing List (llvmdev at cs.uiuc.edu); lldb-dev at cs.uiuc.edu
Subject: Re: [cfe-dev] What does "debugger tuning" mean?



On Fri, May 1, 2015 at 1:06 PM, Robinson, Paul <Paul_Robinson at
playstation.sony.com<mailto:Paul_Robinson at playstation.sony.com>>
wrote:
This is basically a reboot of the previous thread titled
  About the "debugger target"
except that "target" was really too strong a term for what I had
intended
to use this feature for.  "Debugger tuning" is more like it.  You
don't
need to have read the previous thread, I'll recap here.

Fundamentally, Clang/LLVM uses DWARF as the specification for the _format_
of information provided by the compiler to a variety of "consumers,"
which
primarily means debuggers (but not exclusively).  [For a long time it was
the only format supported by LLVM. Lately, Microsoft debug info has started
appearing, but being a less widely used format, the issues that DWARF runs
into aren't a concern for that format.  So "debugger tuning" is
unlikely
to be an issue for Microsoft debug info.]

DWARF is a permissive standard, meaning that it does not rigidly require
that source-language construct X must be described using the DWARF
construct Y.  Instead, DWARF says something more like, "If you have a
source construct that means something like X, here's a mechanism Y that
you could use to describe it."  While this gives compilers a lot of nice
flexibility, it does mean that there's a lot of wiggle room for how a
compiler describes something and in how a debugger interprets that
description.  Compilers and debuggers therefore need to do a bit of
negotiation in determining how the debug-info "contract" will work,
when
it comes to nitty-gritty details.  DWARF itself (the standard, as well
as the committee that owns the standard) refuses to get involved in this
negotiation, referring to all that as "quality of implementation
issues."

It is readily apparent that different debuggers have different ideas
about certain DWARF features, for example whether they are useful or
irrelevant, or whether a certain source construct should be described
this way or that way.  As these generally fall into the QOI realm, the
DWARF spec itself is no help, and it comes down to a matter of opinion
about whether "the debugger should just know this" or "the
compiler
really ought to just emit it that way."

Clang/LLVM is in the position of being a compiler that wants to support
several different debuggers, all of which have slightly different ideas
about what they want from the DWARF info for a program.  Our first line
of defense of course is the DWARF standard itself, but as we've seen,
that is not a universally definitive reference.

LLVM already emits DWARF slightly differently for different *targets*;
primarily Darwin, in a few cases PS4.  But in at least some cases, the
target is just a (somewhat unreliable) proxy for which *debugger* the
compiler expects to be consuming the DWARF.  The most instructive case
is the exact DWARF expression used to describe the location of a thread-
local variable.  DWARF v3 defined an operator to find the base address
of the thread-local storage area; however, GDB has never learned to
recognize it.  Therefore, for targets where we "know" GDB isn't
used,
we can emit the standard operator; for targets where GDB *might* be
used, we need to emit the equivalent (non-standard) GNU operator.

It would be semantically more meaningful to base decisions like this on
whether we expected the debugger to be X or Y or Z.  Therefore I've
proposed (http://reviews.llvm.org/D8506) a "debugger tuning" option
that
will make the reasoning behind these choices more obvious, and ultimately
give users a way to control the tuning themselves, when the platform's
default isn't what they want. (I'll have a follow-up patch exposing the
tuning option to the Clang driver.)

So, what kinds of things should be based on the debugger tuning option?
Are there still things that should be based on the target platform?
Simplest to consider these questions together, because it is often clear
which criterion is important if you consider (a) the same debugger run
on different targets, versus (b) different debuggers running on the same
target.  Basically, if the same debugger on different targets wants to
have something a certain way, that's probably a debugger-tuning thing.
And if different debuggers on the same target doesn't mean you should
change how the DWARF looks, that's likely a platform-specific thing.

The most obvious example of a debugger-tuning consideration is the TLS
operator mentioned above. That's something that GDB insists on having.
(It turns out that the standard operator was defined in DWARF 3, so we
also have to emit the GNU operator if we're producing DWARF 2.  Tuning
considerations don't trump what the standard says.)

Another example would be .debug_pubnames and .debug_pubtypes sections.
Currently these default to omitted for Darwin and PS4, but included
everywhere else. My initial patch for "tuning" changes the PS4
platform
criterion to the SCE debugger predicate; quite likely the "not Darwin"
criterion ought to be "not LLDB" or in other words "on for GDB
only."

"not LLDB" wouldn't be "on for GDB only" (it'd be
"on for GDB and SCE" given the current debuggers)

Eric, Adrian, and I hit another case of positive/negative checking recently for
some DWARF feature... local anonymous unions. GDB likes to have explicit
(possibly artificial) local variables for the unions members, LLDB can manage
without them.

Eric & I discussed that there's a bit of a sliding scale of
compatibility we should bother with - how much LLVM bends over backwards to cope
with debugger bugs/limitations. I was inclined to just say it's a debugger
bug and only enable the workaround when targeting that debugger specifically,
and Eric wasn't. We came to the conclusion/agreement that maybe having it on
by defaut but off if targeting any /specific/ non-GDB debugger.

And having the code actually reflect the correct semantic purpose seems
like an overall goodness.

An example of a target-dependent feature might be the .debug_aranges
section. As it happens, we don't emit this section by default, because
apparently no debugger finds it useful, although there's a command-line
option (-gdwarf-aranges) for it.  But, for PS4 we do want to emit it,
because we have non-debugger tools that find it useful.  We haven't yet
done the work to make that change on llvm.org<http://llvm.org>, but
it's on the list.
I would conditionalize this on the target, not the debugger, because
the debugger is not why we want to generate the section.

Okay, so I've been pretty long-winded about all this, can I possibly
codify it all into a reasonably succinct set of guidelines?  (which
ought to be committed to the repo somewhere, although whether it's as
a lump of text in a docs webpage or a lump of commentary in some source
file is not clear; opinions welcome.)

In the source, probably - somewhere near the enum or major entry point to
querying it.

We might want to talk a bit more about when to err on the side of caution &
put something in for every debugger by default, an opt out of it when tuning for
a debugger that doesn't need it.


o Emit standard DWARF if possible.
o Omitting standard DWARF features that nobody uses is fine.
  (example: DW_AT_sibling)
o Extensions are okay, but think about the circumstances where they
  would be useful (versus just wasting space).  These are probably a
  debugger tuning decision, but might be a target-based decision.
  (example: DW_AT_APPLE_* attributes)
o If some debugger can't tolerate some piece of standard DWARF, that's
  a missing feature or a bug in the debugger.  Accommodating that in
  the compiler is a debugger tuning decision.
  (example: DW_OP_form_tls_address not understood by GDB)
o If some debugger has no use for some piece of standard DWARF, and
  it saves space to omit it, that's a debugger tuning decision.
  (example: .debug_pubnames/.debug_pubtypes sections)
o If a debugger wants things a certain way regardless of the target,
  that's probably a debugger tuning decision.
o If "system" software on a target (other than the debugger) wants
  things a certain way regardless of which debugger you're using,
  that's NOT a debugger tuning decision, but a target-based decision.
  (example: .debug_aranges section)

Let me know if this all seems reasonable, and especially if you have
a good idea where to keep the guidelines.
Thanks,
--paulr


_______________________________________________
cfe-dev mailing list
cfe-dev at cs.uiuc.edu<mailto:cfe-dev at cs.uiuc.edu>
http://lists.cs.uiuc.edu/mailman/listinfo/cfe-dev

-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20150501/46c4d913/attachment.html>

On Fri, May 1, 2015 at 1:06 PM, Robinson, Paul
<Paul_Robinson at playstation.sony.com> wrote:
>
> LLVM already emits DWARF slightly differently for different *targets*;
> primarily Darwin, in a few cases PS4.  But in at least some cases, the
> target is just a (somewhat unreliable) proxy for which *debugger* the
> compiler expects to be consuming the DWARF.  The most instructive case
> is the exact DWARF expression used to describe the location of a thread-
> local variable.  DWARF v3 defined an operator to find the base address
> of the thread-local storage area; however, GDB has never learned to
> recognize it.  Therefore, for targets where we "know" GDB
isn't used,
> we can emit the standard operator; for targets where GDB *might* be
> used, we need to emit the equivalent (non-standard) GNU operator.
>
> It would be semantically more meaningful to base decisions like this on
> whether we expected the debugger to be X or Y or Z.
How is this not actually "we expect the debugger to want his described
as X, Y, and Z" instead of "we expect the debugger to by X or Y or
Z".

Debuggers change over time.

GDB 4's level of support != GDB 5 != GDB6 != GDB7.

Heck, the same version of GDB on different platforms can be very
different (HP's GDB was very different, as was Apple's).

Do you plan on having "debugger tuning" flags for each of these?

I am having a lot of trouble understanding how this is about what
debuggers expect and not "ways of representing things".

Otherwise, i see you getting stuck introducing tons and tons of
debugger tunings, instead of people who want it to work a certain way
building an option profile consisting of
"--debugging-feature=use-tls-operator
--debugging-feature=explicit-anonymous-namespace", and getting exactly
what they want.

IE a year from now, somebody comes along with a version of GDB that
doesn't match what your current "tuning profile" is, and asks for
it
to change.

> -----Original Message-----
> From: Daniel Berlin [mailto:dberlin at dberlin.org]
> Sent: Friday, May 01, 2015 3:15 PM
> To: Robinson, Paul
> Cc: cfe-dev at cs.uiuc.edu Developers (cfe-dev at cs.uiuc.edu); LLVM
Developers
> Mailing List (llvmdev at cs.uiuc.edu); lldb-dev at cs.uiuc.edu
> Subject: Re: [LLVMdev] What does "debugger tuning" mean?
> 
> On Fri, May 1, 2015 at 1:06 PM, Robinson, Paul
> <Paul_Robinson at playstation.sony.com> wrote:
> 
> >
> > LLVM already emits DWARF slightly differently for different *targets*;
> > primarily Darwin, in a few cases PS4.  But in at least some cases, the
> > target is just a (somewhat unreliable) proxy for which *debugger* the
> > compiler expects to be consuming the DWARF.  The most instructive case
> > is the exact DWARF expression used to describe the location of a
thread-
> > local variable.  DWARF v3 defined an operator to find the base address
> > of the thread-local storage area; however, GDB has never learned to
> > recognize it.  Therefore, for targets where we "know" GDB
isn't used,
> > we can emit the standard operator; for targets where GDB *might* be
> > used, we need to emit the equivalent (non-standard) GNU operator.
> >
> > It would be semantically more meaningful to base decisions like this
on
> > whether we expected the debugger to be X or Y or Z.
> 
> How is this not actually "we expect the debugger to want his described
> as X, Y, and Z" instead of "we expect the debugger to by X or Y
or Z".
Different ways of describing things let us reason about them in different
ways.  Are Cartesian coordinates a reason to reject polar coordinates?
> Debuggers change over time.
Well, they're software too.  They're allowed.
> GDB 4's level of support != GDB 5 != GDB6 != GDB7.
> 
> Heck, the same version of GDB on different platforms can be very
> different (HP's GDB was very different, as was Apple's).
> 
> Do you plan on having "debugger tuning" flags for each of these?
Are all of these current supported Clang/LLVM environments?  Are they
suffering because Clang currently emits DWARF in ways that cause them
problems, or that bloats the debug info unnecessarily?  Are vendors
carrying a pile of private patches to get LLVM to emit DWARF that looks
like what their debugger wants?  If the answer to these questions is
Yes then my answer to your question is Sure, we could, if we find 
those differences to be important.

I promise you that these things are true at Sony, and I would be
astounded if it wasn't true for Apple. Guess what? LLDB and SCE are
two of the debugger-tuning options for a reason.

Show me another _real_ case of _real_ differences that matter to the
community, and we can talk about another debugger tuning option.
> I am having a lot of trouble understanding how this is about what
> debuggers expect and not "ways of representing things".
Sometimes there's not much difference in the result, although there
is a difference in how we think about it.
> Otherwise, i see you getting stuck introducing tons and tons of
> debugger tunings, instead of people who want it to work a certain way
> building an option profile consisting of
> "--debugging-feature=use-tls-operator
> --debugging-feature=explicit-anonymous-namespace", and getting exactly
> what they want.
(That sort of alternate proposal is way more useful than the straw-man
stuff you started out with.  Just sayin'.)

(Also incidentally, I see gcc 4.8.2 is emitting an explicit import of
anonymous namespaces, so that's becoming _less_ different over time.)

In fact this is more or less how DwarfDebug operates now; there is a
pile (small pile, but still a pile) of individual feature flags that
get set various ways depending on target or command-line options.
The problem I'm looking at is that the defaults for a lot of these 
things are based on target, which AFAICT is based on an out-of-date
assumption about how target correlates to debugger.

I'm proposing to package up known sets of stuff that we're having to
contend with _today_ in a way that's easier to talk about and do
something about than the target-oriented mish-mash we have now.

It's a whole lot simpler to say something like "FreeBSD implies
LLDB"
instead of "FreeBSD implies accelerator tables and standard TLS opcode
and no pubnames or pubtypes."

Or would you rather say "--lang-feature=auto --lang-feature=rvalue-ref
--lang-feature=move_ctor ..." than "-std=c++11"?

> IE a year from now, somebody comes along with a version of GDB that
> doesn't match what your current "tuning profile" is, and asks
for it
> to change.
If it's meaningfully different, i.e. makes enough of a functional and/or
size difference, and it's an environment we collectively want to support,
and it's unreasonable to get the necessary effect some other way, then
sure, maybe we would want to invent a new tuning profile.

But, if it doesn't meet that bar, I don't see why we'd want to.
--paulr