~ubuntu-branches/ubuntu/vivid/emscripten/vivid

from tools import shared, jsrun

CXX_SUFFIXES = ('.cpp', '.cxx', '.cc')

SOURCE_SUFFIXES = ('.c', '.cpp', '.cxx', '.cc', '.m', '.mm')

BITCODE_SUFFIXES = ('.bc', '.o', '.obj')

DYNAMICLIB_SUFFIXES = ('.dylib', '.so', '.dll')

STATICLIB_SUFFIXES = ('.a',)

ASSEMBLY_SUFFIXES = ('.ll',)

LIB_PREFIXES = ('', 'lib')

JS_CONTAINING_SUFFIXES = ('js', 'html')

                           LLVM -O3 optimizations, and

                              --llvm-lto 3

  -g                       Use debug info. When compiling to bitcode,

                           this is the same as in clang and gcc, it

                           adds debug info to the object files. When

                           compiling from source to JS or bitcode to JS,

                           it is equivalent to -g3 (keep code as debuggable

                           as possible, except for discarding LLVM

                           debug info, so no C/C++ line numbers; use

                           -g4 to get line number debugging info in JS).

 

  -g<level>                When compiling from bitcode to JS, we can

                           keep the code debuggable to different

                           degrees. Each of these levels builds on the

                           previous:

 

                            -g0  Make no effort to keep code debuggable.

                                 Will discard LLVM debug info. (default

                                 in -O1+)

                            -g1  Preserve (do not minify) whitespace

                            -g2  Preserve function names

                            -g3  Preserve variable names

                            -g4  Preserve LLVM debug info (if -g was

                                 used when compiling the C/C++ sources),

                                 show line number debug comments, and

                                 generate source maps. This is the highest

                                 level of debuggability. Note that this

                                 may make -O1 and above significantly

                                 slower because JS optimization will be

                                 limited to 1 core.  (default in -O0)

  --js-opts                0: Prevent JS optimizer from running

                           1: Use JS optimizer (default)

 

  --llvm-lto <level>       0: No LLVM LTO (default)

                           1: LLVM LTO is performed

                           2: We combine all the bitcode and run LLVM opt -O3

                              on that (which optimizes across modules, but is

                              not the same as normal LTO), but do not do normal

                              LTO

                           3: We do both 2 and then 1

                           (see --llvm-opts), setting this has no

                           For more docs on the options --preload-file

                           accepts, see  https://github.com/kripken/emscripten/wiki/Filesystem-Guide

 

  --minify 0               Identical to -g1

  -Wno-warn-absolute-paths If not specified, the compiler will warn about any

                           uses of absolute paths in -I and -L command line

                           directives. Pass this flag on the command line

                           to hide these warnings and acknowledge that the

                           explicit use of absolute paths is intentional.

 

  --proxy-to-worker        Generates both html and js files. The main

                           program is in js, and the html proxies to/from it.

 

  for arg in sys.argv:

    if arg.endswith('.c'):

        src = open(arg).read()

        if debug_configure: open(tempout, 'a').write('============= ' + arg + '\n' + src + '\n=============\n\n')

    elif arg.endswith('.s'):

