56         def init(self, outname):  argument
58                 self.out = open(outname, "w")
86     def __init__(self):  argument
87         self.exclude = []
88         self.include = []
90     def compile(self):  argument
91         self.re_exclude = [ re.compile(x) for x in self.exclude ]
92         self.re_include = [ re.compile(x) for x in self.include ]
94     def match(self, s):  argument
95         if len(self.re_include):
97             for r in self.re_include:
103         for r in self.re_exclude:
111         def __init__(self):  argument
112             self.hit = 0
113             self.miss = 0
115         def show(self, name):  argument
116             total = self.hit + self.miss
120                 ratio = '%f' % (self.hit/float(total))
122                     (name, self.hit, self.miss, ratio)
124     def __init__(self, enabled=True, stats=None):  argument
125         self.enabled = enabled
126         self.items = {}
128             self.stats = Cache.CacheStats()
130             self.stats = stats
132     def get(self, id):  argument
133         if self.enabled and id in self.items:
134             self.stats.hit += 1
135             return self.items[id]
137             self.stats.miss += 1
140     def put(self, id, obj):  argument
141         if self.enabled:
142             if id in self.items and obj is not self.items[id]:
146                         (id, self.items[id], obj))
147             self.items[id] = obj
149     def replace(self, id, obj):  argument
150         if self.enabled:
151             assert id in self.items
152             self.items[id] = obj
155     def __init__(self, orig, new):  argument
156         self.orig = set(orig)
157         self.new = set(new)
158         self.common = self.orig & self.new
159         self.added = self.new - self.common
160         self.removed = self.orig - self.common
163     def __init__(self):  argument
164         self.stack = []
166     def run_nested(self, obj):  argument
167         ex = obj._pp_ex(self)
168         self.stack.append(ex)
170     def run(self, obj):  argument
171         self._result = obj._pp(self)
172         return self._result
174     def nested(self):  argument
175         return sorted(set(self.stack))
177     def result(self):  argument
178         return self._result;
185     def __init__(self, name, offset, version, lib):  argument
186         self.name = name
187         self.offset = offset
188         self.version = version
189         self.lib = lib
190         self.definition = None
193     def name_ver(self):  argument
194         return self.name + '@' + self.version
196     def __repr__(self):  argument
197         return "Symbol(%s, 0x%x, %s)" % (self.name, self.offset, self.version)
200     def __init__(self, origsym, newsym):  argument
204         self.origsym = origsym
205         self.newsym = newsym
206         self.name = newsym.name
207         self.version = newsym.version
209     def __repr__(self):  argument
210         return "CommonSymbol(%s, %s)" % (self.name, self.version)
213     def __init__(self, alias, prefix, offset):  argument
215         self.alias = alias
216         self.name = alias[len(prefix):]
217         self.offset = offset
219     def __repr__(self):  argument
220         return "SymbolAlias(%s, 0x%x)" % (self.alias, self.offset)
224     def __init__(self, name):  argument
225         self.name = name
226         self.symbols = {}
228     def append(self, symbol):  argument
229         if (symbol.name in self.symbols):
231                     (symbol.name, self.name))
232         self.symbols[symbol.name] = symbol
234     def names(self):  argument
235         return self.symbols.keys()
237     def __repr__(self):  argument
238         return repr(self.symbols.values())
247     def __init__(self, id, name, **kwargs):  argument
248         self.id = id
249         self.name = name
250         self.attrs = kwargs
252     def __getattr__(self, attr):  argument
253         if attr not in self.attrs:
254             raise AttributeError('%s in %s' % (attr, str(self)))
255         return self.attrs[attr]
257     def _name_opt(self, default=''):  argument
258         if not self.name:
260         return self.name
262     def _alias(self):  argument
263         if self._is_alias:
264             return self.type._alias()
265         return self
267     def __cmp__(self, other):  argument
270         a = self._alias()
293     def __repr__(self):  argument
295         if hasattr(self, 'name'):
296             p.append("name=%s" % self.name)
297         for (k, v) in self.attrs.items():
301         return self.__class__.__name__ + '(' + ', '.join(p) + ')'
303     def _mapval(self, param, vals):  argument
306                     (param, str(self)))
309     def _pp_ex(self, pp):  argument
311                 str(self))
313     def _pp(self, pp):  argument
314         raise NotImplementedError('Pretty print not implemeted: %s' % str(self))
317     def __init__(self, id, **kwargs):  argument
318         Def.__init__(self, id, None, **kwargs)
329     def __init__(self):  argument
330         AnonymousDef.__init__(self, 0)
332     def _pp(self, pp):  argument
336     def _pp(self, pp):  argument
340     def _pp(self, pp):  argument
341         t = pp.run(self.type)
346     def _pp(self, pp):  argument
347         if self.encoding in self.inttypes:
348             sign = '' if self.encoding == 'DW_ATE_signed' else 'u'
349             bits = int(self.byte_size, 0) * 8
351         elif self.encoding == 'DW_ATE_signed_char' and int(self.byte_size, 0) == 1:
353         elif self.encoding == 'DW_ATE_boolean' and int(self.byte_size, 0) == 1:
355         elif self.encoding == 'DW_ATE_float':
356             return self._mapval(int(self.byte_size, 0), {
361         raise NotImplementedError('Invalid encoding: %s' % self)
365     def _pp(self, pp):  argument
366         alias = self._alias()
368         if self.name and not alias.name:
369             alias.name = 'T(%s)' % self.name
371         return self.type._pp(pp)
374     def _pp(self, pp):  argument
375         return 'enum ' + self._name_opt('UNKNOWN')
379     def _pp(self, pp):  argument
380         return 'const ' + self.type._pp(pp)
384     def _pp(self, pp):  argument
385         return 'volatile ' + self.type._pp(pp)
389     def _pp(self, pp):  argument
390         return 'restrict ' + self.type._pp(pp)
393     def _pp(self, pp):  argument
394         t = pp.run(self.type)
395         assert len(self.subranges) == 1
397             sz = int(self.subranges[0].upper_bound) + 1
399             s = re.sub(r'\(.+\)', '', self.subranges[0].upper_bound)
407     def _pp(self, pp):  argument
408         result = pp.run(self.result)
409         if not self.params:
412             params = ', '.join([ pp.run(x) for x in self.params ])
413         return "%s %s(%s);" % (result, self.name, params)
416     def _pp(self, pp):  argument
417         result = pp.run(self.result)
418         if not self.params:
421             params = ', '.join([ pp.run(x) for x in self.params ])
422         return "F(%s, %s, (%s))" % (self._name_opt(), result, params)
425     def _pp(self, pp):  argument
426         t = pp.run(self.type)
427         return "%s %s" % (t, self._name_opt())
430     def _pp(self, pp):  argument
431         t = pp.run(self.type)
432         return "%s %s" % (t, self._name_opt())
439     def update(self, complete, cache=None):  argument
440         self.complete = complete
441         complete.incomplete = self
443             cached = cache.get(self.id)
445                 cache.replace(self.id, complete)
448     def _pp(self, pp):  argument
449         return "struct %s" % (self.name,)
452     def _pp(self, pp):  argument
453         return "union %s" % (self.name,)
456     def _pp_ex(self, pp, suffix=';'):  argument
457         members = [ pp.run(x) for x in self.members ]
459                 (self._name_opt(), ' '.join(members), suffix)
460     def _pp(self, pp):  argument
461         if self.name:
462             pp.run_nested(self)
463             return "struct %s" % (self.name,)
465             return self._pp_ex(pp, suffix='')
468     def _pp_ex(self, pp, suffix=';'):  argument
469         members = [ pp.run(x) for x in self.members ]
471                 (self._name_opt(), ' '.join(members), suffix)
472     def _pp(self, pp):  argument
473         if self.name:
474             pp.run_nested(self)
475             return "union %s" % (self.name,)
477             return self._pp_ex(pp, suffix='')
480     def _pp(self, pp):  argument
481         t = pp.run(self.type)
482         if self.bit_size:
483             bits = ":%s" % self.bit_size
486         return "%s %s%s;" % (t, self._name_opt(), bits)
492     def __init__(self, dump):  argument
493         self.dump = dump
495     def _build_optarg_type(self, praw):  argument
498             type = self.buildref(praw.unit, type)
501     def build_subprogram(self, raw):  argument
504         params = [ self.build(x) for x in raw.nested ]
505         result = self._build_optarg_type(raw)
508     def build_variable(self, raw):  argument
509         type = self._build_optarg_type(raw)
512     def build_subroutine_type(self, raw):  argument
513         params = [ self.build(x) for x in raw.nested ]
514         result = self._build_optarg_type(raw)
517     def build_formal_parameter(self, raw):  argument
518         type = self._build_optarg_type(raw)
521     def build_pointer_type(self, raw):  argument
522         type = self._build_optarg_type(raw)
525     def build_member(self, raw):  argument
526         type = self.buildref(raw.unit, raw.arg('type'))
530     def build_structure_type(self, raw):  argument
537         members = [ self.build(x) for x in raw.nested ]
547     def build_union_type(self, raw):  argument
554         members = [ self.build(x) for x in raw.nested ]
562     def build_typedef(self, raw):  argument
563         type = self._build_optarg_type(raw)
566     def build_const_type(self, raw):  argument
567         type = self._build_optarg_type(raw)
570     def build_volatile_type(self, raw):  argument
571         type = self._build_optarg_type(raw)
574     def build_restrict_type(self, raw):  argument
575         type = self._build_optarg_type(raw)
578     def build_enumeration_type(self, raw):  argument
583     def build_base_type(self, raw):  argument
587     def build_array_type(self, raw):  argument
588         type = self.buildref(raw.unit, raw.arg('type'))
589         subranges = [ self.build(x) for x in raw.nested ]
592     def build_subrange_type(self, raw):  argument
593         type = self.buildref(raw.unit, raw.arg('type'))
597     def build_unspecified_parameters(self, raw):  argument
600     def _get_id(self, id):  argument
609     def build(self, raw):  argument
615             builder = getattr(self, builder_name)
622     def buildref(self, unit, id):  argument
623         id = self._get_id(id)
625         obj = self.build(raw)
631     def __init__(self, libfile):  argument
632         self.libfile = libfile
633         self.versions = {}
634         self.alias_syms = {}
636     def parse_objdump(self):  argument
637         objdump = ObjdumpParser(self.libfile)
647             sym = Symbol(p['symbol'], p['offset'], vername, self)
648             if vername not in self.versions:
649                 self.versions[vername] = VersionMap(vername)
650             self.versions[vername].append(sym)
652             self.local_offsetmap = objdump.local_offsetmap
658                     if alias.name in self.alias_syms:
659                         prevalias = self.alias_syms[alias.name]
666                     self.alias_syms[alias.name] = alias
668     def parse_dwarfdump(self):  argument
669         dwarfdump = DwarfdumpParser(self.libfile)
676                     localnames = self.local_offsetmap[sym.offset]
679                         if localname not in self.alias_syms:
681                         alias = self.alias_syms[localname]
689         for ver in self.versions.values():
694                             (sym.name_ver, self.libfile, sym.offset))
697                     print("Parsing symbol %s (%s)" % (sym.name_ver, self.libfile))
700     def parse(self):  argument
701         if not os.path.isfile(self.libfile):
702             print("No such file: %s" % self.libfile, file=sys.stderr)
704         self.parse_objdump()
705         self.parse_dwarfdump()
710     def __init__(self, proc):  argument
711         self.proc = proc
712         self.parser = self.parse_begin
714     def run(self):  argument
715         fd = os.popen(self.proc, 'r')
722                 self.parser(line)
725             print("Execution failed: %s" % self.proc, file=sys.stderr)
728     def parse_begin(self, line):  argument
740     def __init__(self, libfile):  argument
741         Parser.__init__(self, "%s -wtT %s" % (Config.objdump, libfile))
742         self.dynamic_symbols = []
743         self.local_symbols = []
744         self.local_offsetmap = {}
746     def parse_begin(self, line):  argument
747         self.parse_header(line)
749     def add_symbol(self, table, symbol, offsetmap = None):  argument
761     def parse_header(self, line):  argument
762         m = self.re_header.match(line)
766                 self.parser = self.parse_dynamic
768                 self.parser = self.parse_local
774     def parse_local(self, line):  argument
775         if (self.parse_header(line)):
777         if (self.re_lame_symbol.match(line)):
779         m = self.re_local_symbol.match(line)
785             self.add_symbol(self.local_symbols, p, self.local_offsetmap);
787     def parse_dynamic(self, line):  argument
788         if (self.parse_header(line)):
790         if (self.re_lame_symbol.match(line)):
792         m = self.re_dynamic_symbol.match(line)
797             self.add_symbol(self.dynamic_symbols, p);
804         def __init__(self):  argument
805             self.cache = Cache(enabled=Config.dwarfcache_enabled,
807             self.incomplete = Cache()
808             self.tags = {}
811         def __init__(self, unit, data):  argument
812             self.unit = unit
813             self.id = int(data['id'], 0)
814             self.level = int(data['level'])
815             self.tag = data['tag']
816             self.args = {}
817             self.nested = []
820         def name(self):  argument
821             return self.arg('name')
824         def optname(self):  argument
825             return self.optarg('name', None)
827         def setname(self, name):  argument
828             self.args['DW_AT_name'] = name
830         def arg(self, a):  argument
833                 return self.args[name]
836                         (name, self, self.args))
838         def optarg(self, a, default):  argument
840                 return self.arg(a)
844         def __repr__(self):  argument
845             return "Tag(%d, %d, %s)" % (self.level, self.id, self.tag)
862     def __init__(self, libfile):  argument
863         Parser.__init__(self, "%s -di %s" % (Config.dwarfdump, libfile))
864         self.current_unit = None
865         self.offsetmap = {}
866         self.stack = []
868     def parse_begin(self, line):  argument
870             self.parser = self.parse_debuginfo
874     def parse_argvalue(self, args):  argument
890     def parse_arg(self, tag, args):  argument
891         m = self.re_argname.match(args)
893             m = self.re_argunknown.match(args)
903             (args, v) = self.parse_argvalue(args)
911     def parse_debuginfo(self, line):  argument
912         m = self.re_header.match(line)
916             self.current_unit = DwarfdumpParser.Unit()
918         tag = DwarfdumpParser.Tag(self.current_unit, m.groupdict())
921             args = self.parse_arg(tag, args)
936             if offset in self.offsetmap:
939             self.offsetmap[offset] = tag
940         if len(self.stack) > 0:
941             prev = self.stack.pop()
942             while prev.level >= tag.level and len(self.stack) > 0:
943                 prev = self.stack.pop()
949                 self.stack.append(prev)
950         self.stack.append(tag)
951         assert len(self.stack) == tag.level
1038         def __init__(self, io_conf):  argument
1039             self.io_conf = io_conf
1040             self.pp = PrettyPrinter()
1041             self.res = []
1042         def run(self, sym):  argument
1043             r = self.pp.run(sym.definition)
1044             self.res.append('/* %s@%s */ %s' % (sym.name, sym.version, r))
1045         def finish(self):  argument
1047                     (ver.name, self.io_conf.filename), file=self.io_conf.out)
1048             for i in self.pp.nested():
1049                 print(i, file=self.io_conf.out)
1050             print('', file=self.io_conf.out)
1051             for i in self.res:
1052                 print(i, file=self.io_conf.out)