kc3-lang/angle/scripts/run_code_generation.py

• Show log

  Commit

• Hash : 4638dc9d
  Author :
  Date : 2018-12-17T13:13:49
  

  Re-land "Load correct libGLESv2 on Linux and Mac."
  
  Re-land fixes build to ensure commit_id is built before libEGL.
  
  libEGL was implicitly loading libGLESv2 on startup. This is bad
  because on platforms like Linux and Mac we could sometimes use the
  incorrect rpath. This in turn meant we needed workarounds like using
  "_angle" extensions to our shared objects to get the correct loading
  behaviour.
  
  Fix this by loading libGLESv2 dynamically in libEGL. We build the
  loader automatically from egl.xml. The loader itself is lazily
  initialized on every EGL entry point call. This is necessary because
  on Linux, etc, there is no equivalent to Windows' DLLMain.
  
  We also use an EGL.h with different generation options so we have the
  proper function pointer types. A README is included for instructions
  on how to regenerate EGL.h.
  
  The entry point generation script is refactored into a helper class
  that is used in the loader generator. Also adds the libGLESv2 versions
  of the EGL entry points in the DEF file on Windows. This allows them to
  be imported properly in 32-bit configurations.
  
  Also fixes up some errors in ANGLE's entry point definitions. Also
  includes a clang-format disable rule for the Khronos headers.
  
  This CL will help us to run ANGLE tests against native drivers.
  
  Bug: angleproject:2871
  Bug: chromium:915731
  Change-Id: I4192a938d1f4117cea1bf1399c98bda7ac25ddab
  Reviewed-on: https://chromium-review.googlesource.com/c/1380511
  Reviewed-by: Yuly Novikov <ynovikov@chromium.org>
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  

Download

• scripts/run_code_generation.py

