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

from distutils.spawn import find_executable

    # Note: repr is used to ensure the paths are escaped correctly on Windows.

    # The full string is replaced so that the template stays valid Python.

    config_file = config_file.replace('\'{{{ EMSCRIPTEN_ROOT }}}\'', repr(__rootpath__))

    llvm_root = os.path.dirname(find_executable('llvm-dis') or '/usr/bin/llvm-dis')

    config_file = config_file.replace('\'{{{ LLVM_ROOT }}}\'', repr(llvm_root))

    node = find_executable('node') or find_executable('nodejs') or 'node'

    config_file = config_file.replace('\'{{{ NODE }}}\'', repr(node))

    python = find_executable('python2') or find_executable('python') or \

        sys.executable or 'python'

    config_file = config_file.replace('\'{{{ PYTHON }}}\'', repr(python))

    if WINDOWS:

      tempdir = os.environ.get('TEMP') or os.environ.get('TMP') or 'c:\\temp'

    else:

      tempdir = '/tmp'

    config_file = config_file.replace('\'{{{ TEMP }}}\'', repr(tempdir))

    check_clang_version()

EXPECTED_NODE_VERSION = (0,8,0)

# Finds the system temp directory without resorting to using the one configured in .emscripten

def find_temp_directory():

  if WINDOWS:

    if os.getenv('TEMP') and os.path.isdir(os.getenv('TEMP')):

      return os.getenv('TEMP')

    elif os.getenv('TMP') and os.path.isdir(os.getenv('TMP')):

      return os.getenv('TMP')

    elif os.path.isdir('C:\\temp'):

      return os.getenv('C:\\temp')

    else:

      return None # No luck!

  else:

    return '/tmp'

 

EMSCRIPTEN_VERSION = '1.5.6'

  return EMSCRIPTEN_VERSION + '|' + get_llvm_target() + '|' + LLVM_ROOT

      force = False # the check actually failed, so definitely write out the sanity file, to avoid others later seeing failures too

    for cmd in [CLANG, LINK_CMD[0], LLVM_AR, LLVM_OPT, LLVM_AS, LLVM_DIS, LLVM_NM]:

try:

        LLVM_ADD_VERSION

except NameError:

        LLVM_ADD_VERSION = os.getenv('LLVM_ADD_VERSION')

 

try:

        CLANG_ADD_VERSION

except NameError:

        CLANG_ADD_VERSION = os.getenv('CLANG_ADD_VERSION')

 

USING_PNACL_TOOLCHAIN = os.path.exists(os.path.join(LLVM_ROOT, 'pnacl-clang'))

 

def modify_prefix(tool):

  if USING_PNACL_TOOLCHAIN:

    if tool.startswith('llvm-'):

      tool = tool[5:]

    tool = 'pnacl-' + tool

    if WINDOWS:

      tool += '.bat'

  return tool

  tool = modify_prefix(tool)

  tool = modify_prefix(tool)

if USING_PNACL_TOOLCHAIN:

  # The PNaCl toolchain doesn't have llvm-link, but we can fake it

  LINK_CMD = [build_llvm_tool_path('llvm-ld'), '-nostdlib', '-r']

else:

  LINK_CMD = [build_llvm_tool_path('llvm-link')]

EMLINK = path_from_root('emlink.py')

  def __init__(self, environ=os.environ):

      self.TEMP_DIR = find_temp_directory()

      if self.TEMP_DIR == None:

        logging.critical('TEMP_DIR not defined in ' + os.path.expanduser('~\\.emscripten') + ", and could not detect a suitable directory! Please configure .emscripten to contain a variable TEMP_DIR='/path/to/temp/dir'.")

      logging.debug('TEMP_DIR not defined in ~/.emscripten, using ' + self.TEMP_DIR)

 

    if not os.path.isdir(self.TEMP_DIR):

      logging.critical("The temp directory TEMP_DIR='" + self.TEMP_DIR + "' doesn't seem to exist! Please make sure that the path is correct.")

def apply_configuration():

  global configuration, DEBUG, EMSCRIPTEN_TEMP_DIR, DEBUG_CACHE, CANONICAL_TEMP_DIR, TEMP_DIR

  configuration = Configuration()

  DEBUG = configuration.DEBUG

  EMSCRIPTEN_TEMP_DIR = configuration.EMSCRIPTEN_TEMP_DIR

  DEBUG_CACHE = configuration.DEBUG_CACHE

  CANONICAL_TEMP_DIR = configuration.CANONICAL_TEMP_DIR

  TEMP_DIR = configuration.TEMP_DIR

