def try_js(args=[]):
     shared.try_delete(filename + '.js')
     js_args = [shared.PYTHON, shared.EMCC, opts] + llvm_opts + [
         fullname, '-o', filename + '.js'
     ] + CSMITH_CFLAGS + args
     if random.random() < 0.5:
         js_args += ['-s', 'ALLOW_MEMORY_GROWTH=1']
     if random.random() < 0.25:
         js_args += ['-s', 'INLINING_LIMIT=1'
                     ]  # inline nothing, for more call interaction
     if random.random() < 0.333:
         js_args += ['-s', 'EMTERPRETIFY=1']
         if random.random() < 0.5:
             if random.random() < 0.5:
                 js_args += [
                     '-s', 'EMTERPRETIFY_BLACKLIST=["_main"]'
                 ]  # blacklist main and all inlined into it, but interpret the rest, tests mixing
             else:
                 js_args += ['-s', 'EMTERPRETIFY_WHITELIST=["_main"]'
                             ]  # the opposite direction
         if random.random() < 0.5:
             js_args += ['-s', 'EMTERPRETIFY_ASYNC=1']
     print '(compile)', ' '.join(js_args)
     open(fullname, 'a').write('\n// ' + ' '.join(js_args) + '\n\n')
     try:
         shared.check_execute(js_args)
         assert os.path.exists(filename + '.js')
         return True
     except:
         return False
Exemple #2
0
 def try_js(args=[]):
   shared.try_delete(filename + '.js')
   js_args = [shared.PYTHON, shared.EMCC, opts] + llvm_opts + [fullname, '-o', filename + '.js'] + CSMITH_CFLAGS + args + ['-w']
   if random.random() < 0.5:
     js_args += ['-s', 'ALLOW_MEMORY_GROWTH=1']
   if random.random() < 0.5 and 'ALLOW_MEMORY_GROWTH=1' not in js_args:
     js_args += ['-s', 'MAIN_MODULE=1']
   if random.random() < 0.25:
     js_args += ['-s', 'INLINING_LIMIT=1'] # inline nothing, for more call interaction
   if random.random() < 0.333:
     js_args += ['-s', 'EMTERPRETIFY=1']
     if random.random() < 0.5:
       if random.random() < 0.5:
         js_args += ['-s', 'EMTERPRETIFY_BLACKLIST=["_main"]'] # blacklist main and all inlined into it, but interpret the rest, tests mixing
       else:
         js_args += ['-s', 'EMTERPRETIFY_WHITELIST=["_main"]'] # the opposite direction
     if random.random() < 0.5:
       js_args += ['-s', 'EMTERPRETIFY_ASYNC=1']
   if random.random() < 0.5:
     js_args += ["--memory-init-file", "0", "-s", "MEM_INIT_METHOD=2"]
   if random.random() < 0.5:
     js_args += ['-s', 'ASSERTIONS=1']
   print '(compile)', ' '.join(js_args)
   open(fullname, 'a').write('\n// ' + ' '.join(js_args) + '\n\n')
   try:
     shared.check_execute(js_args)
     assert os.path.exists(filename + '.js')
     return js_args
   except:
     return False
Exemple #3
0
 def create_optimizer():
     shared.logging.debug('building native optimizer: ' + name)
     output = shared.Cache.get_path(name)
     shared.try_delete(output)
     for compiler in [
             shared.CLANG, 'g++', 'clang++'
     ]:  # try our clang first, otherwise hope for a system compiler in the path
         shared.logging.debug('  using ' + compiler)
         try:
             out, err = subprocess.Popen(
                 [
                     compiler,
                     shared.path_from_root('tools', 'optimizer',
                                           'parser.cpp'),
                     shared.path_from_root('tools', 'optimizer',
                                           'simple_ast.cpp'),
                     shared.path_from_root('tools', 'optimizer',
                                           'optimizer.cpp'),
                     shared.path_from_root('tools', 'optimizer',
                                           'optimizer-shared.cpp'),
                     shared.path_from_root('tools', 'optimizer',
                                           'optimizer-main.cpp'),
                     '-O3', '-std=c++11', '-fno-exceptions',
                     '-fno-rtti', '-o', output
                 ] + args,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE).communicate()
             outs.append(out)
             errs.append(err)
         except OSError:
             if compiler == shared.CLANG:
                 raise  # otherwise, OSError is likely due to g++ or clang++ not being in the path
         if os.path.exists(output): return output
     raise NativeOptimizerCreationException()
 def try_js(args):
   shared.try_delete(filename + '.js')
   print '(compile)'
   shared.check_execute([shared.PYTHON, shared.EMCC, opts, fullname, '-o', filename + '.js'] + CSMITH_CFLAGS + args)
   assert os.path.exists(filename + '.js')
   print '(run)'
   js = shared.run_js(filename + '.js', engine=engine1, check_timeout=True, assert_returncode=None, cwd='/tmp/emscripten_temp')
   assert correct1 == js or correct2 == js, ''.join([a.rstrip()+'\n' for a in difflib.unified_diff(correct1.split('\n'), js.split('\n'), fromfile='expected', tofile='actual')])
Exemple #5
0
 def try_js(args):
   shared.try_delete(filename + '.js')
   print '(compile)'
   shared.check_execute([shared.EMCC, opts, filename + '.c', '-o', filename + '.js'] + CSMITH_CFLAGS + args)
   assert os.path.exists(filename + '.js')
   print '(run)'
   js = shared.run_js(filename + '.js', stderr=PIPE, engine=engine1, check_timeout=True)
   assert correct1 == js or correct2 == js, ''.join([a.rstrip()+'\n' for a in difflib.unified_diff(correct1.split('\n'), js.split('\n'), fromfile='expected', tofile='actual')])
Exemple #6
0
 def try_js(args):
   shared.try_delete(filename + '.js')
   print '(compile)'
   shared.execute([shared.EMCC, '-O2', '-s', 'ASM_JS=1', filename + '.c', '-o', filename + '.js'] + CSMITH_CFLAGS + args, stderr=PIPE)
   assert os.path.exists(filename + '.js')
   print '(run)'
   js = shared.run_js(filename + '.js', stderr=PIPE, engine=engine1, check_timeout=True)
   assert correct1 == js or correct2 == js, ''.join([a.rstrip()+'\n' for a in difflib.unified_diff(correct1.split('\n'), js.split('\n'), fromfile='expected', tofile='actual')])
Exemple #7
0
 def try_js(args):
   shared.try_delete(filename + '.js')
   print '(compile)'
   shared.check_execute([shared.PYTHON, shared.EMCC, opts, fullname, '-o', filename + '.js', '-s', 'PRECISE_F32=1'] + CSMITH_CFLAGS + args)
   assert os.path.exists(filename + '.js')
   print '(run in %s)' % engine1
   js = shared.run_js(filename + '.js', engine=engine1, check_timeout=True, assert_returncode=None, cwd='/tmp/emscripten_temp')
   js = js.split('\n')[0] + '\n' # remove any extra printed stuff (node workarounds)
   assert correct1 == js or correct2 == js, ''.join([a.rstrip()+'\n' for a in difflib.unified_diff(correct1.split('\n'), js.split('\n'), fromfile='expected', tofile='actual')])
