nexmon – Blame information for rev 1

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