apply_configuration()

 

logging.basicConfig(format='%(levelname)-8s %(name)s: %(message)s')

def set_logging():

  logger = logging.getLogger()

  logger.setLevel(logging.DEBUG if os.environ.get('EMCC_DEBUG') else logging.INFO)

set_logging()

 

  def prepare_to_clean_temp(d):

    def clean_temp():

      try_delete(d)

    atexit.register(clean_temp)

  prepare_to_clean_temp(EMSCRIPTEN_TEMP_DIR) # this global var might change later

# COMPILER_OPTS: options passed to clang when generating bitcode for us

COMPILER_OPTS = COMPILER_OPTS + ['-m32', '-DEMSCRIPTEN', '-D__EMSCRIPTEN__',

                                 '-fno-math-errno',

                                 #'-fno-threadsafe-statics', # disabled due to issue 1289

  COMPILER_OPTS = filter(lambda opt: opt != '-m32', COMPILER_OPTS) # le32 target is 32-bit anyhow, no need for -m32

# Remove various platform specific defines, and set little endian

COMPILER_STANDARDIZATION_OPTS = ['-U__i386__', '-U__i386', '-Ui386', '-U__STRICT_ANSI__', '-D__IEEE_LITTLE_ENDIAN',

                                 '-U__SSE__', '-U__SSE_MATH__', '-U__SSE2__', '-U__SSE2_MATH__', '-U__MMX__',

                                 '-U__APPLE__', '-U__linux__']

 

  EMSDK_OPTS = ['-nostdinc', '-Xclang', '-nobuiltininc', '-Xclang', '-nostdsysteminc',

    '-Xclang', '-isystem' + path_from_root('system', 'include', 'compat'),

  EMSDK_OPTS += COMPILER_STANDARDIZATION_OPTS

  if LLVM_TARGET != 'le32-unknown-nacl':

    EMSDK_CXX_OPTS = ['-nostdinc++'] # le32 target does not need -nostdinc++

  else:

    EMSDK_CXX_OPTS = []

  EMSDK_CXX_OPTS = []

  COMPILER_OPTS += COMPILER_STANDARDIZATION_OPTS

def limit_size(string, MAX=12000*20):

class Settings2(type):

  class __impl:

    attrs = {}

 

    def __init__(self):

      self.reset()

 

    @classmethod

    def reset(self):

      self.attrs = { 'QUANTUM_SIZE': 4 }

      self.load()

 

    # Given some emcc-type args (-O3, -s X=Y, etc.), fill Settings with the right settings

    @classmethod

    def load(self, args=[]):

      # Load the JS defaults into python

      settings = open(path_from_root('src', 'settings.js')).read().replace('//', '#')

      settings = re.sub(r'var ([\w\d]+)', r'self.attrs["\1"]', settings)

      exec settings

 

      # Apply additional settings. First -O, then -s

      for i in range(len(args)):

        if args[i].startswith('-O'):

          level = eval(args[i][2])

          self.apply_opt_level(level)

      for i in range(len(args)):

        if args[i] == '-s':

          declare = re.sub(r'([\w\d]+)\s*=\s*(.+)', r'self.attrs["\1"]=\2;', args[i+1])

          exec declare

 

    # Transforms the Settings information into emcc-compatible args (-s X=Y, etc.). Basically

    # the reverse of load_settings, except for -Ox which is relevant there but not here

    @classmethod

    def serialize(self):

      ret = []

      for key, value in self.attrs.iteritems():

        if key == key.upper(): # this is a hack. all of our settings are ALL_CAPS, python internals are not

          jsoned = json.dumps(value, sort_keys=True)

          ret += ['-s', key + '=' + jsoned]

      return ret

 

    @classmethod

    def copy(self, values):

      self.attrs = values

 

    @classmethod

    def apply_opt_level(self, opt_level, noisy=False):

      if opt_level >= 1:

        self.attrs['ASM_JS'] = 1

        self.attrs['ASSERTIONS'] = 0

        self.attrs['DISABLE_EXCEPTION_CATCHING'] = 1

        self.attrs['EMIT_GENERATED_FUNCTIONS'] = 1

      if opt_level >= 2:

        self.attrs['RELOOP'] = 1

        self.attrs['ALIASING_FUNCTION_POINTERS'] = 1

      if opt_level >= 3:

        # Aside from these, -O3 also runs closure compiler and llvm lto

        self.attrs['FORCE_ALIGNED_MEMORY'] = 1

        self.attrs['DOUBLE_MODE'] = 0

        self.attrs['PRECISE_I64_MATH'] = 0

        if noisy: logging.warning('Applying some potentially unsafe optimizations! (Use -O2 if this fails.)')

 

    def __getattr__(self, attr):

      if attr in self.attrs:

        return self.attrs[attr]

      else:

        raise AttributeError

 

    def __setattr__(self, attr, value):

      self.attrs[attr] = value

 

  __instance = None

 

  @staticmethod

  def instance():

    if Settings2.__instance is None:

      Settings2.__instance = Settings2.__impl()

    return Settings2.__instance

 

  def __getattr__(self, attr):

    return getattr(self.instance(), attr)

 

  def __setattr__(self, attr, value):

    return setattr(self.instance(), attr, value)

 

class Settings(object):

  __metaclass__ = Settings2

  JS_ENGINE_OVERRIDE = None # Used to pass the JS engine override from runner.py -> test_benchmark.py

    env['EMSCRIPTEN'] = path_from_root()

  # Finds the given executable 'program' in PATH. Operates like the Unix tool 'which'.

  @staticmethod

  def which(program):

    import os

    def is_exe(fpath):

      return os.path.isfile(fpath) and os.access(fpath, os.X_OK)

 

    fpath, fname = os.path.split(program)

    if fpath:

      if is_exe(program):

        return program

    else:

      for path in os.environ["PATH"].split(os.pathsep):

        path = path.strip('"')

        exe_file = os.path.join(path, program)

        if is_exe(exe_file):

          return exe_file

 

        if WINDOWS and not '.' in fname:

          if is_exe(exe_file + '.exe'):

            return exe_file + '.exe'

          if is_exe(exe_file + '.cmd'):

            return exe_file + '.cmd'

          if is_exe(exe_file + '.bat'):

            return exe_file + '.bat'

 

    return None

 

 

    def has_substr(array, substr):

      for arg in array:

        if substr in arg:

          return True

      return False

 

    # Append the Emscripten toolchain file if the user didn't specify one.

    if not has_substr(args, '-DCMAKE_TOOLCHAIN_FILE'):

      args.append('-DCMAKE_TOOLCHAIN_FILE=' + path_from_root('cmake', 'Platform', 'Emscripten.cmake'))

 

    # On Windows specify MinGW Makefiles if we have MinGW and no other toolchain was specified, to avoid CMake

    # pulling in a native Visual Studio, or Unix Makefiles.

    if WINDOWS and not '-G' in args and Building.which('mingw32-make'):

      args += ['-G', 'MinGW Makefiles']

 

      logging.error('Configure step failed with non-zero return code ' + str(process.returncode) + '! Command line: ' + str(args))

 

    # On Windows prefer building with mingw32-make instead of make, if it exists.

    if WINDOWS and args[0] == 'make':

      mingw32_make = Building.which('mingw32-make')

      if mingw32_make:

        args[0] = mingw32_make

 

    verbose_level = int(os.getenv('EM_BUILD_VERBOSE')) if os.getenv('EM_BUILD_VERBOSE') != None else 0

        Building.configure(configure + configure_args, env=env, stdout=open(os.path.join(project_dir, 'configure_'), 'w') if verbose_level < 2 else None,

                                                                stderr=open(os.path.join(project_dir, 'configure_err'), 'w') if verbose_level < 1 else None)

 

    if verbose_level >= 3:

      make_args += ['VERBOSE=1']

 

            Building.make(make + make_args, stdout=make_out if verbose_level < 2 else None,

                                            stderr=make_err if verbose_level < 1 else None, env=env)

          if verbose_level == 0:

            # Due to the ugly hack above our best guess is to output the first run

            with open_make_err(0) as ferr:

              for line in ferr:

                sys.stderr.write(line)

  def link(files, target, force_archive_contents=False):

    # Tracking unresolveds is necessary for .a linking, see below.

    # Specify all possible entry points to seed the linking process.

    # For a simple application, this would just be "main".

    unresolved_symbols = set([func[1:] for func in Settings.EXPORTED_FUNCTIONS])

                if new_symbols.defs.intersection(unresolved_symbols) or len(files) == 1 or force_archive_contents:

    logging.debug('emcc: llvm-linking: %s to %s', actual_files, target)

    link_cmd = LINK_CMD + actual_files + ['-o', target]

      link_cmd = LINK_CMD + ["@" + response_file]

    output = Popen([LLVM_OPT, filename] + opts + ['-o', filename + '.opt.bc'], stdout=PIPE).communicate()[0]

      output = Popen([LLVM_OPT, filename + '.o.pre'] + Building.LLVM_OPT_OPTS + ['-o', filename + '.o'], stdout=PIPE).communicate()[0]

    output = Popen([LLVM_DIS, input_filename, '-o', output_filename], stdout=PIPE).communicate()[0]

    output = Popen([LLVM_AS, input_filename, '-o', output_filename], stdout=PIPE).communicate()[0]

      # pnacl-nm will print zero offsets for bitcode

      if len(parts) == 3 and parts[0] == "00000000":

        parts.pop(0)

    return not Settings.BUILD_AS_SHARED_LIB and not Settings.LINKABLE and not Settings.EXPORT_ALL

    if not Building.can_build_standalone(): return [] # do not internalize anything

    exps = expand_response(Settings.EXPORTED_FUNCTIONS)

    exports = ','.join(map(lambda exp: exp[1:], exps))

        #addExtensionsToPM(EP_ScalarOptimizerLate, MPM)

  def js_optimizer(filename, passes, jcache=False, debug=False, extra_info=None):

    return js_optimizer.run(filename, passes, listify(NODE_JS), jcache, debug, extra_info)

        f.write("var Relooper = (function() {\n")

  memory_initializer_pattern = '/\* memory initializer \*/ allocate\(([\d,\.concat\(\)\[\]\\n ]+)"i8", ALLOC_NONE, ([\dRuntime\.GLOBAL_BASEH+]+)\)'

  no_memory_initializer_pattern = '/\* no memory initializer \*/'

 

  memory_staticbump_pattern = 'STATICTOP = STATIC_BASE \+ (\d+);'

 

  global_initializers_pattern = '/\* global initializers \*/ __ATINIT__.push\((.+)\);'

 

    return ident.replace('%', '$').replace('@', '_')

 

  @staticmethod

  def make_extcall(sig, named=True):

    args = ','.join(['a' + str(i) for i in range(1, len(sig))])

    args = 'index' + (',' if args else '') + args

    # C++ exceptions are numbers, and longjmp is a string 'longjmp'

    ret = '''function%s(%s) {

  %sModule["dynCall_%s"](%s);

}''' % ((' extCall_' + sig) if named else '', args, 'return ' if sig[0] != 'v' else '', sig, args)

 

    if Settings.DLOPEN_SUPPORT and Settings.ASSERTIONS:

      # guard against cross-module stack leaks

      ret = ret.replace(') {\n', ''') {

  try {

    var preStack = asm.stackSave();

''').replace(';\n}', ''';

  } finally {

    assert(asm.stackSave() == preStack);

  }

}''')

    return ret

 

  @staticmethod

  def make_invoke(sig, named=True):

    args = ','.join(['a' + str(i) for i in range(1, len(sig))])

    args = 'index' + (',' if args else '') + args

    # C++ exceptions are numbers, and longjmp is a string 'longjmp'

    ret = '''function%s(%s) {

  try {

    %sModule["dynCall_%s"](%s);

  } catch(e) {

    if (typeof e !== 'number' && e !== 'longjmp') throw e;

    asm["setThrew"](1, 0);

  }

}''' % ((' invoke_' + sig) if named else '', args, 'return ' if sig[0] != 'v' else '', sig, args)

 

    if Settings.DLOPEN_SUPPORT and Settings.ASSERTIONS:

      # guard against cross-module stack leaks

      ret = ret.replace('  try {', '''  var preStack = asm.stackSave();

  try {

''').replace('  }\n}', '''  } finally {

    assert(asm.stackSave() == preStack);

  }

}''')

 

    return ret

 

  @staticmethod

  def align(x, by):

    while x % by != 0: x += 1

    return x

def check_execute(cmd, *args, **kw):

  # TODO: use in more places. execute doesn't actually check that return values

  # are nonzero

  try:

    kw['stderr'] = STDOUT

    subprocess.check_output(cmd, *args, **kw)

    logging.debug("Successfuly executed %s" % " ".join(cmd))

  except subprocess.CalledProcessError as e:

    logging.error("'%s' failed with output:\n%s" % (" ".join(e.cmd), e.output))

    raise