Exemple #8
0
def create_load_wasm_worker():
  emscripten.logging.debug('building load-wasm-worker')
  output = emscripten.Cache.get_path('load-wasm-worker.js')
  emscripten.try_delete(output)
  check_call([PYTHON, emscripten.EMCC, emscripten.path_from_root('third_party', 'wasm-polyfill', 'src', 'unpack.cpp'),
                      emscripten.path_from_root('tools', 'optimizer', 'parser.cpp'),
                      '-o', output] + \
                      '-O3 -std=c++11 --memory-init-file 0 --llvm-lto 1 -s TOTAL_MEMORY=67108864 -s WASM=0'.split(' '))
  assert os.path.exists(output)
  open(output, 'a').write(open(emscripten.path_from_root('third_party', 'wasm-polyfill', 'src', 'load-wasm-worker.js')).read())
  return output
 def create_optimizer():
   shared.logging.debug('building native optimizer')
   output = shared.Cache.get_path('optimizer.exe')
   shared.try_delete(output)
   errs = []
   for compiler in [shared.CLANG, 'g++', 'clang++']: # try our clang first, otherwise hope for a system compiler in the path
     shared.logging.debug('  using ' + compiler)
     out, err = subprocess.Popen([compiler, shared.path_from_root('tools', 'optimizer', 'optimizer.cpp'), '-O3', '-std=c++11', '-fno-exceptions', '-fno-rtti', '-o', output], stderr=subprocess.PIPE).communicate()
     # for profiling/debugging: '-g', '-fno-omit-frame-pointer'
     if os.path.exists(output): return output
     errs.append(err)
   raise Exception('failed to build native optimizer, errors from each attempt: ' + '\n=================\n'.join(errs))
Exemple #10
0
def create_pack_asmjs():
  emscripten.logging.debug('building pack-asmjs')
  output = emscripten.Cache.get_path('pack-asmjs.js')
  emscripten.try_delete(output)
  check_call([PYTHON, emscripten.EMCC, emscripten.path_from_root('third_party', 'wasm-polyfill', 'src', 'pack-asmjs.cpp'),
                      emscripten.path_from_root('third_party', 'wasm-polyfill', 'src', 'unpack.cpp'),
                      emscripten.path_from_root('tools', 'optimizer', 'parser.cpp'),
                      '-o', output] + \
                      '-O3 -std=c++11 -DCHECKED_OUTPUT_SIZE --memory-init-file 0 --llvm-lto 1 -s TOTAL_MEMORY=67108864 -s WASM=0 -s INVOKE_RUN=0'.split(' ') + \
                     ['-I' + emscripten.path_from_root('tools', 'optimizer')])
  assert os.path.exists(output)
  open(output, 'a').write(open(emscripten.path_from_root('third_party', 'wasm-polyfill', 'src', 'pack-asmjs.js')).read())
  return output
Exemple #11
0
def create_load_wasm_worker():
    emscripten.logging.debug('building load-wasm-worker')
    output = emscripten.Cache.get_path('load-wasm-worker.js')
    emscripten.try_delete(output)
    check_call([PYTHON, emscripten.EMCC, emscripten.path_from_root('third_party', 'wasm-polyfill', 'src', 'unpack.cpp'),
                        emscripten.path_from_root('tools', 'optimizer', 'parser.cpp'),
                        '-o', output] + \
                        '-O3 -std=c++11 --memory-init-file 0 --llvm-lto 1 -s TOTAL_MEMORY=67108864 -s WASM=0'.split(' '))
    assert os.path.exists(output)
    open(output, 'a').write(
        open(
            emscripten.path_from_root('third_party', 'wasm-polyfill', 'src',
                                      'load-wasm-worker.js')).read())
    return output
def try_js(args):
    shared.try_delete(filename + '.js')
    shared.execute([
        shared.EMCC, '-O2', '-s', 'ASM_JS=1', '-s', 'PRECISE_I64_MATH=1', '-s',
        'PRECISE_I32_MUL=1', filename + '.c', '-o', filename + '.js'
    ] + CSMITH_CFLAGS + args,
                   stderr=PIPE)
    assert os.path.exists(filename + '.js')
    js = shared.run_js(filename + '.js', stderr=PIPE, engine=engine1)
    assert correct == js, ''.join([
        a.rstrip() + '\n' for a in difflib.unified_diff(correct.split('\n'),
                                                        js.split('\n'),
                                                        fromfile='expected',
                                                        tofile='actual')
    ])
Exemple #13
0
 def create_optimizer():
   shared.logging.debug('building native optimizer: ' + name)
   output = shared.Cache.get_path(name)
   shared.try_delete(output)
   for compiler in [shared.CLANG, 'g++', 'clang++']: # try our clang first, otherwise hope for a system compiler in the path
     shared.logging.debug('  using ' + compiler)
     try:
       subprocess.Popen([compiler,
                         shared.path_from_root('tools', 'optimizer', 'parser.cpp'),
                         shared.path_from_root('tools', 'optimizer', 'simple_ast.cpp'),
                         shared.path_from_root('tools', 'optimizer', 'optimizer.cpp'),
                         '-O3', '-std=c++11', '-fno-exceptions', '-fno-rtti', '-o', output] + args).communicate()
     except OSError:
       if compiler == shared.CLANG: raise # otherwise, OSError is likely due to g++ or clang++ not being in the path
     if os.path.exists(output): return output
   raise NativeOptimizerCreationException()
Exemple #14
0
def create_pack_asmjs():
    emscripten.logging.debug('building pack-asmjs')
    output = emscripten.Cache.get_path('pack-asmjs.js')
    emscripten.try_delete(output)
    check_call([PYTHON, emscripten.EMCC, emscripten.path_from_root('third_party', 'wasm-polyfill', 'src', 'pack-asmjs.cpp'),
                        emscripten.path_from_root('third_party', 'wasm-polyfill', 'src', 'unpack.cpp'),
                        emscripten.path_from_root('tools', 'optimizer', 'parser.cpp'),
                        '-o', output] + \
                        '-O3 -std=c++11 -DCHECKED_OUTPUT_SIZE --memory-init-file 0 --llvm-lto 1 -s TOTAL_MEMORY=67108864 -s WASM=0 -s INVOKE_RUN=0'.split(' ') + \
                       ['-I' + emscripten.path_from_root('tools', 'optimizer')])
    assert os.path.exists(output)
    open(output, 'a').write(
        open(
            emscripten.path_from_root('third_party', 'wasm-polyfill', 'src',
                                      'pack-asmjs.js')).read())
    return output