• #!/usr/bin/python2
  #
  # Copyright 2017 The ANGLE Project Authors. All rights reserved.
  # Use of this source code is governed by a BSD-style license that can be
  # found in the LICENSE file.
  #
  # run_code_reneration.py:
  #   Runs  ANGLE format table and other script run_code_renerationgeneration.
  
  import hashlib
  import json
  import os
  import subprocess
  import sys
  
  script_dir = os.path.abspath(os.path.dirname(os.path.abspath(__file__)))
  root_dir = os.path.abspath(os.path.join(script_dir, '..'))
  
  # auto_script is a standard way for scripts to return their inputs and outputs.
  
  def get_child_script_dirname(script):
      # All script names are relative to ANGLE's root
      return os.path.dirname(os.path.abspath(os.path.join(root_dir, script)))
  
  # Replace all backslashes with forward slashes to be platform independent
  def clean_path_slashes(path):
      return path.replace("\\", "/")
  
  # Takes a script input file name which is relative to the code generation script's directory and
  # changes it to be relative to the angle root directory
  def rebase_script_input_path(script_path, input_file_path):
      return os.path.relpath(os.path.join(os.path.dirname(script_path), input_file_path), root_dir);
  
  def grab_from_script(script, param):
      res = subprocess.check_output(['python', script, param]).strip()
      return [clean_path_slashes(rebase_script_input_path(script, name)) for name in res.split(',')]
  
  def auto_script(script):
      # Set the CWD to the script directory.
      os.chdir(get_child_script_dirname(script))
      base_script = os.path.basename(script)
      return {
          'script': script,
          'inputs': grab_from_script(base_script, 'inputs'),
      }
  
  hash_fname = "run_code_generation_hashes.json"
  
  # TODO(jmadill): Convert everyting to auto-script.
  generators = {
      'ANGLE format': {
          'inputs': [
              'src/libANGLE/renderer/angle_format.py',
              'src/libANGLE/renderer/angle_format_data.json',
              'src/libANGLE/renderer/angle_format_map.json',
          ],
          'script': 'src/libANGLE/renderer/gen_angle_format_table.py',
      },
      'ANGLE load functions table': {
          'inputs': [
              'src/libANGLE/renderer/load_functions_data.json',
          ],
          'script': 'src/libANGLE/renderer/gen_load_functions_table.py',
      },
      'D3D11 blit shader selection': {
          'inputs': [],
          'script': 'src/libANGLE/renderer/d3d/d3d11/gen_blit11helper.py',
      },
      'D3D11 format': {
          'inputs': [
              'src/libANGLE/renderer/angle_format.py',
              'src/libANGLE/renderer/d3d/d3d11/texture_format_data.json',
              'src/libANGLE/renderer/d3d/d3d11/texture_format_map.json',
          ],
          'script': 'src/libANGLE/renderer/d3d/d3d11/gen_texture_format_table.py',
      },
      'DXGI format': {
          'inputs': [
              'src/libANGLE/renderer/angle_format.py',
              'src/libANGLE/renderer/angle_format_map.json',
              'src/libANGLE/renderer/d3d/d3d11/dxgi_format_data.json',
              'src/libANGLE/renderer/gen_angle_format_table.py',
          ],
          'script': 'src/libANGLE/renderer/d3d/d3d11/gen_dxgi_format_table.py',
      },
      'DXGI format support': {
          'inputs': [
              'src/libANGLE/renderer/d3d/d3d11/dxgi_support_data.json',
          ],
          'script': 'src/libANGLE/renderer/d3d/d3d11/gen_dxgi_support_tables.py',
      },
      'GL/EGL/WGL loader':
          auto_script('scripts/generate_loader.py'),
      'GL/EGL entry points':
          auto_script('scripts/generate_entry_points.py'),
      'GL copy conversion table': {
          'inputs': [
              'src/libANGLE/es3_copy_conversion_formats.json',
          ],
          'script': 'src/libANGLE/gen_copy_conversion_table.py',
      },
      'GL format map': {
          'inputs': [
              'src/libANGLE/es3_format_type_combinations.json',
              'src/libANGLE/format_map_data.json',
          ],
          'script': 'src/libANGLE/gen_format_map.py',
      },
      'uniform type': {
          'inputs': [],
          'script': 'src/common/gen_uniform_type_table.py',
      },
      'OpenGL dispatch table': {
          'inputs': [
              'scripts/gl.xml',
          ],
          'script': 'src/libANGLE/renderer/gl/generate_gl_dispatch_table.py',
      },
      'packed enum': {
          'inputs': [
              'src/common/packed_gl_enums.json',
              'src/common/packed_egl_enums.json',
          ],
          'script': 'src/common/gen_packed_gl_enums.py',
      },
      'proc table': {
          'inputs': [
              'src/libGLESv2/proc_table_data.json',
          ],
          'script': 'src/libGLESv2/gen_proc_table.py',
      },
      'Vulkan format': {
          'inputs': [
              'src/libANGLE/renderer/angle_format.py',
              'src/libANGLE/renderer/angle_format_map.json',
              'src/libANGLE/renderer/vulkan/vk_format_map.json',
          ],
          'script': 'src/libANGLE/renderer/vulkan/gen_vk_format_table.py',
      },
      'Vulkan mandatory format support table': {
          'inputs': [
              'src/libANGLE/renderer/angle_format.py',
              'third_party/vulkan-headers/src/registry/vk.xml',
              'src/libANGLE/renderer/vulkan/vk_mandatory_format_support_data.json',
          ],
          'script': 'src/libANGLE/renderer/vulkan/gen_vk_mandatory_format_support_table.py',
      },
      'Vulkan internal shader programs':
          auto_script('src/libANGLE/renderer/vulkan/gen_vk_internal_shaders.py'),
      'Emulated HLSL functions': {
          'inputs': [
              'src/compiler/translator/emulated_builtin_function_data_hlsl.json'
          ],
          'script': 'src/compiler/translator/gen_emulated_builtin_function_tables.py'
      },
      'ESSL static builtins': {
          'inputs': [
              'src/compiler/translator/builtin_function_declarations.txt',
              'src/compiler/translator/builtin_variables.json',
          ],
          'script': 'src/compiler/translator/gen_builtin_symbols.py',
      },
  }
  
  def md5(fname):
      hash_md5 = hashlib.md5()
      with open(fname, "r") as f:
          for chunk in iter(lambda: f.read(4096), b""):
              hash_md5.update(chunk)
      return hash_md5.hexdigest()
  
  def any_input_dirty(name, inputs):
      found_dirty_input = False
      for finput in inputs:
          key = name + ":" + finput
          new_hashes[key] = md5(finput)
          if (not key in old_hashes) or (old_hashes[key] != new_hashes[key]):
              found_dirty_input = True
      return found_dirty_input
  
  os.chdir(script_dir)
  old_hashes = json.load(open(hash_fname))
  new_hashes = {}
  any_dirty = False
  
  for name, info in sorted(generators.iteritems()):
  
      # Reset the CWD to the root ANGLE directory.
      os.chdir(root_dir)
      script = info['script']
  
      if any_input_dirty(name, info['inputs'] + [script]):
          any_dirty = True
  
          # Set the CWD to the script directory.
          os.chdir(get_child_script_dirname(script))
  
          print('Running ' + name + ' code generator')
          if subprocess.call(['python', os.path.basename(script)]) != 0:
              sys.exit(1)
  
  if any_dirty:
      args = []
      if os.name == 'nt':
          args += ['git.bat']
      else:
          args += ['git']
      # The diff can be so large the arguments to clang-format can break the Windows command
      # line length limits. Work around this by calling git cl format with --full.
      args += ['cl', 'format', '--full']
      print('Calling git cl format')
      subprocess.call(args)
  
      os.chdir(script_dir)
      json.dump(new_hashes, open(hash_fname, "w"), indent=2, sort_keys=True,
                separators=(',', ':\n    '))
  

Download