gobject/gobject.py

   1 import os.path
   2 import gdb
   3 import glib
   4 import sys
   5
   6 if sys.version_info[0] >= 3:
   7     long = int
   8
   9 try:
  10     import gdb.backtrace
  11     import gdb.command.backtrace
  12 except ImportError:
  13     print(os.path.basename(__file__) + ": gdb was not built with "
  14           "custom backtrace support, disabling.")
  15     HAVE_GDB_BACKTRACE = 0
  16 else:
  17     HAVE_GDB_BACKTRACE = 1
  18
  19 # This is not quite right, as local vars may override symname
  20 def read_global_var (symname):
  21     return gdb.selected_frame().read_var(symname)
  22
  23 def g_type_to_name (gtype):
  24     def lookup_fundamental_type (typenode):
  25         if typenode == 0:
  26             return None
  27         val = read_global_var ("static_fundamental_type_nodes")
  28         if val == None:
  29             return None
  30         return val[typenode >> 2].address()
  31
  32     gtype = long(gtype)
  33     typenode = gtype - gtype % 4
  34     if typenode > (255 << 2):
  35         typenode = gdb.Value(typenode).cast (gdb.lookup_type("TypeNode").pointer())
  36     else:
  37         typenode = lookup_fundamental_type (typenode)
  38     if typenode != None:
  39         return glib.g_quark_to_string (typenode["qname"])
  40     return None
  41
  42 def is_g_type_instance (val):
  43     def is_g_type_instance_helper (type):
  44         if str(type) == "GTypeInstance":
  45             return True
  46
  47         while type.code == gdb.TYPE_CODE_TYPEDEF:
  48             type = type.target()
  49
  50         if type.code != gdb.TYPE_CODE_STRUCT:
  51             return False
  52
  53         fields = type.fields()
  54         if len (fields) < 1:
  55             return False
  56
  57         first_field = fields[0]
  58         return is_g_type_instance_helper(first_field.type)
  59
  60     type = val.type
  61     if type.code != gdb.TYPE_CODE_PTR:
  62         return False
  63     type = type.target()
  64     return is_g_type_instance_helper (type)
  65
  66 def g_type_name_from_instance (instance):
  67     if long(instance) != 0:
  68         try:
  69             inst = instance.cast (gdb.lookup_type("GTypeInstance").pointer())
  70             klass = inst["g_class"]
  71             gtype = klass["g_type"]
  72             name = g_type_to_name (gtype)
  73             return name
  74         except RuntimeError:
  75             pass
  76     return None
  77
  78 class GTypePrettyPrinter:
  79     "Prints a GType instance pointer"
  80
  81     def __init__ (self, val):
  82         self.val = val
  83
  84     def to_string (self):
  85         name = g_type_name_from_instance (self.val)
  86         if name:
  87             return ("0x%x [%s]")% (long(self.val), name)
  88         return  ("0x%x") % (long(self.val))
  89
  90 def pretty_printer_lookup (val):
  91     if is_g_type_instance (val):
  92         return GTypePrettyPrinter (val)
  93
  94     return None
  95
  96 def get_signal_name (id):
  97     if id == None:
  98         return None
  99     id = long(id)
 100     if id == 0:
 101         return None
 102     val = read_global_var ("g_signal_nodes")
 103     max_s = read_global_var ("g_n_signal_nodes")
 104     max_s = long(max_s)
 105     if id < max_s:
 106         return val[id]["name"].string()
 107     return None
 108
 109 class DummyFrame:
 110     def __init__ (self, frame):
 111         self.frame = frame
 112
 113     def name (self):
 114         return "signal-emission-dummy"
 115
 116     def describe (self, stream, full):
 117         stream.write (" <...>\n")
 118
 119     def __getattr__ (self, name):
 120         return getattr (self.frame, name)
 121
 122 class SignalFrame:
 123     def __init__ (self, frames):
 124         self.frame = frames[-1]
 125         self.frames = frames
 126
 127     def name (self):
 128         return "signal-emission"
 129
 130     def read_var (self, frame, name, array = None):
 131         try:
 132             v = frame.read_var (name)
 133             if v == None or v.is_optimized_out:
 134                 return None
 135             if array != None:
 136                 array.append (v)
 137             return v
 138         except ValueError:
 139             return None
 140
 141     def read_object (self, frame, name, array = None):
 142         try:
 143             v = frame.read_var (name)
 144             if v == None or v.is_optimized_out:
 145                 return None
 146             v = v.cast (gdb.lookup_type("GObject").pointer())
 147             # Ensure this is a somewhat correct object pointer
 148             if v != None and g_type_name_from_instance (v):
 149                 if array != None:
 150                     array.append (v)
 151                 return v
 152             return None
 153         except ValueError:
 154             return None
 155
 156     def append (self, array, obj):
 157         if obj != None:
 158             array.append (obj)
 159
 160     def or_join_array (self, array):
 161         if len(array) == 0:
 162             return "???"
 163
 164         v = {}
 165         for i in range(len(array)):
 166             v[str(array[i])] = 1
 167         array = v.keys()
 168         s = array[0]
 169         for i in range(1, len(array)):
 170             s = s + " or %s"%array[i]
 171
 172         return s
 173
 174     def get_detailed_signal_from_frame(self, frame, signal):
 175         detail = self.read_var (frame, "detail")
 176         detail = glib.g_quark_to_string (detail)
 177         if detail is not None:
 178             return signal + ":" + detail
 179         else:
 180             return detail
 181
 182     def describe (self, stream, full):
 183         instances = []
 184         signals = []
 185
 186         for frame in self.frames:
 187             name = frame.name()
 188             if name == "signal_emit_unlocked_R":
 189                 self.read_object (frame, "instance", instances)
 190                 node = self.read_var (frame, "node")
 191                 if node:
 192                     signal = node["name"].string()
 193                     signal = self.get_detailed_signal_from_frame(frame, signal)
 194                     self.append(signals, signal)
 195
 196             if name == "g_signal_emitv":
 197                 instance_and_params = self.read_var (frame, "instance_and_params")
 198                 if instance_and_params:
 199                     instance = instance_and_params[0]["v_pointer"].cast (gdb.Type("GObject").pointer())
 200                     self.append (instances, instance)
 201                 id = self.read_var (frame, "signal_id")
 202                 signal = get_signal_name (id)
 203                 if signal:
 204                     signal = self.get_detailed_signal_from_frame(frame, signal)
 205                     self.append (signals, signal)
 206
 207             if name == "g_signal_emit_valist" or name == "g_signal_emit":
 208                 self.read_object (frame, "instance", instances)
 209                 id = self.read_var (frame, "signal_id")
 210                 signal = get_signal_name (id)
 211                 if signal:
 212                     signal = self.get_detailed_signal_from_frame(frame, signal)
 213                     self.append (signals, signal)
 214
 215             if name == "g_signal_emit_by_name":
 216                 self.read_object (frame, "instance", instances)
 217                 self.read_var (frame, "detailed_signal", signals)
 218                 break
 219
 220         instance = self.or_join_array (instances)
 221         signal = self.or_join_array (signals)
 222
 223         stream.write (" <emit signal %s on instance %s>\n" %  (signal, instance))
 224
 225     def __getattr__ (self, name):
 226         return getattr (self.frame, name)
 227
 228 class GFrameFilter:
 229     def __init__ (self, iter):
 230         self.queue = []
 231         self.iter = iter
 232
 233     def __iter__ (self):
 234         return self
 235
 236     def fill (self):
 237         while len(self.queue) <= 6:
 238             try:
 239                 f = self.iter.next ()
 240                 self.queue.append (f)
 241             except StopIteration:
 242                 return
 243
 244     def find_signal_emission (self):
 245         for i in range (min (len(self.queue), 3)):
 246             if self.queue[i].name() == "signal_emit_unlocked_R":
 247                 return i
 248         return -1
 249
 250     def next (self):
 251         # Ensure we have enough frames for a full signal emission
 252         self.fill()
 253
 254         # Are we at the end?
 255         if len(self.queue) == 0:
 256             raise StopIteration
 257
 258         emission = self.find_signal_emission ()
 259         if emission > 0:
 260             start = emission
 261             while True:
 262                 if start == 0:
 263                     break
 264                 prev_name = self.queue[start-1].name()
 265                 if prev_name.find("_marshal_") or prev_name == "g_closure_invoke":
 266                     start = start - 1
 267                 else:
 268                     break
 269             end = emission + 1
 270             while end < len(self.queue):
 271                 if self.queue[end].name() in ["g_signal_emitv",
 272                                               "g_signal_emit_valist",
 273                                               "g_signal_emit",
 274                                               "g_signal_emit_by_name"]:
 275                     end = end + 1
 276                 else:
 277                     break
 278
 279             signal_frames = self.queue[start:end]
 280             new_frames = []
 281             for i in range(len(signal_frames)-1):
 282                 new_frames.append(DummyFrame(signal_frames[i]))
 283             new_frames.append(SignalFrame(signal_frames))
 284
 285             self.queue[start:end] = new_frames
 286
 287         return self.queue.pop(0)
 288
 289
 290 def register (obj):
 291     if obj == None:
 292         obj = gdb
 293
 294     if HAVE_GDB_BACKTRACE:
 295         gdb.backtrace.push_frame_filter (GFrameFilter)
 296     obj.pretty_printers.append(pretty_printer_lookup)