Exemple #15
0
 def try_js(args):
     shared.try_delete(filename + ".js")
     print "(compile)"
     shared.execute(
         [shared.EMCC, "-O2", "-s", "ASM_JS=1", filename + ".c", "-o", filename + ".js"] + CSMITH_CFLAGS + args,
         stderr=PIPE,
     )
     assert os.path.exists(filename + ".js")
     print "(run)"
     js = shared.run_js(filename + ".js", stderr=PIPE, engine=engine1, check_timeout=True)
     assert correct1 == js or correct2 == js, "".join(
         [
             a.rstrip() + "\n"
             for a in difflib.unified_diff(
                 correct1.split("\n"), js.split("\n"), fromfile="expected", tofile="actual"
             )
         ]
     )
 def try_js(args=[]):
     shared.try_delete(filename + '.js')
     js_args = [shared.PYTHON, shared.EMCC, opts] + llvm_opts + [
         fullname, '-o', filename + '.js'
     ] + CSMITH_CFLAGS + args + ['-w']
     if random.random() < 0.5:
         js_args += ['-s', 'ALLOW_MEMORY_GROWTH=1']
     if random.random() < 0.5 and 'ALLOW_MEMORY_GROWTH=1' not in js_args:
         js_args += ['-s', 'MAIN_MODULE=1']
     if random.random() < 0.25:
         js_args += ['-s', 'INLINING_LIMIT=1'
                     ]  # inline nothing, for more call interaction
     if random.random() < 0.333:
         js_args += ['-s', 'EMTERPRETIFY=1']
         if random.random() < 0.5:
             if random.random() < 0.5:
                 js_args += [
                     '-s', 'EMTERPRETIFY_BLACKLIST=["_main"]'
                 ]  # blacklist main and all inlined into it, but interpret the rest, tests mixing
             else:
                 js_args += ['-s', 'EMTERPRETIFY_WHITELIST=["_main"]'
                             ]  # the opposite direction
         if random.random() < 0.5:
             js_args += ['-s', 'EMTERPRETIFY_ASYNC=1']
     if random.random() < 0.5:
         js_args += ["--memory-init-file", "0", "-s", "MEM_INIT_METHOD=2"]
     if random.random() < 0.5:
         js_args += ['-s', 'ASSERTIONS=1']
     #js_args += ['-s', 'BINARYEN=1']
     #if random.random() < 0.333:
     #  js_args += ['-s', 'BINARYEN_METHOD="interpret-s-expr"']
     #elif random.random() < 0.5:
     #  js_args += ['-s', 'BINARYEN_METHOD="interpret-binary"']
     #else:
     #  js_args += ['-s', 'BINARYEN_METHOD="interpret-asm2wasm"']
     print '(compile)', ' '.join(js_args)
     open(fullname, 'a').write('\n// ' + ' '.join(js_args) + '\n\n')
     try:
         shared.check_execute(js_args)
         assert os.path.exists(filename + '.js')
         return js_args
     except:
         return False
Exemple #17
0
 def create_optimizer():
     shared.logging.debug("building native optimizer: " + name)
     output = shared.Cache.get_path(name)
     shared.try_delete(output)
     for compiler in [
         shared.CLANG,
         "g++",
         "clang++",
     ]:  # try our clang first, otherwise hope for a system compiler in the path
         shared.logging.debug("  using " + compiler)
         try:
             out, err = subprocess.Popen(
                 [
                     compiler,
                     shared.path_from_root("tools", "optimizer", "parser.cpp"),
                     shared.path_from_root("tools", "optimizer", "simple_ast.cpp"),
                     shared.path_from_root("tools", "optimizer", "optimizer.cpp"),
                     shared.path_from_root("tools", "optimizer", "optimizer-main.cpp"),
                     "-O3",
                     "-std=c++11",
                     "-fno-exceptions",
                     "-fno-rtti",
                     "-o",
                     output,
                 ]
                 + args,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
             ).communicate()
             outs.append(out)
             errs.append(err)
         except OSError:
             if compiler == shared.CLANG:
                 raise  # otherwise, OSError is likely due to g++ or clang++ not being in the path
         if os.path.exists(output):
             return output
     raise NativeOptimizerCreationException()
Exemple #18
0
      def create_optimizer_cmake():
        shared.logging.debug('building native optimizer via CMake: ' + name)
        output = shared.Cache.get_path(name)
        shared.try_delete(output)

        if NATIVE_OPTIMIZER == '1':
          cmake_build_type = 'RelWithDebInfo'
        elif NATIVE_OPTIMIZER == '2':
          cmake_build_type = 'Release'
        elif NATIVE_OPTIMIZER == 'g':
          cmake_build_type = 'Debug'

        build_path = shared.Cache.get_path('optimizer_build_' + cmake_build_type)
        shared.try_delete(os.path.join(build_path, 'CMakeCache.txt'))

        log_output = None if DEBUG else subprocess.PIPE
        if not os.path.exists(build_path):
          os.mkdir(build_path)

        if WINDOWS:
          # Poor man's check for whether or not we should attempt 64 bit build
          if os.environ.get('ProgramFiles(x86)'):
            cmake_generators = ['Visual Studio 12 Win64', 'Visual Studio 12', 'Visual Studio 11 Win64', 'Visual Studio 11', 'MinGW Makefiles', 'Unix Makefiles']
          else:
            cmake_generators = ['Visual Studio 12', 'Visual Studio 11', 'MinGW Makefiles', 'Unix Makefiles']
        else:
          cmake_generators = ['Unix Makefiles']

        for cmake_generator in cmake_generators:
          proc = subprocess.Popen(['cmake', '-G', cmake_generator, '-DCMAKE_BUILD_TYPE='+cmake_build_type, shared.path_from_root('tools', 'optimizer')], cwd=build_path, stdin=log_output, stdout=log_output, stderr=log_output)
          proc.communicate()
          make_env = os.environ.copy()
          if proc.returncode == 0:
            if 'Visual Studio' in cmake_generator:
              ret = find_msbuild(os.path.join(build_path, 'asmjs_optimizer.sln'), make_env)
              make = [ret[0], '/t:Build', '/p:Configuration='+cmake_build_type, '/nologo', '/verbosity:minimal', 'asmjs_optimizer.sln']
              make_env = ret[1]
            elif 'MinGW' in cmake_generator:
              make = ['mingw32-make']
            else:
              make = ['make']

            proc = subprocess.Popen(make, cwd=build_path, stdin=log_output, stdout=log_output, stderr=log_output, env=make_env)
            proc.communicate()
            if proc.returncode == 0:
              if WINDOWS and 'Visual Studio' in cmake_generator:
                shutil.copyfile(os.path.join(build_path, cmake_build_type, 'optimizer.exe'), output)
              else:
                shutil.copyfile(os.path.join(build_path, 'optimizer'), output)
              return output
            else:
              shared.try_delete(os.path.join(build_path, 'CMakeCache.txt'))
              # Proceed to next iteration of the loop to try next possible CMake generator.

        raise NativeOptimizerCreationException()
 def erase():
   shared.try_delete(Ports.get_dir())
