Lines Matching refs:self
57 def init(self, outname):
59 self.out = open(outname, "w")
87 def __init__(self):
88 self.exclude = []
89 self.include = []
91 def compile(self):
92 self.re_exclude = [ re.compile(x) for x in self.exclude ]
93 self.re_include = [ re.compile(x) for x in self.include ]
95 def match(self, s):
96 if len(self.re_include):
98 for r in self.re_include:
104 for r in self.re_exclude:
112 def __init__(self):
113 self.hit = 0
114 self.miss = 0
116 def show(self, name):
117 total = self.hit + self.miss
121 ratio = '%f' % (self.hit/float(total))
123 (name, self.hit, self.miss, ratio)
125 def __init__(self, enabled=True, stats=None):
126 self.enabled = enabled
127 self.items = {}
129 self.stats = Cache.CacheStats()
131 self.stats = stats
133 def get(self, id):
134 if self.enabled and id in self.items:
135 self.stats.hit += 1
136 return self.items[id]
138 self.stats.miss += 1
141 def put(self, id, obj):
142 if self.enabled:
143 if id in self.items and obj is not self.items[id]:
145 # (id, self.items[id], obj))
147 (id, self.items[id], obj))
148 self.items[id] = obj
150 def replace(self, id, obj):
151 if self.enabled:
152 assert id in self.items
153 self.items[id] = obj
156 def __init__(self, orig, new):
157 self.orig = set(orig)
158 self.new = set(new)
159 self.common = self.orig & self.new
160 self.added = self.new - self.common
161 self.removed = self.orig - self.common
164 def __init__(self):
165 self.stack = []
167 def run_nested(self, obj):
168 ex = obj._pp_ex(self)
169 self.stack.append(ex)
171 def run(self, obj):
172 self._result = obj._pp(self)
173 return self._result
175 def nested(self):
176 return sorted(set(self.stack))
178 def result(self):
179 return self._result;
186 def __init__(self, name, offset, version, lib):
187 self.name = name
188 self.offset = offset
189 self.version = version
190 self.lib = lib
191 self.definition = None
194 def name_ver(self):
195 return self.name + '@' + self.version
197 def __repr__(self):
198 return "Symbol(%s, 0x%x, %s)" % (self.name, self.offset, self.version)
201 def __init__(self, origsym, newsym):
205 self.origsym = origsym
206 self.newsym = newsym
207 self.name = newsym.name
208 self.version = newsym.version
210 def __repr__(self):
211 return "CommonSymbol(%s, %s)" % (self.name, self.version)
214 def __init__(self, alias, prefix, offset):
216 self.alias = alias
217 self.name = alias[len(prefix):]
218 self.offset = offset
220 def __repr__(self):
221 return "SymbolAlias(%s, 0x%x)" % (self.alias, self.offset)
225 def __init__(self, name):
226 self.name = name
227 self.symbols = {}
229 def append(self, symbol):
230 if (symbol.name in self.symbols):
232 (symbol.name, self.name))
233 self.symbols[symbol.name] = symbol
235 def names(self):
236 return self.symbols.keys()
238 def __repr__(self):
239 return repr(self.symbols.values())
248 def __init__(self, id, name, **kwargs):
249 self.id = id
250 self.name = name
251 self.attrs = kwargs
253 def __getattr__(self, attr):
254 if attr not in self.attrs:
255 raise AttributeError('%s in %s' % (attr, str(self)))
256 return self.attrs[attr]
258 def _name_opt(self, default=''):
259 if not self.name:
261 return self.name
263 def _alias(self):
264 if self._is_alias:
265 return self.type._alias()
266 return self
268 def __cmp__(self, other):
269 # TODO assert 'self' and 'other' belong to different libraries
270 #print 'cmp defs: %s, %s' % (self, other)
271 a = self._alias()
294 def __repr__(self):
296 if hasattr(self, 'name'):
297 p.append("name=%s" % self.name)
298 for (k, v) in self.attrs.items():
302 return self.__class__.__name__ + '(' + ', '.join(p) + ')'
304 def _mapval(self, param, vals):
307 (param, str(self)))
310 def _pp_ex(self, pp):
312 str(self))
314 def _pp(self, pp):
315 raise NotImplementedError('Pretty print not implemeted: %s' % str(self))
318 def __init__(self, id, **kwargs):
319 Def.__init__(self, id, None, **kwargs)
330 def __init__(self):
331 AnonymousDef.__init__(self, 0)
333 def _pp(self, pp):
337 def _pp(self, pp):
341 def _pp(self, pp):
342 t = pp.run(self.type)
347 def _pp(self, pp):
348 if self.encoding in self.inttypes:
349 sign = '' if self.encoding == 'DW_ATE_signed' else 'u'
350 bits = int(self.byte_size, 0) * 8
352 elif self.encoding == 'DW_ATE_signed_char' and int(self.byte_size, 0) == 1:
354 elif self.encoding == 'DW_ATE_boolean' and int(self.byte_size, 0) == 1:
356 elif self.encoding == 'DW_ATE_float':
357 return self._mapval(int(self.byte_size, 0), {
362 raise NotImplementedError('Invalid encoding: %s' % self)
366 def _pp(self, pp):
367 alias = self._alias()
369 if self.name and not alias.name:
370 alias.name = 'T(%s)' % self.name
372 return self.type._pp(pp)
375 def _pp(self, pp):
376 return 'enum ' + self._name_opt('UNKNOWN')
380 def _pp(self, pp):
381 return 'const ' + self.type._pp(pp)
385 def _pp(self, pp):
386 return 'volatile ' + self.type._pp(pp)
390 def _pp(self, pp):
391 return 'restrict ' + self.type._pp(pp)
394 def _pp(self, pp):
395 t = pp.run(self.type)
396 assert len(self.subranges) == 1
398 sz = int(self.subranges[0].upper_bound) + 1
400 s = re.sub(r'\(.+\)', '', self.subranges[0].upper_bound)
408 def _pp(self, pp):
409 result = pp.run(self.result)
410 if not self.params:
413 params = ', '.join([ pp.run(x) for x in self.params ])
414 return "%s %s(%s);" % (result, self.name, params)
417 def _pp(self, pp):
418 result = pp.run(self.result)
419 if not self.params:
422 params = ', '.join([ pp.run(x) for x in self.params ])
423 return "F(%s, %s, (%s))" % (self._name_opt(), result, params)
426 def _pp(self, pp):
427 t = pp.run(self.type)
428 return "%s %s" % (t, self._name_opt())
431 def _pp(self, pp):
432 t = pp.run(self.type)
433 return "%s %s" % (t, self._name_opt())
440 def update(self, complete, cache=None):
441 self.complete = complete
442 complete.incomplete = self
444 cached = cache.get(self.id)
446 cache.replace(self.id, complete)
449 def _pp(self, pp):
450 return "struct %s" % (self.name,)
453 def _pp(self, pp):
454 return "union %s" % (self.name,)
457 def _pp_ex(self, pp, suffix=';'):
458 members = [ pp.run(x) for x in self.members ]
460 (self._name_opt(), ' '.join(members), suffix)
461 def _pp(self, pp):
462 if self.name:
463 pp.run_nested(self)
464 return "struct %s" % (self.name,)
466 return self._pp_ex(pp, suffix='')
469 def _pp_ex(self, pp, suffix=';'):
470 members = [ pp.run(x) for x in self.members ]
472 (self._name_opt(), ' '.join(members), suffix)
473 def _pp(self, pp):
474 if self.name:
475 pp.run_nested(self)
476 return "union %s" % (self.name,)
478 return self._pp_ex(pp, suffix='')
481 def _pp(self, pp):
482 t = pp.run(self.type)
483 if self.bit_size:
484 bits = ":%s" % self.bit_size
487 return "%s %s%s;" % (t, self._name_opt(), bits)
493 def __init__(self, dump):
494 self.dump = dump
496 def _build_optarg_type(self, praw):
499 type = self.buildref(praw.unit, type)
502 def build_subprogram(self, raw):
505 params = [ self.build(x) for x in raw.nested ]
506 result = self._build_optarg_type(raw)
509 def build_variable(self, raw):
510 type = self._build_optarg_type(raw)
513 def build_subroutine_type(self, raw):
514 params = [ self.build(x) for x in raw.nested ]
515 result = self._build_optarg_type(raw)
518 def build_formal_parameter(self, raw):
519 type = self._build_optarg_type(raw)
522 def build_pointer_type(self, raw):
523 type = self._build_optarg_type(raw)
526 def build_member(self, raw):
527 type = self.buildref(raw.unit, raw.arg('type'))
531 def build_structure_type(self, raw):
538 members = [ self.build(x) for x in raw.nested ]
548 def build_union_type(self, raw):
555 members = [ self.build(x) for x in raw.nested ]
563 def build_typedef(self, raw):
564 type = self._build_optarg_type(raw)
567 def build_const_type(self, raw):
568 type = self._build_optarg_type(raw)
571 def build_volatile_type(self, raw):
572 type = self._build_optarg_type(raw)
575 def build_restrict_type(self, raw):
576 type = self._build_optarg_type(raw)
579 def build_enumeration_type(self, raw):
584 def build_base_type(self, raw):
588 def build_array_type(self, raw):
589 type = self.buildref(raw.unit, raw.arg('type'))
590 subranges = [ self.build(x) for x in raw.nested ]
593 def build_subrange_type(self, raw):
594 type = self.buildref(raw.unit, raw.arg('type'))
598 def build_unspecified_parameters(self, raw):
601 def _get_id(self, id):
610 def build(self, raw):
616 builder = getattr(self, builder_name)
623 def buildref(self, unit, id):
624 id = self._get_id(id)
626 obj = self.build(raw)
632 def __init__(self, libfile):
633 self.libfile = libfile
634 self.versions = {}
635 self.alias_syms = {}
637 def parse_objdump(self):
638 objdump = ObjdumpParser(self.libfile)
648 sym = Symbol(p['symbol'], p['offset'], vername, self)
649 if vername not in self.versions:
650 self.versions[vername] = VersionMap(vername)
651 self.versions[vername].append(sym)
653 self.local_offsetmap = objdump.local_offsetmap
659 if alias.name in self.alias_syms:
660 prevalias = self.alias_syms[alias.name]
667 self.alias_syms[alias.name] = alias
669 def parse_dwarfdump(self):
670 dwarfdump = DwarfdumpParser(self.libfile)
677 localnames = self.local_offsetmap[sym.offset]
680 if localname not in self.alias_syms:
682 alias = self.alias_syms[localname]
690 for ver in self.versions.values():
695 (sym.name_ver, self.libfile, sym.offset))
698 print("Parsing symbol %s (%s)" % (sym.name_ver, self.libfile))
701 def parse(self):
702 if not os.path.isfile(self.libfile):
703 print("No such file: %s" % self.libfile, file=sys.stderr)
705 self.parse_objdump()
706 self.parse_dwarfdump()
711 def __init__(self, proc):
712 self.proc = proc
713 self.parser = self.parse_begin
715 def run(self):
716 fd = os.popen(self.proc, 'r')
723 self.parser(line)
726 print("Execution failed: %s" % self.proc, file=sys.stderr)
729 def parse_begin(self, line):
741 def __init__(self, libfile):
742 Parser.__init__(self, "%s -wtT %s" % (Config.objdump, libfile))
743 self.dynamic_symbols = []
744 self.local_symbols = []
745 self.local_offsetmap = {}
747 def parse_begin(self, line):
748 self.parse_header(line)
750 def add_symbol(self, table, symbol, offsetmap = None):
762 def parse_header(self, line):
763 m = self.re_header.match(line)
767 self.parser = self.parse_dynamic
769 self.parser = self.parse_local
775 def parse_local(self, line):
776 if (self.parse_header(line)):
778 if (self.re_lame_symbol.match(line)):
780 m = self.re_local_symbol.match(line)
786 self.add_symbol(self.local_symbols, p, self.local_offsetmap);
788 def parse_dynamic(self, line):
789 if (self.parse_header(line)):
791 if (self.re_lame_symbol.match(line)):
793 m = self.re_dynamic_symbol.match(line)
798 self.add_symbol(self.dynamic_symbols, p);
805 def __init__(self):
806 self.cache = Cache(enabled=Config.dwarfcache_enabled,
808 self.incomplete = Cache()
809 self.tags = {}
812 def __init__(self, unit, data):
813 self.unit = unit
814 self.id = int(data['id'], 0)
815 self.level = int(data['level'])
816 self.tag = data['tag']
817 self.args = {}
818 self.nested = []
821 def name(self):
822 return self.arg('name')
825 def optname(self):
826 return self.optarg('name', None)
828 def setname(self, name):
829 self.args['DW_AT_name'] = name
831 def arg(self, a):
834 return self.args[name]
837 (name, self, self.args))
839 def optarg(self, a, default):
841 return self.arg(a)
845 def __repr__(self):
846 return "Tag(%d, %d, %s)" % (self.level, self.id, self.tag)
863 def __init__(self, libfile):
864 Parser.__init__(self, "%s -di %s" % (Config.dwarfdump, libfile))
865 self.current_unit = None
866 self.offsetmap = {}
867 self.stack = []
869 def parse_begin(self, line):
871 self.parser = self.parse_debuginfo
875 def parse_argvalue(self, args):
891 def parse_arg(self, tag, args):
892 m = self.re_argname.match(args)
894 m = self.re_argunknown.match(args)
904 (args, v) = self.parse_argvalue(args)
912 def parse_debuginfo(self, line):
913 m = self.re_header.match(line)
917 self.current_unit = DwarfdumpParser.Unit()
919 tag = DwarfdumpParser.Tag(self.current_unit, m.groupdict())
922 args = self.parse_arg(tag, args)
937 if offset in self.offsetmap:
940 self.offsetmap[offset] = tag
941 if len(self.stack) > 0:
942 prev = self.stack.pop()
943 while prev.level >= tag.level and len(self.stack) > 0:
944 prev = self.stack.pop()
950 self.stack.append(prev)
951 self.stack.append(tag)
952 assert len(self.stack) == tag.level
1039 def __init__(self, io_conf):
1040 self.io_conf = io_conf
1041 self.pp = PrettyPrinter()
1042 self.res = []
1043 def run(self, sym):
1044 r = self.pp.run(sym.definition)
1045 self.res.append('/* %s@%s */ %s' % (sym.name, sym.version, r))
1046 def finish(self):
1048 (ver.name, self.io_conf.filename), file=self.io_conf.out)
1049 for i in self.pp.nested():
1050 print(i, file=self.io_conf.out)
1051 print('', file=self.io_conf.out)
1052 for i in self.res:
1053 print(i, file=self.io_conf.out)