python.pahole.Pahole Class Reference

Inheritance diagram for python.pahole.Pahole:

Collaboration diagram for python.pahole.Pahole:

Public Member Functions
def	__init__ (self)
def	pahole (self, atype, level, name, walk=False, nested=False)
def	invoke (self, arg, from_tty)

Detailed Description

Show the holes in a structure.
This command takes a single argument, a type name.
It prints the type and displays comments showing where holes are.

Definition at line 27 of file pahole.py.

Constructor & Destructor Documentation

__init__()

def python.pahole.Pahole.__init__

(

self

)

Definition at line 32 of file pahole.py.

    def __init__ (self):
        super (Pahole, self).__init__ ("pahole", gdb.COMMAND_DATA,
                                       gdb.COMPLETE_SYMBOL)
 

Member Function Documentation

invoke()

def python.pahole.Pahole.invoke	(		self,
			arg,
			from_tty
	)

Definition at line 96 of file pahole.py.

    def invoke (self, arg, from_tty):
        argv = gdb.string_to_argv(arg)
        if len(argv) > 2:
            raise gdb.GdbError('pahole takes a type name and an optional "walk" argument.')
        stype = gdb.lookup_type (argv[0])
        ptype = stype.strip_typedefs()
        if ptype.code != gdb.TYPE_CODE_STRUCT and ptype.code != gdb.TYPE_CODE_UNION:
            raise gdb.GdbError('%s is not a struct/union type: %s' % (arg, ptype.code))
 
        # Should the entire object be walked recursively?
        walk = len(argv) > 1 and argv[1] == "walk"
 
        self.pahole (ptype, 0, argv[0], walk=walk)
 
Pahole()

pahole()

def python.pahole.Pahole.pahole	(		self,
			atype,
			level,
			name,
			walk = False,
			nested = False
	)

Definition at line 36 of file pahole.py.

    def pahole (self, atype, level, name, walk=False, nested=False):
        if name is None:
            name = ''
        tag = atype.tag
        if tag is None:
            tag = ''
        kind = 'struct' if atype.code == gdb.TYPE_CODE_STRUCT else 'union'
        if not nested:
            print ('/* %4d 0x%04x     */ ' % (atype.sizeof, atype.sizeof), end="")
        print ('%s%s %s {' % ( ' ' * (2 * level), kind, tag))
        endpos = 0
        for field in atype.fields():
            # Skip static fields
            if not hasattr (field, ('bitpos')):
                continue
            # find the type
            ftype = field.type.strip_typedefs()
 
            # Detect hole
            if endpos < field.bitpos:
                hole = field.bitpos - endpos
                print ('/* XXX       %4d */ !!' % (hole // 8), end="")
                print (' ' * (4 + 2 * level - 2), end="")
                print ('char [%d] __%d_bit_padding__' % (math.ceil(hole / 8), hole))
 
            # Are we a bitfield?
            if field.bitsize > 0:
                fieldsize = field.bitsize
            else:
                if (ftype.code == gdb.TYPE_CODE_STRUCT or ftype.code == gdb.TYPE_CODE_UNION) and len(ftype.fields()) == 0:
                    fieldsize = 0 # empty struct
                else:
                    fieldsize = 8 * ftype.sizeof # will get packing wrong for structs
 
            print ('/* %3d 0x%03x %4d */ ' % (field.bitpos // 8, field.bitpos // 8, fieldsize // 8), end="")
            endpos = field.bitpos + fieldsize
 
            # Walk nested structure or print variable size (this is not a hole)
            if walk and (ftype.code == gdb.TYPE_CODE_STRUCT or ftype.code == gdb.TYPE_CODE_UNION):
                print ('  ', end="")
                self.pahole (ftype, level + 1, field.name, walk=walk, nested=True)
            else:
                print (' ' * (4 + 2 * level), end="")
                print ('%s %s' % (str (ftype), field.name),end="")
                # Append bitfield size if non-standard
                if fieldsize != ftype.sizeof * 8:
                    print (':%d' % fieldsize)
                else:
                    print ('')
 
        # Check for padding at the end
        if endpos // 8 < atype.sizeof:
            hole = 8 * atype.sizeof - endpos
            print ('/* XXX %4d */ !!' % hole, end="")
            print (' ' * (4 + 2 * level - 2), end="")
            print ('char [%d] __%d_bit_padding__' % (math.ceil(hole / 8), hole))
 
        print (' ' * (14 + 2 * level), end="")
        print (' } %s' % name)
 

---

The documentation for this class was generated from the following file:

• pahole.py