This is the mail archive of the
archer@sourceware.org
mailing list for the Archer project.
notes on type printing
- From: Tom Tromey <tromey at redhat dot com>
- To: Project Archer <archer at sourceware dot org>
- Date: Fri, 19 Sep 2008 15:35:09 -0600
- Subject: notes on type printing
- Reply-to: Tom Tromey <tromey at redhat dot com>
Today I spent some time looking at a few type-printing examples that
Benjamin Kosnik sent a while back.
gdb often prints the "wrong" information for a type. I think this
problem has two parts. First, debuginfo often does not express all
the information we need. Second, I think we may need to extend
'whatis' or 'ptype' to give the user more control over verbosity.
Consider a simple case:
namespace ns {
template<typename T>
class k {
T z;
};
typedef k<int> td;
}
ns::td zardoz;
ns::k<int> maude;
'whatis' shows funny results:
(gdb) whatis zardoz
type = td
(gdb) whatis maude
type = ns::k<int>
Here, I think both types should be qualified with 'ns::'. In the
'zardoz' case, this boils down to missing debug info. Most of
Benjamin's tests come down to this -- g++ emitting something other
than what the user wrote.
The need for verbosity control needs a somewhat more complicated
test. I've appended Benjamin's '2.cc' for reference.
Here, if you 'start' and then 'ptype functor_type', you will get the
weird:
(gdb) ptype functor_type
type =
class functor<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, int> {
private:
std::basic_string<char, std::char_traits<char>, std::allocator<char> > one;
std::vector<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > two;
int three;
public:
void operator()();
}
Now, this is all correct -- just not what the user, IMO, would expect.
For instance, there is no mention of 'vector_type' here (and none in
the debug info anywhere, to my surprise).
'whatis' also gives somewhat unfriendly results -- fully expanding
std::string and std::vector.
By default, I think, ptype and whatis should give what the source
shows -- typedefs in place, defaulted template arguments omitted, etc.
However, on occasion it is nice to see the full expansion. So, that
is why I think some kind of verbosity control is needed.
I think it may also be handy to have a mode that omits methods from
the type. I don't know how important this is.
All of this is contingent on g++ emitting usable info, though.
I filed a bug for this: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=37590
I can send out Benjamin's other (two) tests if anybody wants them.
Tom
#include <string>
#include <utility>
#include <vector>
// 02, more complex types
template<typename T1, typename T2, typename T3>
struct functor
{
void
operator()()
{
std::size_t s1 = one.size();
std::size_t s2 = two.size();
std::size_t s3 = three;
}
private:
T1 one;
T2 two;
T3 three;
};
int main()
{
typedef std::vector<std::string> vector_type;
typedef functor<std::string, vector_type, int> functor_type;
functor_type f;
f();
return 0;
}