FREEZE.unindexed

tools/binary_size/libsupersize/console.py

 # Copyright 2017 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """An interactive console for looking analyzing .size files."""
 
 import argparse
 import atexit
 import code
 import contextlib
 import itertools
 import logging
 import os
 import readline
 import subprocess
 import sys
 
 import archive
 import describe
 import diff
 import file_format
 import match_util
 import models
 import paths
+import precanned_queries
 
 
 # Number of lines before using less for Print().
 _THRESHOLD_FOR_PAGER = 30
 
 
 @contextlib.contextmanager
 def _LessPipe():
   """Output to `less`. Yields a file object to write to."""
   try:
@@ skipping 26 matching lines @@
   else:
     describe.WriteLines(lines, sys.stdout.write)
 
 
 class _Session(object):
   _readline_initialized = False
 
   def __init__(self, size_infos, lazy_paths):
     self._variables = {
         'Print': self._PrintFunc,
-        'Diff': diff.Diff,
+        'Diff': self._DiffFunc,
+        'CategorizeByChromeComponent': self._CategorizeByChromeComponentFunc,
+        'CategorizeGenerated': self._CategorizeGeneratedFunc,
         'Disassemble': self._DisassembleFunc,
         'ExpandRegex': match_util.ExpandRegexIdentifierPlaceholder,
         'ShowExamples': self._ShowExamplesFunc,
     }
     self._lazy_paths = lazy_paths
     self._size_infos = size_infos
 
     if len(size_infos) == 1:
       self._variables['size_info'] = size_infos[0]
     else:
       for i, size_info in enumerate(size_infos):
         self._variables['size_info%d' % (i + 1)] = size_info
 
-  def _PrintFunc(self, obj, verbose=False, recursive=False, use_pager=None,
+  def _DiffFunc(before=None, after=None, cluster=True):
+    """Diffs two SizeInfo objects. Returns a SizeInfoDiff.
+
+    Args:
+      before: Defaults to first size_infos[0].
+      after: Defaults to second size_infos[1].
+      cluster: When True, calls SymbolGroup.Cluster() after diffing. This
+          generally reduces noise.
+    """
+    before = before if before is not None else self._size_infos[0]
+    after = after if after is not None else self._size_infos[1]
+    return diff.Diff(before, after, cluster=cluster)
+
+  def _PrintFunc(self, obj=None, verbose=False, recursive=False, use_pager=None,
                  to_file=None):
     """Prints out the given Symbol / SymbolGroup / SymbolDiff / SizeInfo.
 
     Args:
-      obj: The object to be printed.
+      obj: The object to be printed. Defaults to size_infos[-1].
       verbose: Show more detailed output.
       recursive: Print children of nested SymbolGroups.
       use_pager: Pipe output through `less`. Ignored when |obj| is a Symbol.
           default is to automatically pipe when output is long.
       to_file: Rather than print to stdio, write to the given file.
     """
+    obj = obj if obj is not None else self._size_infos[-1]
     lines = describe.GenerateLines(obj, verbose=verbose, recursive=recursive)
     _WriteToStream(lines, use_pager=use_pager, to_file=to_file)
 
+  def _CategorizeByChromeComponentFunc(self, arg=None):
+    """Groups symbols by component using predefined queries.
+
+    Args:
+      arg: A SizeInfo or SymbolGroup. Defaults to the size_infos[-1].
+    """
+    arg = arg if arg is not None else self._size_infos[-1]
+    if isinstance(arg, models.SizeInfo):
+      arg = arg.symbols
+    return precanned_queries.CategorizeByChromeComponent(arg)
+
+  def _CategorizeGeneratedFunc(self, arg=None):
+    """Categorizes symbols from generated sources.
+
+    Args:
+      arg: A SizeInfo or SymbolGroup. Defaults to the size_infos[-1].
+    """
+    arg = arg if arg is not None else self._size_infos[-1]
+    if isinstance(arg, models.SizeInfo):
+      arg = arg.symbols
+    return precanned_queries.CategorizeGenerated(arg)
+
+
   def _ElfPathForSymbol(self, symbol):
     size_info = None
     for size_info in self._size_infos:
       if symbol in size_info.symbols:
         break
     else:
       assert False, 'Symbol does not belong to a size_info.'
 
     filename = size_info.metadata.get(models.METADATA_ELF_FILENAME)
     output_dir = self._lazy_paths.output_directory or ''
@@ skipping 23 matching lines @@
             '--start-address=0x%x' % symbol.address,
             '--stop-address=0x%x' % symbol.end_address, elf_path]
     proc = subprocess.Popen(args, stdout=subprocess.PIPE)
     lines = itertools.chain(('Showing disassembly for %r' % symbol,
                              'Command: %s' % ' '.join(args)),
                             (l.rstrip() for l in proc.stdout))
     _WriteToStream(lines, use_pager=use_pager, to_file=to_file)
     proc.kill()
 
   def _ShowExamplesFunc(self):
