python脚本:任何在C/ c++ struct字段中迭代的示例

The new GDB-Python scripting API looks quite powerful and should be very useful. However writing a useful script to iterate through the fields in a struct of C or C++ is not trivial. Does any one know some solid samples that does exactly that?

新的GDB-Python脚本API看起来非常强大，应该非常有用。然而，编写一个有用的脚本来迭代C或c++结构中的字段并不容易。有谁知道确切的固体样品吗?

Thanks in advance.

提前谢谢。

Update the final sample: Replace the _print_fields() in early sample.

更新最终的示例:在早期的示例中替换_print_fields()。

    if l.type.code == gdb.TYPE_CODE_STRUCT:
        print "Found a struct  %s " % n
        #self._print_fields(n, t)
        self._print_deep_items(n, t, l)
    else:
        print "Found no struct"

def _print_deep_items (self, n_, type_, instance_):
    for fld in type_.fields():
        fn = fld.name
        ft = fld.type
        fv = instance_[fn]
        if fv.type.code == gdb.TYPE_CODE_STRUCT:
            print "  Found a sub struct  %s " % fn
            self._print_deep_items(fn, ft, fv)
        else:
            print "    Field %s " % fn, " type %s " % ft.tag, " value %s " % fv

And the output:

和输出:

  variable s1   type S1
Found a struct  s1
    Field v1   type None   value 0
    Field v2   type None   value 0
  Found a sub struct  v3
    Field w3   type None   value 0

Update with the first sample: Got the following sample code working. This is not the optimal as it does a look-up on every field after composing the string field name. abarnert is showing a promising and elegant approach, the working code is updated in the above final update section.

使用第一个示例进行更新:使以下示例代码正常工作。这并不是最优的，因为它在组合字符串字段名之后对每个字段进行查找。abarnert展示了一种有前途和优雅的方法，工作代码在上面的最后更新部分中更新。

import gdb
class PrintGList(gdb.Command):
    """print fields of a struct: wzd struct_object

Iterate through the fields of a struct, and display
a human-readable form of the objects."""
    def __init__(self):
        gdb.Command.__init__(self, "wzd", gdb.COMMAND_DATA, gdb.COMPLETE_SYMBOL, True)

    def invoke(self, arg, from_tty):

        arg_list = gdb.string_to_argv(arg)
        if len(arg_list) < 1:
            print "usage: wzd struct"
            return

        n = arg_list[0]
        l = gdb.parse_and_eval(arg_list[0])
        m = l.type.tag

        print "  variable %s " % n, " type %s " % m
        try:
            t = gdb.lookup_type(m)
        except RuntimeError, e:
            print "type %s not found" % t
            return

        if l.type.code == gdb.TYPE_CODE_STRUCT:
            print "Found a struct  %s " % n
            self._print_fields(n, t)
        else:
            print "Found no struct"

    def _print_fields(self, n, typeobject):
        print typeobject
        flds = typeobject.fields()
        for x in flds:
            sn = n + "." + x.name
            print "  field %s" % sn, " code %s " % x.type.code, " type %s " % x.type.tag
            if x.type.code == gdb.TYPE_CODE_STRUCT:
                print "Found sub level struct  %s " % sn
                sl = gdb.parse_and_eval(sn)
                sm = sl.type.tag
                st = gdb.lookup_type( sm )
                self._print_fields(sn, x.type)

    def _deep_items (self, type_):
        for k, v in type_.iteritems():
            if k:
                print " k v %s " % k , " %s " % v
            else:
                print "   v    ",      " %s " % v

PrintGList()

The source file to test with:

要测试的源文件:

struct S2 {        int w3;    };
struct S1 {        int v1, v2;      struct S2 v3; } s1;
int main(int argc, char *argv[]) {   return 0; }

Example output:

示例输出:

  variable s1   type S1
Found a struct  s1
S1
  field s1.v1  typecode 8   type None
  field s1.v2  typecode 8   type None
  field s1.v3  typecode 3   type S2
Found sub level struct  s1.v3
S2
  field s1.v3.w3  typecode 8   type None

GDB session to get the: source /home/me/testpath/wzdfile.py file a.out b main r wzd s1 quit

GDB会话获取:source /home/ me/testpath/wzdfile.com。py文件。主r退出

1 个解决方案

#1

According to the docs, iterating through the fields of a C struct should be pretty trivial:

根据文档，遍历C struct的字段应该非常简单:

If the type is a structure or class type, or an enum type, the fields of that type can be accessed using the Python dictionary syntax. For example, if some_type is a gdb.Type instance holding a structure type, you can access its foo field with:

如果类型是结构或类类型，或枚举类型，则可以使用Python字典语法访问该类型的字段。例如，如果some_type是gdb。类型实例持有结构类型，您可以通过以下方式访问其foo字段:
bar = some_type['foo']
bar will be a gdb.Field object; see below under the description of the Type.fields method for a description of the gdb.Field class.

bar是gdb。领域对象;请参阅下面的类型描述。用于描述gdb的字段方法。领域类。

You can also use Type.fields to get the fields of a struct explicitly, but (as of 7.4) you can just use the normal dict methods as well, so to get a list of name/Field pairs:

您还可以使用Type。字段以显式地获取结构体的字段，但是(从7.4开始)您也可以使用普通的dict method，以便获得名称/字段对的列表:

for name, field in foo.type.iteritems():

Or, for just the names:

或者，仅仅是名字:

for name, field in foo.type.iterkeys():

And so on.

等等。

This doesn't seem to be directly documented on that page, but gdb.types implies it pretty strongly when it says that deep_items:

这似乎没有直接记录在页面上，但是gdb。当它说deep_items:

Returns a Python iterator similar to the standard gdb.Type.iteritems method.

返回类似于标准gdb.Type的Python迭代器。iteritems方法。

For example, given this C type:

例如，给定这个C类型:

struct S {
    int x;
    int y;
};

You can do this:

你可以这样做:

(gdb) python struct_S = my_s.type # or gdb.lookup_type("struct S"), etc.
(gdb) python print struct_S.keys()
{['a', 'b']}
(gdb) python print my_s['a']
0

From a quick glance at the types.py source, look at how gdb.types.deep_item(type_) is implemented, and that does seem to be all there is to it.

快速浏览一下类型。py source，看看gdb.types.deep_item(type_)是如何实现的，这似乎就是它的全部。

Before gdb 7.4, you could not treat a type directly as a dict. That is, no for name in instance_.type: or instance_.type.iteritems(), etc. You had to explicitly call fields. Anyway, putting it all together, here's a simple example for iterating over all of the fields of a structure with gdb 7.2:

在gdb 7.4之前，您不能将类型直接视为一个命令，即instance_中的name为no。类型:或instance_.type.iteritems()等，您必须显式地调用字段。总之，把它们放在一起，这里有一个简单的例子用gdb 7.2遍历结构的所有字段:

for field in inst.fields:
    fname = field.name
    ftype = field.type
    fval = inst[fname]

Except that this won't work if your struct has an anonymous struct inside it. For that, you'll need deep_items (and, if that isn't there in 7.2, you'll need to look at the code and figure out how to implement it yourself).

但是，如果您的结构体内部有一个匿名结构体，这将无法工作。为此，您将需要deep_items(如果7.2中没有的话，您将需要查看代码并了解如何自己实现它)。

So, not quite trivial in 7.2, but pretty simple. And, if you want trivial, just upgrade to 7.4.

不是很平凡的7。2，但是很简单。如果你想要小的，就升级到7.4。

#1