Exemple #20
0
#!/usr/bin/env python2

'''
Splits a compiler outputted program into the asm module and the surrounding shell. This
can be useful if you want to process the shell in some manner (e.g. minifiy it) in ways
that would be harmful to asm.js code.
'''

import sys
import shared

try:
  me, in_shell, in_asm, outfile = sys.argv[:4]
except:
  print >> sys.stderr, 'usage: emlink.py [input file] [shell output file] [asm output file]'
  sys.exit(1)

print 'Shell input:', in_shell
print 'Asm input:', in_asm
print 'Input file:', outfile

shared.try_delete(outfile)

pre, post = open(in_shell).read().split('// ASM_CODE\n')
open(outfile, 'w').write(pre + '\n' + open(in_asm).read() + '\n' + post)

Exemple #21
0
  def fetch_project(name, url, subdir):
    fullname = os.path.join(Ports.get_dir(), name)

    if name not in Ports.name_cache: # only mention each port once in log
      logging.debug('including port: ' + name)
      logging.debug('    (at ' + fullname + ')')
      Ports.name_cache.add(name)

    class State:
      retrieved = False
      unpacked = False

    def retrieve():
      # if EMCC_LOCAL_PORTS is set, we use a local directory as our ports. This is useful
      # for testing. This env var should be in format
      #     name=dir|tag,name=dir|tag
      # e.g.
      #     sdl2=/home/username/dev/ports/SDL2|SDL2-master
      # so you could run
      #     EMCC_LOCAL_PORTS="sdl2=/home/alon/Dev/ports/SDL2|SDL2-master" ./tests/runner.py browser.test_sdl2_mouse
      # note that tag **must** be the tag in sdl.py, it is where we store to (not where we load from, we just load the local dir)
      local_ports = os.environ.get('EMCC_LOCAL_PORTS')
      if local_ports:
        local_ports = map(lambda pair: pair.split('='), local_ports.split(','))
        for local in local_ports:
          if name == local[0]:
            path, subdir = local[1].split('|')
            logging.warning('grabbing local port: ' + name + ' from ' + path + ', into ' + subdir)
            # zip up the directory, so it looks the same as if we downloaded a zip from the remote server
            z = zipfile.ZipFile(fullname + '.zip', 'w')
            def add_dir(p):
              for f in os.listdir(p):
                full = os.path.join(p, f)
                if os.path.isdir(full):
                  add_dir(full)
                else:
                  if not f.startswith('.'): # ignore hidden files, including .git/ etc.
                    z.write(full, os.path.join(subdir, os.path.relpath(full, path)))
            add_dir(path)
            z.close()
            State.retrieved = True
            return
      # retrieve from remote server
      logging.warning('retrieving port: ' + name + ' from ' + url)
      import urllib2
      f = urllib2.urlopen(url)
      data = f.read()
      open(fullname + '.zip', 'wb').write(data)
      State.retrieved = True

    def check_tag():
      z = zipfile.ZipFile(fullname + '.zip', 'r')
      names = z.namelist()
      if not (names[0].startswith(subdir + '/') or names[0].startswith(subdir + '\\')):
        # current zip file is old, force a retrieve
        return False
      return True

    def unpack():
      logging.warning('unpacking port: ' + name)
      shared.safe_ensure_dirs(fullname)
      z = zipfile.ZipFile(fullname + '.zip', 'r')
      try:
        cwd = os.getcwd()
        os.chdir(fullname)
        z.extractall()
      finally:
        os.chdir(cwd)
      State.unpacked = True

    # main logic

    if not os.path.exists(fullname + '.zip'):
      retrieve()

    if not os.path.exists(fullname):
      unpack()

    if not check_tag():
      logging.warning('local copy of port is not correct, retrieving from remote server')
      shared.try_delete(fullname)
      shared.try_delete(fullname + '.zip')
      retrieve()
      unpack()

    if State.unpacked:
      # we unpacked a new version, clear the build in the cache
      Ports.clear_project_build(name)
Exemple #22
0
DEBUG = os.environ.get('IDL_VERBOSE') is '1'

if DEBUG: print "Debug print ON, CHECKS=%s" % CHECKS

class Dummy(object):
  def __init__(self, init):
    for k, v in init.iteritems():
      self.__dict__[k] = v

  def getExtendedAttribute(self, name):
    return None

input_file = sys.argv[1]
output_base = sys.argv[2]

shared.try_delete(output_base + '.cpp')
shared.try_delete(output_base + '.js')

p = WebIDL.Parser()
p.parse(r'''
interface VoidPtr {
};
''' + open(input_file).read())
data = p.finish()

interfaces = {}
implements = {}
enums = {}

for thing in data:
  if isinstance(thing, WebIDL.IDLInterface):
Exemple #23
0
 def erase():
     shared.try_delete(Ports.get_dir())
Exemple #24
0
fails = 0

