~ubuntu-branches/ubuntu/trusty/emscripten/trusty-proposed

import os, sys, shutil, tempfile, subprocess, shlex, time, re, logging

from subprocess import PIPE, STDOUT

from tools import shared, jsrun

from tools.response_file import read_response_file

 

LIB_PREFIXES = ('', 'lib')

JS_CONTAINING_SUFFIXES = ('js', 'html')

 

# Mapping of emcc opt levels to llvm opt levels. We use llvm opt level 3 in emcc opt

  --version                Display compiler version information

 

Options that are modified or new in %s include:

  -O1                      Simple optimizations, including asm.js, LLVM -O1

                           or C++ exception catching (to re-enable

                           C++ exception catching, use

                           opt levels, see apply_opt_level() in

                           tools/shared.py and also src/settings.js.)

 

 

  -O3                      As -O2, plus dangerous optimizations that may

                           break the generated code! This adds

                           2: -O2 LLVM optimizations

                           3: -O3 LLVM optimizations (default in -O2+)

 

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

                           1: LLVM LTO is performed

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

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

                           effect.

 

  --closure <on>           0: No closure compiler (default in -O2 and below)

                           1: Run closure compiler. This greatly reduces

                           code size and may in some cases increase

                           try adjusting JAVA_HEAP_SIZE in the environment

                           (for example, to 4096m for 4GB).

 

  --js-transform <cmd>     <cmd> will be called on the generated code

                           before it is optimized. This lets you modify

                           the JavaScript, for example adding some code

                           For more docs on the options --preload-file

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

 

                           preloaded files. <codec> should be a triple,

 

                              <native_encoder>,<js_decoder>,<js_name>

  --shell-file <path>      The path name to a skeleton HTML file used

                           when generating HTML output. The shell file

                           used needs to have this token inside it:

                           Note that this argument is ignored if a

                           target other than HTML is specified using

                           the -o option.

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

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

 

The target file, if specified (-o <target>), defines what will

be generated:

 

  <name>.js                JavaScript

  <name>.bc                LLVM bitcode (default)

  <name>.o                 LLVM bitcode (same as .bc)

 

  exit(0)  

 

elif len(sys.argv) == 2 and sys.argv[1] == '-v': # -v with no inputs

  exit(subprocess.call([shared.CLANG, '-v']))

 

def is_minus_s_for_emcc(newargs,i):

    elif arg.endswith('.s'):

      if debug_configure: open(tempout, 'a').write('(compiling .s assembly, must use clang\n')

      use_js = 0

 

  if src:

    if 'fopen' in src and '"w"' in src:

CC_ADDITIONAL_ARGS = shared.COMPILER_OPTS

 

EMMAKEN_CFLAGS = os.environ.get('EMMAKEN_CFLAGS')

 

# ---------------- Utilities ---------------

 

if '-E' in sys.argv:

  # Just run the preprocessor

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

  exit(subprocess.call(cmd))

 

# Check if a target is specified

def in_temp(name):

  return os.path.join(temp_dir, os.path.basename(name))

 

