用ptype显示GDB中的所有C ++数据字段（甚至继承）

Question

In a C++11 program (compiled with GCC 5 on Linux/Debian/x86-64, with g++ -Og -g3 -Wall -std=c++11 b.cc -o bprog ), when you have a class hierarchy such as in this file b.cc :

  #include <string>
  #include <vector>
  class A {
    int a1i;
    double a2d;
  public:
    A(int x, double y) : a1i(x), a2d(y) {};
    ~A() = default;
  };

  class B : public A {
    std::string b1s;
    int b2ii[2];
    std::vector<long> b3vl;
  public:
    B (int x, double y, const char*s, int a, int b)
      : A(x,y), b1s(s), b2ii{a,b},
        b3vl{x,a,b,x+a,a*b} {};
    ~B() = default;
  };

  int main(int argc, char**argv) {
    B bobj {1,2.1,"bname",3,4};
    return 0;
  }      

and using a recent GDB (ie 7.10) I would like to display all the data fields (perhaps even the vtable pointer[s], if there is some) of the type. Using the ptype command is not extremely helpful (because inherited fields are not displayed):

 (gdb) ptype B
  type = class B : public A {
    private:
      std::__cxx11::string b1s;
      int b2ii[2];
      std::vector<long, std::allocator<long> > b3vl;

    public:
      B(int, double, const char *, int, int);
      ~B(int);
  }      

Most of the motivation is that I am interfacing to GCCJIT (or perhaps some other JIT library, but probably GCCJIT), and of course a JITing code need to know implementation details like types and offsets of every data field. If you are interested in more details, see this thread .

For example, a read access to bobj.b3vl[i] should be inlined by the JIT-er, so I need to understand the machine layout ...

I am aware that the fields inside C++ standard containers and strings are implementation specific (but I do know that they don't vary that much, but a tiny bit, in practice)

Do you have any trick or tips to get all that (field name, type, and perhaps offset) information easily thru GDB (including for inherited fields)?

Answer 1

I don't think there is a way to do this that is built in to gdb. See this gdb feature request .

However, it can be done relatively easily from Python. If you have the pahole gdb command (not part of upstream gdb, but shipped in Fedora at least), that will do the trick (though it seems to generate really ugly output right now). It will at least show how the code could be written.