while 1:
  print 'Tried %d, notes: %s' % (tried, notes)
  print '1) Generate C'
  shared.execute([CSMITH, '--no-volatiles', '--no-math64', '--no-packed-struct'],# +
                 #['--max-block-depth', '2', '--max-block-size', '2', '--max-expr-complexity', '2', '--max-funcs', '2'],
                 stdout=open(filename + '.c', 'w'))
  #shutil.copyfile(filename + '.c', 'testcase%d.c' % tried)
  print '1) Generate C... %.2f K of C source' % (len(open(filename + '.c').read())/1024.)

  tried += 1

  print '2) Compile natively'
  shared.try_delete(filename)
  shared.execute([shared.CLANG_CC, '-O2', filename + '.c', '-o', filename + '1'] + CSMITH_CFLAGS, stderr=PIPE) #  + shared.EMSDK_OPTS
  shared.execute([shared.CLANG_CC, '-O2', '-emit-llvm', '-c', '-Xclang', '-triple=i386-pc-linux-gnu', filename + '.c', '-o', filename + '.bc'] + CSMITH_CFLAGS + shared.EMSDK_OPTS, stderr=PIPE)
  shared.execute([shared.path_from_root('tools', 'nativize_llvm.py'), filename + '.bc'], stdout=PIPE, stderr=PIPE)
  shutil.move(filename + '.bc.run', filename + '2')
  shared.execute([shared.CLANG_CC, filename + '.c', '-o', filename + '3'] + CSMITH_CFLAGS, stderr=PIPE)
  print '3) Run natively'
  try:
    correct1 = shared.timeout_run(Popen([filename + '1'], stdout=PIPE, stderr=PIPE), 3)
    if 'Segmentation fault' in correct1 or len(correct1) < 10: raise Exception('segfault')
    correct2 = shared.timeout_run(Popen([filename + '2'], stdout=PIPE, stderr=PIPE), 3)
    if 'Segmentation fault' in correct2 or len(correct2) < 10: raise Exception('segfault')
    correct3 = shared.timeout_run(Popen([filename + '3'], stdout=PIPE, stderr=PIPE), 3)
    if 'Segmentation fault' in correct3 or len(correct3) < 10: raise Exception('segfault')
    if correct1 != correct3: raise Exception('clang opts change result')
  except Exception, e:
 def try_js(args=[]):
   shared.try_delete(filename + '.js')
   js_args = [shared.PYTHON, shared.EMCC, fullname, '-o', filename + '.js'] + [opts] + llvm_opts + CSMITH_CFLAGS + args + ['-w']
   if 0: # binaryen testing, off by default for now
     js_args += ['-s', 'BINARYEN=1']
     r = random.random()
     if r < 0.45:
       js_args += ['-s', 'BINARYEN_METHOD="interpret-s-expr"']
     elif r < 0.90:
       js_args += ['-s', 'BINARYEN_METHOD="interpret-binary"']
     else:
       if random.random() < 0.5:
         js_args += ['-s', 'BINARYEN_METHOD="interpret-binary,asmjs"']
       else:
         js_args += ['-s', 'BINARYEN_METHOD="interpret-s-expr,asmjs"']
     if random.random() < 0.5:
       if random.random() < 0.5:
         js_args += ['--js-opts', '0']
       else:
         js_args += ['--js-opts', '1']
     if random.random() < 0.5:
       # pick random passes
       BINARYEN_PASSES = [
         "duplicate-function-elimination",
         "dce",
         "remove-unused-brs",
         "remove-unused-names",
         "optimize-instructions",
         "precompute",
         "simplify-locals",
         "vacuum",
         "coalesce-locals",
         "reorder-locals",
         "merge-blocks",
         "remove-unused-functions",
       ]
       passes = []
       while 1:
         passes.append(random.choice(BINARYEN_PASSES))
         if random.random() < 0.1:
           break
       js_args += ['-s', 'BINARYEN_PASSES="' + ','.join(passes) + '"']
   if random.random() < 0.5:
     js_args += ['-s', 'ALLOW_MEMORY_GROWTH=1']
   if random.random() < 0.5 and 'ALLOW_MEMORY_GROWTH=1' not in js_args and 'BINARYEN=1' not in js_args:
     js_args += ['-s', 'MAIN_MODULE=1']
   if random.random() < 0.25:
     js_args += ['-s', 'INLINING_LIMIT=1'] # inline nothing, for more call interaction
   if random.random() < 0.333:
     js_args += ['-s', 'EMTERPRETIFY=1']
     if random.random() < 0.5:
       if random.random() < 0.5:
         js_args += ['-s', 'EMTERPRETIFY_BLACKLIST=["_main"]'] # blacklist main and all inlined into it, but interpret the rest, tests mixing
       else:
         js_args += ['-s', 'EMTERPRETIFY_WHITELIST=["_main"]'] # the opposite direction
     if random.random() < 0.5:
       js_args += ['-s', 'EMTERPRETIFY_ASYNC=1']
   if random.random() < 0.5:
     js_args += ["--memory-init-file", "0", "-s", "MEM_INIT_METHOD=2"]
   if random.random() < 0.5:
     js_args += ['-s', 'ASSERTIONS=1']
   print '(compile)', ' '.join(js_args)
   short_args = [shared.PYTHON, shared.EMCC, fail_output_name] + js_args[5:]
   escaped_short_args = map(lambda x : ("'" + x + "'") if '"' in x else x, short_args)
   open(fullname, 'a').write('\n// ' + ' '.join(escaped_short_args) + '\n\n')
   try:
     shared.check_execute(js_args)
     assert os.path.exists(filename + '.js')
     return js_args
   except:
     return False
sys.path.append(shared.path_from_root('third_party', 'ply'))

import WebIDL

class Dummy:
  def __init__(self, init):
    for k, v in init.iteritems():
      self.__dict__[k] = v

  def getExtendedAttribute(self, name):
    return None

input_file = sys.argv[1]
output_base = sys.argv[2]

shared.try_delete(output_base + '.cpp')
shared.try_delete(output_base + '.js')

p = WebIDL.Parser()
p.parse(r'''
interface VoidPtr {
};
''' + open(input_file).read())
data = p.finish()

interfaces = {}
implements = {}
enums = {}

for thing in data:
  if isinstance(thing, WebIDL.IDLInterface):
