testing/scripts/check_static_initializers.py - chromium/src - Git at Google

 #!/usr/bin/env python
 # Copyright 2018 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.

 import json
 import os
 import re
 import subprocess
 import sys

 import common

 # If something adds a static initializer, revert it, don't increase these
 # numbers. We don't accept regressions in static initializers.
 EXPECTED_LINUX_SI_COUNTS = {
     'chrome': 4,
     'nacl_helper': 4,
     'nacl_helper_bootstrap': 0,
 }

 # A static initializer is needed on Mac for libc++ to set up std::cin/cout/cerr
 # before main() runs.
 EXPECTED_MAC_SI_COUNT = 1


 def run_process(command):
   p = subprocess.Popen(command, stdout=subprocess.PIPE)
   stdout = p.communicate()[0]
   if p.returncode != 0:
     raise Exception(
         'ERROR from command "%s": %d' % (' '.join(command), p.returncode))
   return stdout


 def main_mac(src_dir):
   base_names = ('Chromium', 'Google Chrome')
   ret = 0
   for base_name in base_names:
     app_bundle = base_name + '.app'
     framework_name = base_name + ' Framework'
     framework_bundle = framework_name + '.framework'
     framework_dsym_bundle = framework_bundle + '.dSYM'
     framework_unstripped_name = framework_name + '.unstripped'
     chromium_executable = os.path.join(app_bundle, 'Contents', 'MacOS',
                                        base_name)
     chromium_framework_executable = os.path.join(framework_bundle,
                                                  framework_name)
     chromium_framework_dsym = os.path.join(framework_dsym_bundle, 'Contents',
                                            'Resources', 'DWARF', framework_name)
     if os.path.exists(chromium_executable):
       # Count the number of files with at least one static initializer.
       si_count = 0
       # Find the __DATA,__mod_init_func section.
       stdout = run_process(['otool', '-l', chromium_framework_executable])
       section_index = stdout.find('sectname __mod_init_func')
       if section_index != -1:
         # If the section exists, the "size" line must follow it.
         initializers_s = re.search('size 0x([0-9a-f]+)',
                                    stdout[section_index:]).group(1)
         word_size = 8  # Assume 64 bit
         si_count = int(initializers_s, 16) / word_size

       # Print the list of static initializers.
       if si_count > EXPECTED_MAC_SI_COUNT:
         print('Expected <= %d static initializers in %s, but found %d' %
               (EXPECTED_MAC_SI_COUNT, chromium_framework_executable, si_count))
         ret = 1

         # First look for a dSYM to get information about the initializers. If
         # one is not present, check if there is an unstripped copy of the build
         # output.
         mac_tools_path = os.path.join(src_dir, 'tools', 'mac')
         if os.path.exists(chromium_framework_dsym):
           dump_static_initializers = os.path.join(
               mac_tools_path, 'dump-static-initializers.py')
           stdout = run_process(
               [dump_static_initializers, chromium_framework_dsym])
           print stdout
         else:
           show_mod_init_func = os.path.join(mac_tools_path,
                                             'show_mod_init_func.py')
           args = [show_mod_init_func]
           if os.path.exists(framework_unstripped_name):
             args.append(framework_unstripped_name)
           else:
             print '# Warning: Falling back to potentially stripped output.'
             args.append(chromium_framework_executable)
           stdout = run_process(args)
           print stdout
   return ret


 def main_linux(src_dir):

   def get_elf_section_size(readelf_stdout, section_name):
     # Matches: .ctors PROGBITS 000000000516add0 5169dd0 000010 00 WA 0 0 8
     match = re.search(r'\.%s.*$' % re.escape(section_name), readelf_stdout,
                       re.MULTILINE)
     if not match:
       return (False, -1)
     size_str = re.split(r'\W+', match.group(0))[5]
     return (True, int(size_str, 16))

   def get_word_size(binary_name):
     stdout = run_process(['readelf', '-h', binary_name])
     elf_class_line = re.search('Class:.*$', stdout, re.MULTILINE).group(0)
     elf_class = re.split(r'\W+', elf_class_line)[1]
     if elf_class == 'ELF32':
       return 4
     elif elf_class == 'ELF64':
       return 8
     raise Exception('Unsupported architecture')

   ret = 0
   for binary_name in EXPECTED_LINUX_SI_COUNTS:
     if not os.path.exists(binary_name):
       continue
     # NOTE: this is very implementation-specific and makes assumptions
     # about how compiler and linker implement global static initializers.
     si_count = 0
     stdout = run_process(['readelf', '-SW', binary_name])
     has_init_array, init_array_size = get_elf_section_size(stdout, 'init_array')
     if has_init_array:
       si_count = init_array_size / get_word_size(binary_name)
       # In newer versions of gcc crtbegin.o inserts frame_dummy into .init_array
       # but we don't want to count this entry, since its always present and not
       # related to our code.
       stdout = run_process(['objdump', '-t', binary_name, '-j' '.init_array'])
       if '__frame_dummy_init_array_entry' in stdout:
         si_count -= 1

     # Print the list of static initializers.
     if (binary_name in EXPECTED_LINUX_SI_COUNTS and
         si_count > EXPECTED_LINUX_SI_COUNTS[binary_name]):
       print('Expected <= %d static initializers in %s, but found %d' %
             (EXPECTED_LINUX_SI_COUNTS[binary_name], binary_name, si_count))
       ret = 1
     if si_count > 0:
       dump_static_initializers = os.path.join(src_dir, 'tools', 'linux',
                                               'dump-static-initializers.py')
       stdout = run_process([dump_static_initializers, '-d', binary_name])
       print '\n# Static initializers in %s:' % binary_name
       print stdout
   return ret


 def main_run(args):
   if args.build_config_fs != 'Release':
     raise Exception('Only release builds are supported')

   src_dir = args.paths['checkout']
   build_dir = os.path.join(src_dir, 'out', args.build_config_fs)
   os.chdir(build_dir)

   if sys.platform.startswith('darwin'):
     rc = main_mac(src_dir)
   elif sys.platform == 'linux2':
     rc = main_linux(src_dir)
   else:
     sys.stderr.write('Unsupported platform %s.\n' % repr(sys.platform))
     return 2

   json.dump({
       'valid': rc == 0,
       'failures': [],
   }, args.output)

   return rc


 def main_compile_targets(args):
   if sys.platform.startswith('darwin'):
     compile_targets = ['chrome']
   elif sys.platform == 'linux2':
     compile_targets = ['chrome', 'nacl_helper', 'nacl_helper_bootstrap']
   else:
     compile_targets = []

   json.dump(compile_targets, args.output)

   return 0


 if __name__ == '__main__':
   funcs = {
       'run': main_run,
       'compile_targets': main_compile_targets,
   }
   sys.exit(common.run_script(sys.argv[1:], funcs))
	#!/usr/bin/env python
	# Copyright 2018 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.

	import json
	import os
	import re
	import subprocess
	import sys

	import common

	# If something adds a static initializer, revert it, don't increase these
	# numbers. We don't accept regressions in static initializers.
	EXPECTED_LINUX_SI_COUNTS = {
	'chrome': 4,
	'nacl_helper': 4,
	'nacl_helper_bootstrap': 0,
	}

	# A static initializer is needed on Mac for libc++ to set up std::cin/cout/cerr
	# before main() runs.
	EXPECTED_MAC_SI_COUNT = 1


	def run_process(command):
	p = subprocess.Popen(command, stdout=subprocess.PIPE)
	stdout = p.communicate()[0]
	if p.returncode != 0:
	raise Exception(
	'ERROR from command "%s": %d' % (' '.join(command), p.returncode))
	return stdout


	def main_mac(src_dir):
	base_names = ('Chromium', 'Google Chrome')
	ret = 0
	for base_name in base_names:
	app_bundle = base_name + '.app'
	framework_name = base_name + ' Framework'
	framework_bundle = framework_name + '.framework'
	framework_dsym_bundle = framework_bundle + '.dSYM'
	framework_unstripped_name = framework_name + '.unstripped'
	chromium_executable = os.path.join(app_bundle, 'Contents', 'MacOS',
	base_name)
	chromium_framework_executable = os.path.join(framework_bundle,
	framework_name)
	chromium_framework_dsym = os.path.join(framework_dsym_bundle, 'Contents',
	'Resources', 'DWARF', framework_name)
	if os.path.exists(chromium_executable):
	# Count the number of files with at least one static initializer.
	si_count = 0
	# Find the __DATA,__mod_init_func section.
	stdout = run_process(['otool', '-l', chromium_framework_executable])
	section_index = stdout.find('sectname __mod_init_func')
	if section_index != -1:
	# If the section exists, the "size" line must follow it.
	initializers_s = re.search('size 0x([0-9a-f]+)',
	stdout[section_index:]).group(1)
	word_size = 8 # Assume 64 bit
	si_count = int(initializers_s, 16) / word_size

	# Print the list of static initializers.
	if si_count > EXPECTED_MAC_SI_COUNT:
	print('Expected <= %d static initializers in %s, but found %d' %
	(EXPECTED_MAC_SI_COUNT, chromium_framework_executable, si_count))
	ret = 1

	# First look for a dSYM to get information about the initializers. If
	# one is not present, check if there is an unstripped copy of the build
	# output.
	mac_tools_path = os.path.join(src_dir, 'tools', 'mac')
	if os.path.exists(chromium_framework_dsym):
	dump_static_initializers = os.path.join(
	mac_tools_path, 'dump-static-initializers.py')
	stdout = run_process(
	[dump_static_initializers, chromium_framework_dsym])
	print stdout
	else:
	show_mod_init_func = os.path.join(mac_tools_path,
	'show_mod_init_func.py')
	args = [show_mod_init_func]
	if os.path.exists(framework_unstripped_name):
	args.append(framework_unstripped_name)
	else:
	print '# Warning: Falling back to potentially stripped output.'
	args.append(chromium_framework_executable)
	stdout = run_process(args)
	print stdout
	return ret


	def main_linux(src_dir):

	def get_elf_section_size(readelf_stdout, section_name):
	# Matches: .ctors PROGBITS 000000000516add0 5169dd0 000010 00 WA 0 0 8
	match = re.search(r'\.%s.*$' % re.escape(section_name), readelf_stdout,
	re.MULTILINE)
	if not match:
	return (False, -1)
	size_str = re.split(r'\W+', match.group(0))[5]
	return (True, int(size_str, 16))

	def get_word_size(binary_name):
	stdout = run_process(['readelf', '-h', binary_name])
	elf_class_line = re.search('Class:.*$', stdout, re.MULTILINE).group(0)
	elf_class = re.split(r'\W+', elf_class_line)[1]
	if elf_class == 'ELF32':
	return 4
	elif elf_class == 'ELF64':
	return 8
	raise Exception('Unsupported architecture')

	ret = 0
	for binary_name in EXPECTED_LINUX_SI_COUNTS:
	if not os.path.exists(binary_name):
	continue
	# NOTE: this is very implementation-specific and makes assumptions
	# about how compiler and linker implement global static initializers.
	si_count = 0
	stdout = run_process(['readelf', '-SW', binary_name])
	has_init_array, init_array_size = get_elf_section_size(stdout, 'init_array')
	if has_init_array:
	si_count = init_array_size / get_word_size(binary_name)
	# In newer versions of gcc crtbegin.o inserts frame_dummy into .init_array
	# but we don't want to count this entry, since its always present and not
	# related to our code.
	stdout = run_process(['objdump', '-t', binary_name, '-j' '.init_array'])
	if '__frame_dummy_init_array_entry' in stdout:
	si_count -= 1

	# Print the list of static initializers.
	if (binary_name in EXPECTED_LINUX_SI_COUNTS and
	si_count > EXPECTED_LINUX_SI_COUNTS[binary_name]):
	print('Expected <= %d static initializers in %s, but found %d' %
	(EXPECTED_LINUX_SI_COUNTS[binary_name], binary_name, si_count))
	ret = 1
	if si_count > 0:
	dump_static_initializers = os.path.join(src_dir, 'tools', 'linux',
	'dump-static-initializers.py')
	stdout = run_process([dump_static_initializers, '-d', binary_name])
	print '\n# Static initializers in %s:' % binary_name
	print stdout
	return ret


	def main_run(args):
	if args.build_config_fs != 'Release':
	raise Exception('Only release builds are supported')

	src_dir = args.paths['checkout']
	build_dir = os.path.join(src_dir, 'out', args.build_config_fs)
	os.chdir(build_dir)

	if sys.platform.startswith('darwin'):
	rc = main_mac(src_dir)
	elif sys.platform == 'linux2':
	rc = main_linux(src_dir)
	else:
	sys.stderr.write('Unsupported platform %s.\n' % repr(sys.platform))
	return 2

	json.dump({
	'valid': rc == 0,
	'failures': [],
	}, args.output)

	return rc


	def main_compile_targets(args):
	if sys.platform.startswith('darwin'):
	compile_targets = ['chrome']
	elif sys.platform == 'linux2':
	compile_targets = ['chrome', 'nacl_helper', 'nacl_helper_bootstrap']
	else:
	compile_targets = []

	json.dump(compile_targets, args.output)

	return 0


	if __name__ == '__main__':
	funcs = {
	'run': main_run,
	'compile_targets': main_compile_targets,
	}
	sys.exit(common.run_script(sys.argv[1:], funcs))