+    print self._CreateBanner()
     print '\n'.join([
         '# Show pydoc for main types:',
         'import models',
         'help(models)',
         '',
         '# Show all attributes of all symbols & per-section totals:',
         'Print(size_info, verbose=True)',
         '',
         '# Show two levels of .text, grouped by first two subdirectories',
         'text_syms = size_info.symbols.WhereInSection("t")',
-        'by_path = text_syms.GroupBySourcePath(depth=2)',
+        'by_path = text_syms.GroupByPath(depth=2)',
         'Print(by_path.WhereBiggerThan(1024))',
         '',
         '# Show all non-vtable generated symbols',
-        'generated_syms = size_info.symbols.WhereIsGenerated()',
-        'Print(generated_syms.WhereNameMatches(r"vtable").Inverted())',
+        'generated_syms = size_info.symbols.WhereGeneratedByToolchain()',
+        'Print(generated_syms.WhereNameMatches(r"vtable").Inverted().Sorted())',
         '',
         '# Show all symbols that have "print" in their name or path, except',
         '# those within components/.',
         '# Note: Could have also used Inverted(), as above.',
         '# Note: Use "help(ExpandRegex)" for more about what {{_print_}} does.',
         'print_syms = size_info.symbols.WhereMatches(r"{{_print_}}")',
         'Print(print_syms - print_syms.WherePathMatches(r"^components/"))',
         '',
         '# Diff two .size files and save result to a file:',
         'Print(Diff(size_info1, size_info2), to_file="output.txt")',
         '',
+        '# View per-component breakdowns, then inspect the "other" subgroup.',
+        'c = GroupByChromeComponent()',
+        'Print(c)',
+        'Print(c[-1].GroupByPath(depth=2))',
     ])
 
   def _CreateBanner(self):
     symbol_info_keys = sorted(m for m in dir(models.SizeInfo) if m[0] != '_')
     symbol_keys = sorted(m for m in dir(models.Symbol) if m[0] != '_')
     symbol_group_keys = [m for m in dir(models.SymbolGroup) if m[0] != '_']
     symbol_diff_keys = sorted(m for m in dir(models.SymbolDiff)
                               if m[0] != '_' and m not in symbol_group_keys)
     symbol_group_keys = sorted(m for m in symbol_group_keys
                                if m not in symbol_keys)
     functions = sorted(k for k in self._variables if k[0].isupper())
     variables = sorted(k for k in self._variables if k[0].islower())
     return '\n'.join([
         '*' * 80,
         'Entering interactive Python shell. Quick reference:',
         '',
         'SizeInfo: %s' % ', '.join(symbol_info_keys),
         'Symbol: %s' % ', '.join(symbol_keys),
+        '',
         'SymbolGroup (extends Symbol): %s' % ', '.join(symbol_group_keys),
+        '',
         'SymbolDiff (extends SymbolGroup): %s' % ', '.join(symbol_diff_keys),
         '',
         'Functions: %s' % ', '.join('%s()' % f for f in functions),
         'Variables: %s' % ', '.join(variables),
         '*' * 80,
     ])
 
   @classmethod
   def _InitReadline(cls):
     if cls._readline_initialized:
@@ skipping 42 matching lines @@
                                output_directory=args.output_directory,
                                any_path_within_output_directory=args.inputs[0])
   session = _Session(size_infos, lazy_paths)
 
   if args.query:
     logging.info('Running query from command-line.')
     session.Eval(args.query)
   else:
     logging.info('Entering interactive console.')
     session.GoInteractive()