tools/lldbmacros/structanalyze.py

   1 import lldb
   2 from xnu import *
   3
   4 _UnionStructClass = [ lldb.eTypeClassStruct, lldb.eTypeClassClass, lldb.eTypeClassUnion ]
   5
   6 def _showStructPacking(O, symbol, begin_offset=0, symsize=0, typedef=None, outerSize=0, memberName=None):
   7     """
   8        recursively parse the field members of structure.
   9        params : O the output formatter (standard.py)
  10                 symbol (lldb.SBType) reference to symbol in binary
  11        returns: string containing lines of output.
  12     """
  13     ctype = "unknown type"
  14     is_union = False
  15     is_class = False
  16     union_size = None
  17     sym_size = symbol.GetByteSize()
  18
  19     if symbol.GetTypeClass() == lldb.eTypeClassUnion:
  20         ctype = "union"
  21         is_union = True
  22         union_size = sym_size
  23     if symbol.GetTypeClass() == lldb.eTypeClassStruct:
  24         ctype = "struct"
  25     if symbol.GetTypeClass() == lldb.eTypeClassClass:
  26         ctype = "class"
  27         is_class = True
  28
  29     if not outerSize or outerSize == sym_size:
  30         outstr = O.format("{:04d},[{:4d}]", begin_offset, sym_size)
  31     elif outerSize < sym_size: # happens with c++ inheritance
  32         outstr = O.format("{:04d},[{:4d}]", begin_offset, outerSize)
  33     else:
  34         outstr = O.format("{:04d},[{:4d}]{VT.DarkRed}{{{:+d}}}{VT.Default}",
  35                 begin_offset, sym_size, outerSize - sym_size)
  36
  37     if typedef:
  38         outstr += O.format(" {0}", typedef)
  39     if symbol.IsAnonymousType():
  40         outstr += O.format(" ({VT.DarkMagenta}anonymous {0}{VT.Default})", ctype)
  41     else:
  42         outstr += O.format(" ({VT.DarkMagenta}{0} {1}{VT.Default})", ctype, symbol.GetName())
  43     if memberName:
  44         outstr += O.format(" {0} {{", memberName)
  45     else:
  46         outstr += ") {"
  47
  48     print outstr
  49
  50     with O.indent():
  51         _previous_size = 0
  52         _packed_bit_offset = 0
  53         _nfields = symbol.GetNumberOfFields()
  54
  55         if is_class:
  56             _next_offset_in_bits = 0
  57             _nclasses = symbol.GetNumberOfDirectBaseClasses()
  58
  59             for i in range(_nclasses):
  60                 member = symbol.GetDirectBaseClassAtIndex(i)
  61                 if i < _nclasses - 1:
  62                     m_size_bits = symbol.GetDirectBaseClassAtIndex(i + 1).GetOffsetInBits()
  63                 elif _nfields:
  64                     m_size_bits = symbol.GetFieldAtIndex(0).GetOffsetInBits()
  65                 else:
  66                     m_size_bits = symbol.GetByteSize() * 8
  67
  68                 m_offset = member.GetOffsetInBytes() + begin_offset
  69                 m_type = member.GetType()
  70                 m_name = member.GetName()
  71                 m_size = m_size_bits / 8
  72
  73                 _previous_size = m_size
  74                 _packed_bit_offset = member.GetOffsetInBits() + m_size_bits
  75
  76                 _showStructPacking(O, m_type, m_offset, str(m_type), outerSize=m_size, memberName=m_name)
  77
  78         for i in range(_nfields):
  79             member = symbol.GetFieldAtIndex(i)
  80             m_offset = member.GetOffsetInBytes() + begin_offset
  81             m_offset_bits = member.GetOffsetInBits()
  82
  83             m_type = member.GetType()
  84             m_name = member.GetName()
  85             m_size = m_type.GetByteSize()
  86
  87             if member.IsBitfield():
  88                 m_is_bitfield = True
  89                 m_size_bits = member.GetBitfieldSizeInBits()
  90             else:
  91                 m_is_bitfield = False
  92                 m_size_bits = m_size * 8
  93
  94             if not is_union and _packed_bit_offset < m_offset_bits:
  95                 m_previous_offset = begin_offset + _packed_bit_offset / 8
  96                 m_hole_bits = m_offset_bits - _packed_bit_offset
  97                 if _packed_bit_offset % 8 == 0:
  98                     print O.format("{:04d},[{:4d}] ({VT.DarkRed}*** padding ***{VT.Default})",
  99                             m_previous_offset, m_hole_bits / 8)
 100                 else:
 101                     print O.format("{:04d},[{:4d}] ({VT.Brown}*** padding : {:d} ***{VT.Default})",
 102                             m_previous_offset, _previous_size, m_hole_bits)
 103
 104             _previous_size = m_size
 105             _packed_bit_offset = m_offset_bits + m_size_bits
 106
 107             _type_class = m_type.GetTypeClass()
 108             _canonical_type = m_type.GetCanonicalType()
 109             _canonical_type_class = m_type.GetCanonicalType().GetTypeClass()
 110
 111             if _type_class == lldb.eTypeClassTypedef and _canonical_type_class in _UnionStructClass:
 112                 _showStructPacking(O, _canonical_type, m_offset, str(m_type), outerSize=union_size, memberName=m_name)
 113             elif _type_class in _UnionStructClass:
 114                 _showStructPacking(O, m_type, m_offset, outerSize=union_size, memberName=m_name)
 115             else:
 116                 outstr = O.format("{:04d},[{:4d}]", m_offset, m_size)
 117                 if is_union and union_size != m_size_bits / 8:
 118                     outstr += O.format("{VT.DarkRed}{{{:+d}}}{VT.Default}",
 119                             union_size - m_size_bits / 8)
 120                 if m_is_bitfield:
 121                     outstr += O.format(" ({VT.DarkGreen}{:s} : {:d}{VT.Default}) {:s}",
 122                             m_type.GetName(), m_size_bits, m_name)
 123                 else:
 124                     outstr += O.format(" ({VT.DarkGreen}{:s}{VT.Default}) {:s}",
 125                             m_type.GetName(), m_name)
 126                 print outstr
 127
 128         referenceSize = min(outerSize, sym_size) or sym_size
 129         if not is_union and _packed_bit_offset < referenceSize * 8:
 130             m_previous_offset = begin_offset + _packed_bit_offset / 8
 131             m_hole_bits = referenceSize * 8 - _packed_bit_offset
 132             offset = _packed_bit_offset / 8 + begin_offset
 133             if _packed_bit_offset % 8 == 0:
 134                 print O.format("{:04d},[{:4d}] ({VT.DarkRed}*** padding ***{VT.Default})",
 135                         m_previous_offset, m_hole_bits / 8)
 136             else:
 137                 print O.format("{:04d},[{:4d}] ({VT.Brown}padding : {:d}{VT.Default})\n",
 138                         m_previous_offset, _previous_size, m_hole_bits)
 139
 140     print "}"
 141
 142 @lldb_command('showstructpacking', fancy=True)
 143 def showStructInfo(cmd_args=None, cmd_options={}, O=None):
 144     """Show how a structure is packed in the binary. The format is
 145        <offset>, [<size_of_member>] (<type>) <name>
 146
 147        For example:
 148           (lldb) showstructpacking pollfd
 149              0,[   8] struct pollfd {
 150                  0,[   4] (int) fd
 151                  4,[   2] (short) events
 152                  6,[   2] (short) revents
 153           }
 154
 155       syntax: showstructpacking task
 156     """
 157     if not cmd_args:
 158         raise ArgumentError("Please provide a type name.")
 159
 160     ty_name = cmd_args[0]
 161     try:
 162         sym = gettype(ty_name)
 163     except NameError:
 164         return O.error("Cannot find type named {0}", ty_name)
 165
 166     if sym.GetTypeClass() == lldb.eTypeClassTypedef:
 167         sym = sym.GetCanonicalType()
 168
 169     if sym.GetTypeClass() not in _UnionStructClass:
 170         return O.error("{0} is not a structure/union/class type", ty_name)
 171
 172     _showStructPacking(O, sym, 0)
 173
 174 # EndMacro: showstructinto