| import os.path |
| import gdb |
| import glib_gdb |
| import sys |
| |
| if sys.version_info[0] >= 3: |
| long = int |
| else: |
| import itertools |
| map = itertools.imap |
| |
| # FrameDecorator is new in gdb 7.7, so we adapt to its absence. |
| try: |
| import gdb.FrameDecorator |
| HAVE_GDB_FRAMEDECORATOR = True |
| FrameDecorator = gdb.FrameDecorator.FrameDecorator |
| except ImportError: |
| HAVE_GDB_FRAMEDECORATOR = False |
| |
| # This is not quite right, as local vars may override symname |
| def read_global_var (symname): |
| return gdb.selected_frame().read_var(symname) |
| |
| def g_type_to_name (gtype): |
| def lookup_fundamental_type (typenode): |
| if typenode == 0: |
| return None |
| val = read_global_var ("static_fundamental_type_nodes") |
| if val == None: |
| return None |
| return val[typenode >> 2].address() |
| |
| gtype = long(gtype) |
| typenode = gtype - gtype % 4 |
| if typenode > (255 << 2): |
| typenode = gdb.Value(typenode).cast (gdb.lookup_type("TypeNode").pointer()) |
| else: |
| typenode = lookup_fundamental_type (typenode) |
| if typenode != None: |
| return glib_gdb.g_quark_to_string (typenode["qname"]) |
| return None |
| |
| def is_g_type_instance (val): |
| def is_g_type_instance_helper (type): |
| if str(type) == "GTypeInstance": |
| return True |
| |
| while type.code == gdb.TYPE_CODE_TYPEDEF: |
| type = type.target() |
| |
| if type.code != gdb.TYPE_CODE_STRUCT: |
| return False |
| |
| fields = type.fields() |
| if len (fields) < 1: |
| return False |
| |
| first_field = fields[0] |
| return is_g_type_instance_helper(first_field.type) |
| |
| type = val.type |
| if type.code != gdb.TYPE_CODE_PTR: |
| return False |
| type = type.target() |
| return is_g_type_instance_helper (type) |
| |
| def g_type_name_from_instance (instance): |
| if long(instance) != 0: |
| try: |
| inst = instance.cast (gdb.lookup_type("GTypeInstance").pointer()) |
| klass = inst["g_class"] |
| gtype = klass["g_type"] |
| name = g_type_to_name (gtype) |
| return name |
| except RuntimeError: |
| pass |
| return None |
| |
| class GTypePrettyPrinter: |
| "Prints a GType instance pointer" |
| |
| def __init__ (self, val): |
| self.val = val |
| |
| def to_string (self): |
| name = g_type_name_from_instance (self.val) |
| if name: |
| return ("0x%x [%s]")% (long(self.val), name) |
| return ("0x%x") % (long(self.val)) |
| |
| def pretty_printer_lookup (val): |
| if is_g_type_instance (val): |
| return GTypePrettyPrinter (val) |
| |
| return None |
| |
| def get_signal_name (id): |
| if id == None: |
| return None |
| id = long(id) |
| if id == 0: |
| return None |
| val = read_global_var ("g_signal_nodes") |
| max_s = read_global_var ("g_n_signal_nodes") |
| max_s = long(max_s) |
| if id < max_s: |
| return val[id]["name"].string() |
| return None |
| |
| def frame_name(frame): |
| return str(frame.function()) |
| |
| def frame_var(frame, var): |
| return frame.inferior_frame().read_var(var) |
| |
| |
| class SignalFrame(FrameDecorator): |
| def __init__ (self, frames): |
| FrameDecorator.__init__(self, frames[-1]) |
| self.frame = frames[-1] |
| self.frames = frames |
| |
| def name (self): |
| return "signal-emission" |
| |
| def read_var (self, frame, name, array = None): |
| try: |
| v = frame_var (frame, name) |
| if v == None or v.is_optimized_out: |
| return None |
| if array != None: |
| array.append (v) |
| return v |
| except ValueError: |
| return None |
| |
| def read_object (self, frame, name, array = None): |
| try: |
| v = frame_var (frame, name) |
| if v == None or v.is_optimized_out: |
| return None |
| v = v.cast (gdb.lookup_type("GObject").pointer()) |
| # Ensure this is a somewhat correct object pointer |
| if v != None and g_type_name_from_instance (v): |
| if array != None: |
| array.append (v) |
| return v |
| return None |
| except ValueError: |
| return None |
| |
| def append (self, array, obj): |
| if obj != None: |
| array.append (obj) |
| |
| def or_join_array (self, array): |
| if len(array) == 0: |
| return "???" |
| else: |
| return ' or '.join(set(map(str, array))) |
| |
| def get_detailed_signal_from_frame(self, frame, signal): |
| detail = self.read_var (frame, "detail") |
| detail = glib_gdb.g_quark_to_string (detail) |
| if detail is not None: |
| return signal + ":" + detail |
| else: |
| return detail |
| |
| def function (self): |
| instances = [] |
| signals = [] |
| |
| for frame in self.frames: |
| name = frame_name(frame) |
| if name == "signal_emit_unlocked_R": |
| self.read_object (frame, "instance", instances) |
| node = self.read_var (frame, "node") |
| if node: |
| signal = node["name"].string() |
| signal = self.get_detailed_signal_from_frame(frame, signal) |
| self.append(signals, signal) |
| |
| if name == "g_signal_emitv": |
| instance_and_params = self.read_var (frame, "instance_and_params") |
| if instance_and_params: |
| instance = instance_and_params[0]["v_pointer"].cast (gdb.Type("GObject").pointer()) |
| self.append (instances, instance) |
| id = self.read_var (frame, "signal_id") |
| signal = get_signal_name (id) |
| if signal: |
| signal = self.get_detailed_signal_from_frame(frame, signal) |
| self.append (signals, signal) |
| |
| if name == "g_signal_emit_valist" or name == "g_signal_emit": |
| self.read_object (frame, "instance", instances) |
| id = self.read_var (frame, "signal_id") |
| signal = get_signal_name (id) |
| if signal: |
| signal = self.get_detailed_signal_from_frame(frame, signal) |
| self.append (signals, signal) |
| |
| if name == "g_signal_emit_by_name": |
| self.read_object (frame, "instance", instances) |
| self.read_var (frame, "detailed_signal", signals) |
| break |
| |
| instance = self.or_join_array (instances) |
| signal = self.or_join_array (signals) |
| |
| return "<emit signal %s on instance %s>" % (signal, instance) |
| |
| def elided (self): |
| return self.frames[0:-1] |
| |
| def describe (self, stream, full): |
| stream.write (" " + self.function () + "\n") |
| |
| class GFrameDecorator: |
| def __init__ (self, iter): |
| self.queue = [] |
| self.iter = iter |
| |
| def __iter__ (self): |
| return self |
| |
| def fill (self): |
| while len(self.queue) <= 8: |
| try: |
| f = next(self.iter) |
| self.queue.append (f) |
| except StopIteration: |
| return |
| |
| def find_signal_emission (self): |
| for i in range (min (len(self.queue), 3)): |
| if frame_name(self.queue[i]) == "signal_emit_unlocked_R": |
| return i |
| return -1 |
| |
| def next (self): |
| # Ensure we have enough frames for a full signal emission |
| self.fill() |
| |
| # Are we at the end? |
| if len(self.queue) == 0: |
| raise StopIteration |
| |
| emission = self.find_signal_emission () |
| if emission > 0: |
| start = emission |
| while True: |
| if start == 0: |
| break |
| prev_name = frame_name(self.queue[start-1]) |
| if prev_name.find("_marshal_") >= 0 or prev_name == "g_closure_invoke": |
| start = start - 1 |
| else: |
| break |
| end = emission + 1 |
| while end < len(self.queue): |
| if frame_name(self.queue[end]) in ["g_signal_emitv", |
| "g_signal_emit_valist", |
| "g_signal_emit", |
| "g_signal_emit_by_name", |
| "_g_closure_invoke_va"]: |
| end = end + 1 |
| else: |
| break |
| |
| signal_frames = self.queue[start:end] |
| new_frames = [SignalFrame(signal_frames)] |
| self.queue[start:end] = new_frames |
| |
| return self.queue.pop(0) |
| |
| def __next__ (self): |
| return self.next() |
| |
| class GFrameFilter(object): |
| name = 'glib' |
| enabled = True |
| priority = 100 |
| |
| def filter(self, iterator): |
| return GFrameDecorator(iterator) |
| |
| def register (obj): |
| if obj == None: |
| obj = gdb |
| |
| if HAVE_GDB_FRAMEDECORATOR: |
| filter = GFrameFilter() |
| obj.frame_filters[filter.name] = filter |
| obj.pretty_printers.append(pretty_printer_lookup) |