Exemple #27
0
    def fetch_project(name, url, expected_version):
        fullname = os.path.join(Ports.get_dir(), name)

        if name not in Ports.name_cache:  # only mention each port once in log
            logging.warning('including port: ' + name)
            logging.debug('    (at ' + fullname + ')')
            Ports.name_cache.add(name)

        class State:
            retrieved = False
            unpacked = False

        def retrieve():
            logging.warning('retrieving port: ' + name + ' from ' + url)
            import urllib2
            f = urllib2.urlopen(url)
            data = f.read()
            open(fullname + '.zip', 'wb').write(data)
            State.retrieved = True

        def unpack():
            logging.warning('unpacking port: ' + name)
            import zipfile
            shared.safe_ensure_dirs(fullname)
            z = zipfile.ZipFile(fullname + '.zip', 'r')
            try:
                cwd = os.getcwd()
                os.chdir(fullname)
                z.extractall()
            finally:
                os.chdir(cwd)
            State.unpacked = True

        def check_version(expected_version):
            try:
                ok = False
                if not os.path.exists(fullname): return False
                subdir = os.listdir(fullname)
                if len(subdir) != 1: return False
                subdir = subdir[0]  # each port has a singleton subdir
                f = os.path.join(fullname, subdir, 'version.txt')
                if not os.path.exists(f):
                    return False  # no version, need an update
                version = open(f).read()
                version = int(version)
                ok = True
            finally:
                if not ok:
                    logging.error('error when checking port version for ' +
                                  name)
            return version >= expected_version

        # main logic

        if not os.path.exists(fullname + '.zip'):
            retrieve()

        if not os.path.exists(fullname):
            unpack()

        if not check_version(expected_version):
            # fetch a newer version
            assert not State.retrieved, 'just retrieved port ' + name + ', but not a new enough version?'
            shared.try_delete(fullname)
            shared.try_delete(fullname + '.zip')
            retrieve()
            unpack()
            assert check_version(
                expected_version
            ), 'just retrieved replacement port ' + name + ', but not a new enough version?'

        if State.unpacked:
            # we unpacked a new version, clear the build in the cache
            Ports.clear_project_build(name)
            def create_optimizer_cmake():
                shared.logging.debug("building native optimizer via CMake: " + name)
                output = shared.Cache.get_path(name)
                shared.try_delete(output)

                if NATIVE_OPTIMIZER == "1":
                    cmake_build_type = "RelWithDebInfo"
                elif NATIVE_OPTIMIZER == "2":
                    cmake_build_type = "Release"
                elif NATIVE_OPTIMIZER == "g":
                    cmake_build_type = "Debug"

                build_path = shared.Cache.get_path("optimizer_build_" + cmake_build_type)
                shared.try_delete(os.path.join(build_path, "CMakeCache.txt"))

                log_output = None if DEBUG else subprocess.PIPE
                if not os.path.exists(build_path):
                    os.mkdir(build_path)

                if WINDOWS:
                    cmake_generators = [
                        "Visual Studio 12 Win64",
                        "Visual Studio 12",
                        "Visual Studio 11 Win64",
                        "Visual Studio 11",
                        "MinGW Makefiles",
                        "Unix Makefiles",
                    ]
                else:
                    cmake_generators = ["Unix Makefiles"]

                for cmake_generator in cmake_generators:
                    proc = subprocess.Popen(
                        [
                            "cmake",
                            "-G",
                            cmake_generator,
                            "-DCMAKE_BUILD_TYPE=" + cmake_build_type,
                            shared.path_from_root("tools", "optimizer"),
                        ],
                        cwd=build_path,
                        stdin=log_output,
                        stdout=log_output,
                        stderr=log_output,
                    )
                    proc.communicate()
                    make_env = os.environ.copy()
                    if proc.returncode == 0:
                        if "Visual Studio" in cmake_generator:
                            ret = find_msbuild(os.path.join(build_path, "asmjs_optimizer.sln"), make_env)
                            make = [
                                ret[0],
                                "/t:Build",
                                "/p:Configuration=" + cmake_build_type,
                                "/nologo",
                                "/verbosity:minimal",
                                "asmjs_optimizer.sln",
                            ]
                            make_env = ret[1]
                        elif "MinGW" in cmake_generator:
                            make = ["mingw32-make"]
                        else:
                            make = ["make"]

                        proc = subprocess.Popen(
                            make, cwd=build_path, stdin=log_output, stdout=log_output, stderr=log_output, env=make_env
                        )
                        proc.communicate()
                        if proc.returncode == 0:
                            if WINDOWS and "Visual Studio" in cmake_generator:
                                shutil.copyfile(os.path.join(build_path, cmake_build_type, "optimizer.exe"), output)
                            else:
                                shutil.copyfile(os.path.join(build_path, "optimizer"), output)
                            return output
                        else:
                            shared.try_delete(os.path.join(build_path, "CMakeCache.txt"))
                            # Proceed to next iteration of the loop to try next possible CMake generator.

                raise NativeOptimizerCreationException()
Exemple #29
0
 def clear_project_build(name):
     shared.try_delete(os.path.join(Ports.get_build_dir(), name))
     shared.try_delete(shared.Cache.get_path(name + '.bc'))
def try_js(args):
  shared.try_delete(filename + '.js')
  shared.execute([shared.EMCC, '-O2', '-s', 'ASM_JS=1', '-s', 'PRECISE_I64_MATH=1', '-s', 'PRECISE_I32_MUL=1', filename + '.c', '-o', filename + '.js'] + CSMITH_CFLAGS + args, stderr=PIPE)
  assert os.path.exists(filename + '.js')
  js = shared.run_js(filename + '.js', stderr=PIPE, engine=engine1)
  assert correct == js, ''.join([a.rstrip()+'\n' for a in difflib.unified_diff(correct.split('\n'), js.split('\n'), fromfile='expected', tofile='actual')])
  def fetch_project(name, url, expected_version):
    fullname = os.path.join(Ports.get_dir(), name)

    if name not in Ports.name_cache: # only mention each port once in log
      logging.warning('including port: ' + name)
      logging.debug('    (at ' + fullname + ')')
      Ports.name_cache.add(name)

    class State:
      retrieved = False
      unpacked = False

    def retrieve():
      logging.warning('retrieving port: ' + name + ' from ' + url)
      import urllib2
      f = urllib2.urlopen(url)
      data = f.read()
      open(fullname + '.zip', 'wb').write(data)
      State.retrieved = True

    def unpack():
      logging.warning('unpacking port: ' + name)
      import zipfile
      shared.safe_ensure_dirs(fullname)
      z = zipfile.ZipFile(fullname + '.zip', 'r')
      try:
        cwd = os.getcwd()
        os.chdir(fullname)
        z.extractall()
      finally:
        os.chdir(cwd)
      State.unpacked = True

    def check_version(expected_version):
      try:
        ok = False
        if not os.path.exists(fullname): return False
        subdir = os.listdir(fullname)
        if len(subdir) != 1: return False
        subdir = subdir[0] # each port has a singleton subdir
        f = os.path.join(fullname, subdir, 'version.txt')
        if not os.path.exists(f): return False # no version, need an update
        version = open(f).read()
        version = int(version)
        ok = True
      finally:
        if not ok: logging.error('error when checking port version for ' + name)
      return version >= expected_version

    # main logic

    if not os.path.exists(fullname + '.zip'):
      retrieve()

    if not os.path.exists(fullname):
      unpack()

    if not check_version(expected_version):
      # fetch a newer version
      assert not State.retrieved, 'just retrieved port ' + name + ', but not a new enough version?'
      shared.try_delete(fullname)
      shared.try_delete(fullname + '.zip')
      retrieve()
      unpack()
      assert check_version(expected_version), 'just retrieved replacement port ' + name + ', but not a new enough version?'

    if State.unpacked:
      # we unpacked a new version, clear the build in the cache
      Ports.clear_project_build(name)
 def clear_project_build(name):
   shared.try_delete(os.path.join(Ports.get_build_dir(), name))
   shared.try_delete(shared.Cache.get_path(name + '.bc'))
