| #!/usr/bin/env python | |
| # Copyright (c) 2017, the R8 project authors. Please see the AUTHORS file | |
| # for details. All rights reserved. Use of this source code is governed by a | |
| # BSD-style license that can be found in the LICENSE file. | |
| from __future__ import print_function | |
| from glob import glob | |
| import optparse | |
| import os | |
| import sys | |
| import time | |
| import d8 | |
| import gmail_data | |
| import gmscore_data | |
| import r8 | |
| import utils | |
| import youtube_data | |
| TYPES = ['dex', 'deploy', 'proguarded'] | |
| APPS = ['gmscore', 'youtube', 'gmail'] | |
| COMPILERS = ['d8', 'r8'] | |
| def ParseOptions(argv): | |
| result = optparse.OptionParser() | |
| result.add_option('--compiler', | |
| help='', | |
| choices=COMPILERS) | |
| result.add_option('--app', | |
| help='', | |
| choices=APPS) | |
| result.add_option('--type', | |
| help='Default for R8: deploy, for D8: proguarded', | |
| choices=TYPES) | |
| result.add_option('--out', | |
| help='', | |
| default=os.getcwd()) | |
| result.add_option('--no-build', | |
| help='', | |
| default=False, | |
| action='store_true') | |
| result.add_option('--no-libraries', | |
| help='', | |
| default=False, | |
| action='store_true') | |
| result.add_option('--no-debug', | |
| help='Run without debug asserts.', | |
| default=False, | |
| action='store_true') | |
| result.add_option('--version', | |
| help='') | |
| result.add_option('-k', | |
| help='Override the default ProGuard keep rules') | |
| result.add_option('--compiler-flags', | |
| help='Additional option(s) for the compiler. ' + | |
| 'If passing several options use a quoted string.') | |
| result.add_option('--r8-flags', | |
| help='Additional option(s) for the compiler. ' + | |
| 'Same as --compiler-flags, keeping it for backward' | |
| ' compatibility. ' + | |
| 'If passing several options use a quoted string.') | |
| # TODO(tamaskenez) remove track-memory-to-file as soon as we updated golem | |
| # to use --print-memoryuse instead | |
| result.add_option('--track-memory-to-file', | |
| help='Track how much memory the jvm is using while ' + | |
| ' compiling. Output to the specified file.') | |
| result.add_option('--profile', | |
| help='Profile R8 run.', | |
| default=False, | |
| action='store_true') | |
| result.add_option('--dump-args-file', | |
| help='Dump a file with the arguments for the specified ' + | |
| 'configuration. For use as a @<file> argument to perform ' + | |
| 'the run.') | |
| result.add_option('--print-runtimeraw', | |
| metavar='BENCHMARKNAME', | |
| help='Print the line \'<BENCHMARKNAME>(RunTimeRaw):' + | |
| ' <elapsed> ms\' at the end where <elapsed> is' + | |
| ' the elapsed time in milliseconds.') | |
| result.add_option('--print-memoryuse', | |
| metavar='BENCHMARKNAME', | |
| help='Print the line \'<BENCHMARKNAME>(MemoryUse):' + | |
| ' <mem>\' at the end where <mem> is the peak' + | |
| ' peak resident set size (VmHWM) in bytes.') | |
| result.add_option('--print-dexsegments', | |
| metavar='BENCHMARKNAME', | |
| help='Print the sizes of individual dex segments as ' + | |
| '\'<BENCHMARKNAME>-<segment>(CodeSize): <bytes>\'') | |
| return result.parse_args(argv) | |
| # Most apps have the -printmapping and -printseeds in the Proguard | |
| # configuration. However we don't want to write these files in these | |
| # locations. Instead generate an auxiliary Proguard configuration | |
| # placing these two output files together with the dex output. | |
| def GenerateAdditionalProguardConfiguration(temp, outdir): | |
| name = "output.config" | |
| with open(os.path.join(temp, name), 'w') as f: | |
| f.write('-printmapping ' + os.path.join(outdir, 'proguard.map') + "\n") | |
| f.write('-printseeds ' + os.path.join(outdir, 'proguard.seeds') + "\n") | |
| return os.path.abspath(f.name) | |
| def main(argv): | |
| utils.check_java_version() | |
| app_provided_pg_conf = False; | |
| (options, args) = ParseOptions(argv) | |
| outdir = options.out | |
| data = None | |
| if options.app == 'gmscore': | |
| options.version = options.version or 'v9' | |
| data = gmscore_data | |
| elif options.app == 'youtube': | |
| options.version = options.version or '12.22' | |
| data = youtube_data | |
| elif options.app == 'gmail': | |
| options.version = options.version or '170604.16' | |
| data = gmail_data | |
| else: | |
| raise Exception("You need to specify '--app={}'".format('|'.join(APPS))) | |
| if options.compiler not in COMPILERS: | |
| raise Exception("You need to specify '--compiler={}'" | |
| .format('|'.join(COMPILERS))) | |
| if not options.version in data.VERSIONS.keys(): | |
| print('No version {} for application {}' | |
| .format(options.version, options.app)) | |
| print('Valid versions are {}'.format(data.VERSIONS.keys())) | |
| return 1 | |
| version = data.VERSIONS[options.version] | |
| if not options.type: | |
| options.type = 'deploy' if options.compiler == 'r8' \ | |
| else 'proguarded' | |
| if options.type not in version: | |
| print('No type {} for version {}'.format(options.type, options.version)) | |
| print('Valid types are {}'.format(version.keys())) | |
| return 1 | |
| values = version[options.type] | |
| inputs = None | |
| # For R8 'deploy' the JAR is located using the Proguard configuration | |
| # -injars option. | |
| if 'inputs' in values and (options.compiler != 'r8' | |
| or options.type != 'deploy'): | |
| inputs = values['inputs'] | |
| args.extend(['--output', outdir]) | |
| if 'min-api' in values: | |
| args.extend(['--min-api', values['min-api']]) | |
| if options.compiler == 'r8': | |
| if 'pgconf' in values and not options.k: | |
| for pgconf in values['pgconf']: | |
| args.extend(['--pg-conf', pgconf]) | |
| app_provided_pg_conf = True | |
| if options.k: | |
| args.extend(['--pg-conf', options.k]) | |
| if 'maindexrules' in values: | |
| for rules in values['maindexrules']: | |
| args.extend(['--main-dex-rules', rules]) | |
| if not options.no_libraries and 'libraries' in values: | |
| for lib in values['libraries']: | |
| args.extend(['--lib', lib]) | |
| if not outdir.endswith('.zip') and not outdir.endswith('.jar') \ | |
| and not os.path.exists(outdir): | |
| os.makedirs(outdir) | |
| if options.compiler == 'r8': | |
| if 'r8-flags' in values: | |
| args.extend(values['r8-flags'].split(' ')) | |
| if options.compiler_flags: | |
| args.extend(options.compiler_flags.split(' ')) | |
| if options.r8_flags: | |
| args.extend(options.r8_flags.split(' ')) | |
| if inputs: | |
| args.extend(inputs) | |
| t0 = time.time() | |
| if options.dump_args_file: | |
| with open(options.dump_args_file, 'w') as args_file: | |
| args_file.writelines([arg + os.linesep for arg in args]) | |
| else: | |
| with utils.TempDir() as temp: | |
| if options.print_memoryuse and not options.track_memory_to_file: | |
| options.track_memory_to_file = os.path.join(temp, | |
| utils.MEMORY_USE_TMP_FILE) | |
| if options.compiler == 'd8': | |
| d8.run(args, not options.no_build, not options.no_debug, | |
| options.profile, options.track_memory_to_file) | |
| else: | |
| if app_provided_pg_conf: | |
| # Ensure that output of -printmapping and -printseeds go to the output | |
| # location and not where the app Proguard configuration places them. | |
| if outdir.endswith('.zip') or outdir.endswith('.jar'): | |
| pg_outdir = os.path.dirname(outdir) | |
| else: | |
| pg_outdir = outdir | |
| additional_pg_conf = GenerateAdditionalProguardConfiguration( | |
| temp, os.path.abspath(pg_outdir)) | |
| args.extend(['--pg-conf', additional_pg_conf]) | |
| r8.run(args, not options.no_build, not options.no_debug, | |
| options.profile, options.track_memory_to_file) | |
| if options.print_memoryuse: | |
| print('{}(MemoryUse): {}' | |
| .format(options.print_memoryuse, | |
| utils.grep_memoryuse(options.track_memory_to_file))) | |
| if options.print_runtimeraw: | |
| print('{}(RunTimeRaw): {} ms' | |
| .format(options.print_runtimeraw, 1000.0 * (time.time() - t0))) | |
| if options.print_dexsegments: | |
| dex_files = glob(os.path.join(outdir, '*.dex')) | |
| utils.print_dexsegments(options.print_dexsegments, dex_files) | |
| if __name__ == '__main__': | |
| sys.exit(main(sys.argv[1:])) |