try:

  call = CXX if use_cxx else CC

 

  split_js_file = None

  preload_files = []

  embed_files = []

  compression = None

  ignore_dynamic_linking = False

  shell_path = shared.path_from_root('src', 'shell.html')

  js_libraries = []

  bind = False

  jcache = False

  save_bc = False

  memory_init_file = False

  use_preload_cache = False

  proxy_to_worker = False

 

  if use_cxx:

    default_cxx_std = '-std=c++03' # Enforce a consistent C++ standard when compiling .cpp files, if user does not specify one on the cmdline.

      preload_files.append(newargs[i+1])

      newargs[i] = ''

      newargs[i+1] = ''

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

      check_bad_eq(newargs[i])

      parts = newargs[i+1].split(',')

      assert len(parts) == 3, '--compression requires specifying    native_encoder,js_decoder,js_name  - see emcc --help. got: %s' % newargs[i+1]

      Compression.js_name = parts[2]

      assert os.path.exists(Compression.encoder), 'native encoder %s does not exist' % Compression.encoder

      assert os.path.exists(Compression.decoder), 'js decoder %s does not exist' % Compression.decoder

    elif newargs[i].startswith('--use-preload-cache'):

      use_preload_cache = True

      newargs[i] = ''

    elif newargs[i] == '--ignore-dynamic-linking':

      ignore_dynamic_linking = True

      newargs[i] = ''

      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

        absolute_warning_shown = True

  newargs = [ arg for arg in newargs if arg is not '' ]

 

  # If user did not specify a default -std for C++ code, specify the emscripten default.

  if default_cxx_std:

    newargs = newargs + [default_cxx_std]

 

  if llvm_opts is None: llvm_opts = LLVM_OPT_LEVEL[opt_level]

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

  if opt_level == 0: debug_level = 4

 

    if i > 0:

      prev = newargs[i-1]

 

      arg = os.path.realpath(arg)

 

          input_files.append(arg)

          has_source_inputs = True

        else:

          else:

      else:

        exit(1)

    elif arg.startswith('-L'):

      lib_dirs.append(arg[2:])

    target = target_basename + '.o'

    final_suffix = 'o'

 

  # Find library files

  for lib in libs:

    logging.debug('looking for library "%s"' % lib)

    found = False

    for prefix in LIB_PREFIXES:

        name = prefix + lib + suff

        for lib_dir in lib_dirs:

          path = os.path.join(lib_dir, name)

            break

        if found: break

      if found: break

 

 

  if len(input_files) == 0:

    exit(0)

 

  newargs = CC_ADDITIONAL_ARGS + newargs

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

    shared.Settings.ASM_JS = 0

 

  if shared.Settings.ASM_JS:

 

    if bind:

      shared.Settings.RESERVED_FUNCTION_POINTERS = max(shared.Settings.RESERVED_FUNCTION_POINTERS, 10)

 

  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 proxy_to_worker:

    shared.Settings.PROXY_TO_WORKER = 1

 

  ## Compile source code to bitcode

 

  logging.debug('compiling to bitcode')

 

  # First, generate LLVM bitcode. For each input file, we get base.o with bitcode

  for input_file in input_files:

      logging.debug('compiling source file: ' + input_file)

      input_file = shared.Building.preprocess(input_file, in_temp(uniquename(input_file)))

      output_file = in_temp(unsuffixed(uniquename(input_file)) + '.o')

      temp_files.append(output_file)

      args = newargs + ['-emit-llvm', '-c', input_file, '-o', output_file]

        args += shared.EMSDK_CXX_OPTS

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

      execute([call] + args) # let compiler frontend print directly, so colors are saved (PIPE kills that)

        logging.error('compiler frontend failed to generate LLVM bitcode, halting')

        sys.exit(1)

    else: # bitcode

        logging.debug('copying bitcode file: ' + input_file)

        temp_file = in_temp(unsuffixed(uniquename(input_file)) + '.o')

        shutil.copyfile(input_file, temp_file)

        temp_files.append(temp_file)

        logging.debug('copying library file: ' + input_file)

        temp_file = in_temp(uniquename(input_file))

        shutil.copyfile(input_file, temp_file)

        temp_files.append(temp_file)

        if not LEAVE_INPUTS_RAW:

          # Note that by assembling the .ll file, then disassembling it later, we will

          # remove annotations which is a good thing for compilation time

          temp_file = in_temp(unsuffixed(uniquename(input_file)) + '.o')

          shared.Building.llvm_as(input_file, temp_file)

          temp_files.append(temp_file)

 

  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):

          temp_file = temp_files[i]

          shared.Building.llvm_opt(temp_file, llvm_opts)

 

  # If we were just asked to generate bitcode, stop there

        shutil.move(in_temp(unsuffixed(uniquename(input_file)) + '.o'), unsuffixed_basename(input_file) + '.' + final_suffix)

    else:

      if len(input_files) == 1:

      else:

        assert len(original_input_files) == 1 or not has_dash_c, 'fatal error: cannot specify -o with -c with multiple files' + str(sys.argv) + ':' + str(original_input_files)

        # We have a specified target (-o <target>), which is not JavaScript or HTML, and

 

  extra_files_to_link = []

 

     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

 

      libc_files = [

        'dlmalloc.c',

        os.path.join('libcxx', 'new.cpp'),

      return build_libc('libc.bc', libc_files)

 

    def apply_libc(need):

          'wctrans.c',

          'wcwidth.c',

         ]],

         ['multibyte', [

          'btowc.c',

          'mblen.c',

          'wctob.c',

          'wctomb.c',

         ]],

         ['stdlib', [

           'ecvt.c',

           'fcvt.c',

           'gcvt.c',

         ]],

         ['string', [

           'wcpcpy.c',

           'wcpncpy.c',

           'wcscasecmp.c',