if '-E' in sys.argv:

  # Just run the preprocessor

  cmd = [CC] + sys.argv[1:]

  logging.debug('just preprocssor ' + ' '.join(cmd))

  exit(subprocess.call(cmd))

 

  debug_level = 0

  js_opts = None

  proxy_to_worker = False

  # Scan for warning suppression message in advance from other cmdline flags, so that it works even if -I or -L directives are present before this.

  for i in range(len(newargs)):

    if newargs[i] == '-Wno-warn-absolute-paths':

      newargs[i] = ''

      absolute_warning_shown = True

 

  def validate_arg_level(level_string, max_level, err_msg):

    try:

      level = int(level_string)

      assert 0 <= level <= max_level

    except:

      raise Exception(err_msg)

    return level

 

      opt_level = validate_arg_level(requested_level, 3, 'Invalid optimization level: ' + newargs[i])

      newargs[i] = ''

    elif newargs[i].startswith('--js-opts'):

      check_bad_eq(newargs[i])

      js_opts = eval(newargs[i+1])

      newargs[i] = ''

      newargs[i+1] = ''

      assert newargs[i+1] == '0', '0 is the only supported option for --minify; 1 has been deprecated'

      debug_level = max(1, debug_level)

    elif newargs[i].startswith('-g'):

      requested_level = newargs[i][2:] or '3'

      debug_level = validate_arg_level(requested_level, 4, 'Invalid debug level: ' + newargs[i])

      newargs[i] = '-g' # we'll need this to get LLVM debug info

      use_preload_cache = True

      if DEBUG != 1:

        # swap in debug logging

        DEBUG = 1

        shared.set_logging()

        logging.debug('invocation: ' + ' '.join(sys.argv))

        shared.apply_configuration() # reset config to pick up change

    elif newargs[i] == '--proxy-to-worker':

      proxy_to_worker = True

      newargs[i] = ''

    elif newargs[i].startswith(('-I', '-L')):

      path_name = newargs[i][2:]

      if not absolute_warning_shown and os.path.isabs(path_name):

        logging.warning ('-I or -L of an absolute path "' + newargs[i] + '" encountered. If this is to a local system header/library, it may cause problems (local system files make sense for compiling natively on your system, but not necessarily to JavaScript). Pass \'-Wno-warn-absolute-paths\' to emcc to hide this warning.') # Of course an absolute path to a non-system-specific library or header is fine, and you can ignore this warning. The danger are system headers that are e.g. x86 specific and nonportable. The emscripten bundled headers are modified to be portable, local system ones are generally not

  if js_opts is None: js_opts = True

  if llvm_lto is None and opt_level >= 3: llvm_lto = 3

  if opt_level == 0: debug_level = 4

  if llvm_lto is None and bind:

    logging.debug('running lto for embind') # XXX this is a workaround for a pointer issue

    llvm_lto = 1

 

  # TODO: support source maps with js_transform

  if js_transform and debug_level >= 4:

    logging.warning('disabling source maps because a js transform is being done')

    debug_level = 3

 

      if prev in ['-MT', '-MF', '-MQ', '-D', '-U', '-o', '-x', '-Xpreprocessor', '-include', '-imacros', '-idirafter', '-iprefix', '-iwithprefix', '-iwithprefixbefore', '-isysroot', '-imultilib', '-A', '-isystem', '-iquote', '-install_name', '-I', '-L']: continue # ignore this gcc-style argument

                break

  newargs = CC_ADDITIONAL_ARGS + newargs

  if bind and shared.Settings.ASM_JS:

    logging.warning('disabling asm.js since embind is not ready for it yet')

    shared.Settings.ASM_JS = 0

 

    debug_level = 4 # must keep debug info to do line-by-line operations

  if debug_level > 1 and closure:

  if shared.Settings.USE_TYPED_ARRAYS != 2 and llvm_opts > 0:

    logging.warning('disabling LLVM optimizations, need typed arrays mode 2 for them')

    llvm_opts = 0

 

  if shared.Settings.MAIN_MODULE:

    assert not shared.Settings.SIDE_MODULE

    shared.Settings.INCLUDE_FULL_LIBRARY = 1

  elif shared.Settings.SIDE_MODULE:

    assert not shared.Settings.MAIN_MODULE

 

  if shared.Settings.MAIN_MODULE or shared.Settings.SIDE_MODULE:

    assert not memory_init_file, 'memory init file is not supported with module linking'

    shared.Settings.LINKABLE = 1 # TODO: add FORCE_DCE option for the brave people that do want to dce here and in side modules

    debug_level = max(debug_level, 2)

 

  if shared.Settings.ASSERTIONS and shared.Settings.ALIASING_FUNCTION_POINTERS:

    logging.warning('ALIASING_FUNCTION_POINTERS is on, function pointer comparisons may be invalid across types')

 

  if shared.Settings.STB_IMAGE and final_suffix in JS_CONTAINING_SUFFIXES:

    input_files.append(shared.path_from_root('third_party', 'stb_image.c'))

    shared.Settings.EXPORTED_FUNCTIONS += ['_stbi_load', '_stbi_load_from_memory', '_stbi_image_free']

 

  if type(shared.Settings.EXPORTED_FUNCTIONS) in (list, tuple):

    # always need malloc and free to be kept alive and exported, for internal use and other modules

    for required_export in ['_malloc', '_free']:

      if required_export not in shared.Settings.EXPORTED_FUNCTIONS:

        shared.Settings.EXPORTED_FUNCTIONS.append(required_export)

  else:

    logging.debug('using response file for EXPORTED_FUNCTIONS, make sure it includes _malloc and _free')

 

  if shared.Settings.ASM_JS and shared.Settings.DLOPEN_SUPPORT:

    assert shared.Settings.DISABLE_EXCEPTION_CATCHING, 'no exceptions support with dlopen in asm yet'

 

  if proxy_to_worker:

    shared.Settings.PROXY_TO_WORKER = 1

 

      if input_file.endswith(CXX_SUFFIXES):

        args += shared.EMSDK_CXX_OPTS

      logging.debug("running: " + call + ' ' + ' '.join(args))

  if not LEAVE_INPUTS_RAW:

    assert len(temp_files) == len(input_files)

 

    # Optimize source files

    if llvm_opts > 0:

      for i, input_file in enumerate(input_files):

        if input_file.endswith(SOURCE_SUFFIXES):

          temp_file = temp_files[i]

          logging.debug('optimizing %s with -O%d' % (input_file, llvm_opts))

          shared.Building.llvm_opt(temp_file, llvm_opts)

     not shared.Settings.BUILD_AS_SHARED_LIB == 2 and \

     not shared.Settings.SIDE_MODULE: # shared libraries/side modules link no C libraries, need them in parent

 

    lib_opts = ['-O2']

 

    # XXX we should disable EMCC_DEBUG when building libs, just like in the relooper

 

        execute([shared.PYTHON, shared.EMCC, shared.path_from_root('system', 'lib', src), '-o', o, '-I', musl_internal_includes] + lib_opts, stdout=stdout, stderr=stderr)

        execute([shared.PYTHON, shared.EMXX, srcfile, '-o', o, '-std=c++11'] + lib_opts, stdout=stdout, stderr=stderr)

      ]

         ['stdlib', [

           'ecvt.c',

           'fcvt.c',

           'gcvt.c',

         ]],

    # 1 means include everything; otherwise it can be the name of a lib (libcxx, etc.)

    force_all = force == '1'

      force_this = force_all or force == name

      if not force_this:

        if shared.Settings.VERBOSE: logging.debug('considering %s: we need %s and have %s' % (name, str(need), str(has)))

      if force_this or len(need) > 0:

        force_all = True

        if apply_(need):

          # We need to build and link the library in

          logging.debug('including %s' % name)

          libfile = shared.Cache.get(name, create)

          extra_files_to_link.append(libfile)

    shared.Building.link(linker_inputs, in_temp(target_basename + '.bc'), force_archive_contents = len(filter(lambda temp: not temp.endswith(STATICLIB_SUFFIXES), temp_files)) == 0)

    link_opts = [] if debug_level >= 4 else ['-strip-debug'] # remove LLVM debug if we are not asked for it

 

    if llvm_lto >= 2:

      logging.debug('running LLVM opt -O3 as pre-LTO')

      shared.Building.llvm_opt(in_temp(target_basename + '.bc'), ['-O3'])

      if DEBUG: save_intermediate('opt', 'bc')

 

    # If we can LTO, do it before dce, since it opens up dce opportunities

    if shared.Building.can_build_standalone() and llvm_lto and llvm_lto != 2 and shared.Building.can_use_unsafe_opts():

      if not shared.Building.can_inline(): link_opts.append('-disable-inlining')

      # do not internalize in std-link-opts - it ignores internalize-public-api-list - and add a manual internalize

      link_opts += ['-disable-internalize'] + shared.Building.get_safe_internalize() + ['-std-link-opts']

    else:

      # At minimum remove dead functions etc., this potentially saves a lot in the size of the generated code (and the time to compile it)

      link_opts += shared.Building.get_safe_internalize() + ['-globaldce']

    shared.Building.llvm_opt(in_temp(target_basename + '.bc'), link_opts)

    if DEBUG: save_intermediate('linktime', 'bc')

    subprocess.check_call(shlex.split(js_transform, posix=posix) + [os.path.abspath(final)])

  js_transform_tempfiles = [final]

 

  if memory_init_file:

    if shared.Settings.USE_TYPED_ARRAYS != 2:

      if type(memory_init_file) == int: logging.warning('memory init file requires typed arrays mode 2')

    else:

      memfile = target + '.mem'

      shared.try_delete(memfile)

      def repl(m):

        # handle chunking of the memory initializer

        s = re.sub('[\[\]\n\(\)\. ]', '', m.groups(0)[0])

        s = s.replace('concat', ',')

        if s[-1] == ',': s = s[:-1]

        open(memfile, 'wb').write(''.join(map(lambda x: chr(int(x or '0')), s.split(','))))

        if DEBUG:

          # Copy into temp dir as well, so can be run there too

          temp_memfile = os.path.join(shared.EMSCRIPTEN_TEMP_DIR, os.path.basename(memfile))

          if os.path.abspath(memfile) != os.path.abspath(memfile):

            shutil.copyfile(memfile, temp_memfile)

        return 'loadMemoryInitializer("%s");' % os.path.basename(memfile)

      src = re.sub(shared.JS.memory_initializer_pattern, repl, open(final).read(), count=1)

      open(final + '.mem.js', 'w').write(src)

      final += '.mem.js'

      js_transform_tempfiles[-1] = final # simple text substitution preserves comment line number mappings

      if DEBUG:

        if os.path.exists(memfile):

          save_intermediate('meminit')

          logging.debug('wrote memory initialization to %s' % memfile)

        else:

          logging.debug('did not see memory initialization')

 

  js_optimizer_extra_info = {}

    global final, js_optimizer_queue, js_optimizer_extra_info

    if len(js_optimizer_extra_info) == 0:

      js_optimizer_extra_info = None

        final = shared.Building.js_optimizer(final, js_optimizer_queue, jcache, debug_level >= 4, js_optimizer_extra_info)

        js_transform_tempfiles.append(final)

          final = shared.Building.js_optimizer(final, passes, jcache, debug_level >= 4, js_optimizer_extra_info)

          js_transform_tempfiles.append(final)

    js_optimizer_extra_info = {}

  if opt_level >= 1 and js_opts:

      final = shared.Building.js_optimizer(final, [], jcache, debug_level >= 4)

      js_transform_tempfiles.append(final)

    js_optimizer_queue += [get_eliminate(), 'simplifyExpressions']

    # no need to add this to js_transform_tempfiles, because closure and

    # debug_level > 0 are never simultaneously true

  if js_opts:

    if shared.Settings.OUTLINING_LIMIT > 0 and shared.Settings.ASM_JS:

      js_optimizer_queue += ['outline']

      js_optimizer_extra_info['sizeToOutline'] = shared.Settings.OUTLINING_LIMIT

 

    if (not closure or shared.Settings.ASM_JS) and shared.Settings.RELOOP and debug_level < 3:

      js_optimizer_queue += ['registerize']

 

    if opt_level > 0:

      if debug_level < 2 and shared.Settings.ASM_JS: js_optimizer_queue = map(lambda p: p if p != 'registerize' else 'registerizeAndMinify', js_optimizer_queue)

      if debug_level == 0: js_optimizer_queue += ['minifyWhitespace']

 

    if closure and shared.Settings.ASM_JS: 

      js_optimizer_queue += ['closure']

 

    if not shared.Settings.SIDE_MODULE: js_optimizer_queue += ['last'] # side modules are not finalized until after relocation

 

    flush_js_optimizer_queue()

  def generate_source_map(map_file_base_name, offset=0):

    jsrun.run_js(shared.path_from_root('tools', 'source-maps', 'sourcemapper.js'),

      shared.NODE_JS, js_transform_tempfiles +

        ['--sourceRoot', os.getcwd(),

         '--mapFileBaseName', map_file_base_name,

         '--offset', str(offset)])

    if proxy_to_worker:

      html.write(shell.replace('{{{ SCRIPT_CODE }}}', open(shared.path_from_root('src', 'proxyClient.js')).read().replace('{{{ filename }}}', target_basename)))

      js_target = unsuffixed(target) + '.js'

      shutil.copyfile(final, js_target)

    elif not Compression.on:

      if debug_level >= 4:

        match = re.match('.*?<script[^>]*>{{{ SCRIPT_CODE }}}</script>', shell,

            re.DOTALL)

        if match is None:

          raise RuntimeError('''Could not find script insertion point - make sure you have   <script type='text/javascript'>{{{ SCRIPT_CODE }}}</script>   in your HTML file (with no newlines)''')

        generate_source_map(target, match.group().count('\n'))

      from tools.split import split_javascript_file

      split_javascript_file(final, unsuffixed(target), split_js_file)

      if debug_level >= 4: generate_source_map(target)

      # copy final JS to output

      shutil.move(final, target)