'''

import os, sys, difflib
from subprocess import Popen, PIPE, STDOUT

sys.path += [
    os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))),
                 'tools')
]
import shared

filename = sys.argv[1]
print 'testing file', filename

print '2) Compile natively'
shared.try_delete(filename)
shared.execute([shared.CLANG_CC, '-O2', filename + '.c', '-o', filename] +
               CSMITH_CFLAGS,
               stderr=PIPE)
assert os.path.exists(filename)
print '3) Run natively'
try:
    correct = shared.timeout_run(Popen([filename], stdout=PIPE, stderr=PIPE),
                                 3)
except Exception, e:
    print 'Failed or infinite looping in native, skipping', e
    notes['invalid'] += 1
    os.exit(0)  # boring

print '4) Compile JS-ly and compare'
Exemple #34
0
  def relocate_into(self, main):
    # heap initializer
    if self.staticbump > 0:
      new_mem_init = self.mem_init_js[:self.mem_init_js.rfind(', ')] + ', Runtime.GLOBAL_BASE+%d)' % main.staticbump
      main.pre_js = re.sub(shared.JS.memory_staticbump_pattern, 'STATICTOP = STATIC_BASE + %d;\n' % (main.staticbump + self.staticbump) + new_mem_init, main.pre_js, count=1)

    # Find function name replacements TODO: do not rename duplicate names with duplicate contents, just merge them
    replacements = {}
    for func in self.funcs:
      rep = func
      while rep in main.funcs:
        rep += '_'
        replacements[func] = rep
    #print >> sys.stderr, 'replacements:', replacements

    # sendings: add invokes for new tables
    all_sendings = main.sendings
    added_sending = False
    for table in self.tables:
      if table not in main.tables:
        sig = table[table.rfind('_')+1:]
        func = 'invoke_%s' % sig
        all_sendings[func] = func
        main.pre_js += 'var %s = %s;\n' % (func, shared.JS.make_invoke(sig, named=False))
        added_sending = True

    # imports
    all_imports = main.imports
    for key, value in self.imports.iteritems():
      if key in self.funcs or key in main.funcs: continue # external function in one module, implemented in the other
      value_concrete = '.' not in value # env.key means it is an import, an external value, and not a concrete one
      main_value = main.imports.get(key)
      main_value_concrete = main_value and '.' not in main_value
      if value_concrete and main_value_concrete: continue # standard global var
      if not main_value or value_concrete:
        if '+' in value:
          # relocate
          value = value.replace('(', '').replace(')', '').replace('| 0', '').replace('|0', '').replace(' ', '')
          left, right = value.split('+')
          assert left == 'H_BASE'
          value = str(main.staticbump + int(right))
        all_imports[key] = value
      if (value_concrete or main_value_concrete) and key in all_sendings:
        del all_sendings[key] # import of external value no longer needed
    main.imports_js = '\n'.join(['var %s = %s;' % (key, value) for key, value in all_imports.iteritems()]) + '\n'

    # check for undefined references to global variables
    def check_import(key, value):
      if value.startswith('+') or value.endswith('|0'): # ignore functions
        if key not in all_sendings:
          print >> sys.stderr, 'warning: external variable %s is still not defined after linking' % key
          all_sendings[key] = '0'
    for key, value in all_imports.iteritems(): check_import(key, value)

    if added_sending:
      sendings_js = ', '.join(['%s: %s' % (key, value) for key, value in all_sendings.iteritems()])
      sendings_start = main.post_js.find('}, { ')+5
      sendings_end = main.post_js.find(' }, buffer);')
      main.post_js = main.post_js[:sendings_start] + sendings_js + main.post_js[sendings_end:]

    # tables
    f_bases = {}
    f_sizes = {}
    for table, data in self.tables.iteritems():
      main.tables[table] = self.merge_tables(table, main.tables.get(table), data, replacements, f_bases, f_sizes)
    main.combine_tables()
    #print >> sys.stderr, 'f bases', f_bases

    # relocate
    temp = shared.Building.js_optimizer(self.filename, ['asm', 'relocate', 'last'], extra_info={
      'replacements': replacements,
      'fBases': f_bases,
      'hBase': main.staticbump
    })
    #print >> sys.stderr, 'relocated side into', temp
    relocated_funcs = AsmModule(temp)
    shared.try_delete(temp)
    main.extra_funcs_js = relocated_funcs.funcs_js.replace(js_optimizer.start_funcs_marker, '\n')

    # update function table uses
    ft_marker = 'FUNCTION_TABLE_'

    def update_fts(what):
      updates = []
      i = 1 # avoid seeing marker in recursion
      while 1:
        i = what.find(ft_marker, i)
        if i < 0: break;
        start = i
        end = what.find('[', start)
        table = what[i:end]
        if table not in f_sizes:
          # table was not modified
          i += len(ft_marker)
          continue
        nesting = 1
        while nesting > 0:
          next = what.find(']', end+1)
          nesting -= 1
          nesting += what.count('[', end+1, next)
          end = next
        assert end > 0
        mask = what.rfind('&', start, end)
        assert mask > 0 and end - mask <= 13
        fixed = update_fts(what[start:mask+1] + str(f_sizes[table]-1) + ']')
        updates.append((start, end, fixed))
        i = end # additional function table uses were done by recursion
      # apply updates
      if len(updates) == 0: return what
      parts = []
      so_far = 0
      for i in range(len(updates)):
        start, end, fixed = updates[i]
        parts.append(what[so_far:start])
        parts.append(fixed)
        so_far = end+1
      parts.append(what[so_far:])
      return ''.join(parts)

    main.funcs_js = update_fts(main.funcs_js)
    main.extra_funcs_js = update_fts(main.extra_funcs_js)

    # global initializers
    if self.global_inits:
      my_global_inits = map(lambda init: replacements[init] if init in replacements else init, self.global_inits)
      all_global_inits = map(lambda init: '{ func: function() { %s() } }' % init, main.global_inits + my_global_inits)
      all_global_inits_js = '/* global initializers */ __ATINIT__.push(' + ','.join(all_global_inits) + ');'
      if main.global_inits:
        target = main.global_inits_js
      else:
        target = '// === Body ===\n'
        all_global_inits_js = target + all_global_inits_js
      main.pre_js = main.pre_js.replace(target, all_global_inits_js)

    # exports
    def rep_exp(export):
      key, value = export.split(':')
      if key in replacements:
        repped = replacements[key]
        return repped + ': ' + repped
      return export
    my_exports = map(rep_exp, self.exports)
    exports = main.exports.union(my_exports)
    main.exports_js = 'return {' + ','.join(list(exports)) + '};\n})\n'

    # post
    def rep_def(deff):
      key = deff.split(' ')[1]
      if key in replacements:
        rep = replacements[key]
        return 'var %s = Module["%s"] = asm["%s"];\n' % (rep, rep, rep)
      return deff
    my_module_defs = map(rep_def, self.module_defs)
    new_module_defs = set(my_module_defs).difference(main.module_defs)
    if len(new_module_defs) > 0:
      position = main.post_js.find('Runtime.') # Runtime is the start of the hardcoded ones
      main.post_js = main.post_js[:position] + ''.join(list(new_module_defs)) + '\n' + main.post_js[position:]
Exemple #35
0
#!/usr/bin/env python2
'''
Splits a compiler outputted program into the asm module and the surrounding shell. This
can be useful if you want to process the shell in some manner (e.g. minifiy it) in ways
that would be harmful to asm.js code.
'''

import sys
import shared
from asm_module import AsmModule

try:
    me, infile, out_shell, out_asm = sys.argv[:4]
except:
    print >> sys.stderr, 'usage: emlink.py [input file] [shell output file] [asm output file]'
    sys.exit(1)

print 'Input file:', infile
print 'Shell output:', out_shell
print 'Asm output:', out_asm

shared.try_delete(out_shell)
shared.try_delete(out_asm)

module = AsmModule(infile)

open(out_shell, 'w').write(module.pre_js + '\n// ASM_CODE\n' + module.post_js)
open(out_asm, 'w').write(module.asm_js)
Exemple #36
0
    def fetch_project(name, url, subdir):
        fullname = os.path.join(Ports.get_dir(), name)

        if name not in Ports.name_cache:  # only mention each port once in log
            logging.debug('including port: ' + name)
            logging.debug('    (at ' + fullname + ')')
            Ports.name_cache.add(name)

        class State:
            retrieved = False
            unpacked = False

        def retrieve():
            # if EMCC_LOCAL_PORTS is set, we use a local directory as our ports. This is useful
            # for testing. This env var should be in format
            #     name=dir|tag,name=dir|tag
            # e.g.
            #     sdl2=/home/username/dev/ports/SDL2|SDL2-version_5
            # so you could run
            #     EMCC_LOCAL_PORTS="sdl2=/home/alon/Dev/ports/SDL2|SDL2-version_5" ./tests/runner.py browser.test_sdl2_mouse
            # note that tag must be the tag in sdl.py, it is where we store to (not where we load from, we just load the local dir)
            local_ports = os.environ.get('EMCC_LOCAL_PORTS')
            if local_ports:
                local_ports = map(lambda pair: pair.split('='),
                                  local_ports.split(','))
                for local in local_ports:
                    if name == local[0]:
                        path, subdir = local[1].split('|')
                        logging.warning('grabbing local port: ' + name +
                                        ' from ' + path + ', into ' + subdir)
                        # zip up the directory, so it looks the same as if we downloaded a zip from the remote server
                        z = zipfile.ZipFile(fullname + '.zip', 'w')

                        def add_dir(p):
                            for f in os.listdir(p):
                                full = os.path.join(p, f)
                                if os.path.isdir(full):
                                    add_dir(full)
                                else:
                                    if not f.startswith(
                                            '.'
                                    ):  # ignore hidden files, including .git/ etc.
                                        z.write(
                                            full,
                                            os.path.join(
                                                subdir,
                                                os.path.relpath(full, path)))

                        add_dir(path)
                        z.close()
                        State.retrieved = True
                        return
            # retrieve from remote server
            logging.warning('retrieving port: ' + name + ' from ' + url)
            import urllib2
            f = urllib2.urlopen(url)
            data = f.read()
            open(fullname + '.zip', 'wb').write(data)
            State.retrieved = True

        def check_tag():
            # find subdir/version.txt
            z = zipfile.ZipFile(fullname + '.zip', 'r')
            names = z.namelist()
            if not (names[0].startswith(subdir + '/')
                    or names[0].startswith(subdir + '\\')):
                # current zip file is old, force a retrieve
                return False
            return True

        def unpack():
            logging.warning('unpacking port: ' + name)
            shared.safe_ensure_dirs(fullname)
            z = zipfile.ZipFile(fullname + '.zip', 'r')
            try:
                cwd = os.getcwd()
                os.chdir(fullname)
                z.extractall()
            finally:
                os.chdir(cwd)
            State.unpacked = True

        # main logic

        if not os.path.exists(fullname + '.zip'):
            retrieve()

        if not os.path.exists(fullname):
            unpack()

        if not check_tag():
            logging.warning(
                'local copy of port is not correct, retrieving from remote server'
            )
            shared.try_delete(fullname)
            shared.try_delete(fullname + '.zip')
            retrieve()
            unpack()

        if State.unpacked:
            # we unpacked a new version, clear the build in the cache
            Ports.clear_project_build(name)
Exemple #37
0
 def try_js(args=[]):
     shared.try_delete(filename + '.js')
     js_args = [
         shared.PYTHON, shared.EMCC, fullname, '-o', filename + '.js'
     ] + [opts] + llvm_opts + CSMITH_CFLAGS + args + ['-w']
     if 0:  # binaryen testing, off by default for now
         js_args += ['-s', 'BINARYEN=1']
         r = random.random()
         if r < 0.45:
             js_args += ['-s', 'BINARYEN_METHOD="interpret-s-expr"']
         elif r < 0.90:
             js_args += ['-s', 'BINARYEN_METHOD="interpret-binary"']
         else:
             if random.random() < 0.5:
                 js_args += [
                     '-s', 'BINARYEN_METHOD="interpret-binary,asmjs"'
                 ]
             else:
                 js_args += [
                     '-s', 'BINARYEN_METHOD="interpret-s-expr,asmjs"'
                 ]
         if random.random() < 0.5:
             if random.random() < 0.5:
                 js_args += ['--js-opts', '0']
             else:
                 js_args += ['--js-opts', '1']
         if random.random() < 0.5:
             # pick random passes
             BINARYEN_PASSES = [
                 "duplicate-function-elimination",
                 "dce",
                 "remove-unused-brs",
                 "remove-unused-names",
                 "optimize-instructions",
                 "precompute",
                 "simplify-locals",
                 "vacuum",
                 "coalesce-locals",
                 "reorder-locals",
                 "merge-blocks",
                 "remove-unused-functions",
             ]
             passes = []
             while 1:
                 passes.append(random.choice(BINARYEN_PASSES))
                 if random.random() < 0.1:
                     break
             js_args += ['-s', 'BINARYEN_PASSES="' + ','.join(passes) + '"']
     if random.random() < 0.5:
         js_args += ['-s', 'ALLOW_MEMORY_GROWTH=1']
     if random.random(
     ) < 0.5 and 'ALLOW_MEMORY_GROWTH=1' not in js_args and 'BINARYEN=1' not in js_args:
         js_args += ['-s', 'MAIN_MODULE=1']
     if random.random() < 0.25:
         js_args += ['-s', 'INLINING_LIMIT=1'
                     ]  # inline nothing, for more call interaction
     if random.random() < 0.333:
         js_args += ['-s', 'EMTERPRETIFY=1']
         if random.random() < 0.5:
             if random.random() < 0.5:
                 js_args += [
                     '-s', 'EMTERPRETIFY_BLACKLIST=["_main"]'
                 ]  # blacklist main and all inlined into it, but interpret the rest, tests mixing
             else:
                 js_args += ['-s', 'EMTERPRETIFY_WHITELIST=["_main"]'
                             ]  # the opposite direction
         if random.random() < 0.5:
             js_args += ['-s', 'EMTERPRETIFY_ASYNC=1']
     if random.random() < 0.5:
         js_args += ["--memory-init-file", "0", "-s", "MEM_INIT_METHOD=2"]
     if random.random() < 0.5:
         js_args += ['-s', 'ASSERTIONS=1']
     print '(compile)', ' '.join(js_args)
     short_args = [shared.PYTHON, shared.EMCC, fail_output_name
                   ] + js_args[5:]
     escaped_short_args = map(lambda x: ("'" + x + "'")
                              if '"' in x else x, short_args)
     open(fullname,
          'a').write('\n// ' + ' '.join(escaped_short_args) + '\n\n')
     try:
         shared.check_execute(js_args)
         assert os.path.exists(filename + '.js')
         return js_args
     except:
         return False