webruby 0.1.0

data/modules/emscripten/tools/eliminator/safe-eliminator-test-output.js

@@ -0,0 +1,85 @@
+function a($directory) {
+ chak($directory + _strlen($directory) | 0);
+ var $210 = HEAP32[100];
+ HEAP32[1e3] = HEAP32[5];
+ HEAP32[90] = $210;
+ chak();
+ var $210a = HEAP32[100];
+ something();
+ HEAP32[90] = $210a;
+ chak();
+ HEAP32[1e3] = HEAP32[5];
+ HEAP32[90] = $hack;
+ chak();
+ var $b = HEAP32[11] + 7 | 0;
+ HEAP32[1e3] = HEAP32[5];
+ HEAP32[90] = $b;
+ chak();
+ var $bb2 = HEAP32[11];
+ HEAP32[111] = 321;
+ HEAP32[1e3] = HEAP32[5];
+ HEAP32[90] = $bb2 + 7 | 0;
+ chak();
+ HEAP32[1e3] = HEAP32[100];
+ chak();
+ var $e = func();
+ HEAP32[1e3] = $e;
+ chak();
+ tor(func());
+ chak();
+ tor(HEAP[9]);
+ barrier();
+ var $$210, $$210a, $$b, $$bb2, $$e;
+ $$210 = HEAP32[100];
+ HEAP32[1e3] = HEAP32[5];
+ HEAP32[90] = $$210;
+ chak();
+ $$210a = HEAP32[100];
+ something();
+ HEAP32[90] = $$210a;
+ chak();
+ HEAP32[1e3] = HEAP32[5];
+ HEAP32[90] = $$hack;
+ chak();
+ $$b = HEAP32[11] + 7 | 0;
+ HEAP32[1e3] = HEAP32[5];
+ HEAP32[90] = $$b;
+ chak();
+ $$bb2 = HEAP32[11];
+ HEAP32[111] = 321;
+ HEAP32[1e3] = HEAP32[5];
+ HEAP32[90] = $$bb2 + 7 | 0;
+ chak();
+ HEAP32[1e3] = HEAP32[100];
+ chak();
+ $$e = func();
+ HEAP32[1e3] = $$e;
+ chak();
+ tor(func());
+ chak();
+ tor(HEAP[9]);
+ barrier();
+ var $65, $image, $51$s2, $71;
+ var $71 = HEAP32[$65 >> 2] - _int_ceildiv(HEAP32[$image >> 2], HEAP32[$51$s2]) | 0;
+ HEAP32[$65 >> 2] = _int_ceildivpow2($71, HEAP32[$51$s2 + 10]);
+ barr();
+ var ONCE = sheep();
+ while (ONCE) {
+  work();
+ }
+ var ONCEb = 75;
+ while (ONCEb) {
+  work();
+ }
+ var $26 = __ZL3minIiET_S0_S0_12(4096, 4096 - $16 | 0);
+ print(FUNCTION_TABLE[$22]($18, $16 + ($this + 27) | 0, $26));
+ chak();
+ do {
+  print(10);
+ } while (0);
+ var zzz1 = 10;
+ do {
+  print(zzz1);
+ } while (1);
+}
+

data/modules/emscripten/tools/eliminator/safe-eliminator-test.js

@@ -0,0 +1,103 @@
+function a($directory) {
+ var $1 = _strlen($directory);
+ var $p_0 = $directory + $1 | 0;
+ chak($p_0);
+ var $210 = HEAP32[100]; // heaps alias each other! so this cannot be eliminated
+ HEAP32[1e3] = HEAP32[5];
+ HEAP32[90] = $210;
+ chak();
+ var $210a = HEAP32[100]; // function calls can also modify memory
+ something();
+ HEAP32[90] = $210a;
+ chak();
+ var $a = $hack; // no mem use (just a global), so ok to eliminate
+ HEAP32[1e3] = HEAP32[5];
+ HEAP32[90] = $a;
+ chak();
+ var $bb = HEAP32[11]; // ok to eliminate
+ var $b = ($bb+7)|0; // ok to eliminate by itself, but not with inlined $bb which is mem-using!
+ HEAP32[1e3] = HEAP32[5];
+ HEAP32[90] = $b;
+ chak();
+ var $bb2 = HEAP32[11];
+ HEAP32[111] = 321;
+ var $b2 = ($bb2+7)|0;
+ HEAP32[1e3] = HEAP32[5];
+ HEAP32[90] = $b2;
+ chak();
+ var $d = HEAP32[100]; // alias on next line, but that is where we are consumed - so ok.
+ HEAP32[1e3] = $d;
+ chak();
+ var $e = func();
+ HEAP32[1e3] = $e;
+ chak();
+ var $e2 = func();
+ tor($e2);
+ chak();
+ var $e3 = HEAP[9];
+ tor($e3);
+ barrier(); // same stuff, but with a var on top and assigns as the first and only def
+ var $$210, $$210a, $$a, $$bb, $$b, $$bb2, $$b2, $$d, $$e, $$e2, $$e3;
+ $$210 = HEAP32[100]; // heaps alias each other! so this cannot be eliminated
+ HEAP32[1e3] = HEAP32[5];
+ HEAP32[90] = $$210;
+ chak();
+ $$210a = HEAP32[100]; // function calls can also modify memory
+ something();
+ HEAP32[90] = $$210a;
+ chak();
+ $$a = $$hack; // no mem use, so ok to eliminate
+ HEAP32[1e3] = HEAP32[5];
+ HEAP32[90] = $$a;
+ chak();
+ $$bb = HEAP32[11]; // ok to eliminate
+ $$b = ($$bb+7)|0; // ok to eliminate by itself, but not with inlined $$bb which is mem-using!
+ HEAP32[1e3] = HEAP32[5];
+ HEAP32[90] = $$b;
+ chak();
+ $$bb2 = HEAP32[11];
+ HEAP32[111] = 321;
+ $$b2 = ($$bb2+7)|0;
+ HEAP32[1e3] = HEAP32[5];
+ HEAP32[90] = $$b2;
+ chak();
+ $$d = HEAP32[100]; // alias on next line, but that is where we are consumed - so ok.
+ HEAP32[1e3] = $$d;
+ chak();
+ $$e = func();
+ HEAP32[1e3] = $$e;
+ chak();
+ $$e2 = func();
+ tor($$e2);
+ chak();
+ $$e3 = HEAP[9];
+ tor($$e3);
+ barrier();
+ var $65, $image, $51$s2, $71;
+ var $66 = HEAP32[$65 >> 2];
+ var $71 = $66 - _int_ceildiv(HEAP32[$image >> 2], HEAP32[$51$s2]) | 0;
+ HEAP32[$65 >> 2] = _int_ceildivpow2($71, HEAP32[$51$s2 + 10]);
+ barr();
+ var ONCE = sheep();
+ while (ONCE) {
+  work();
+ }
+ var ONCEb = 75;
+ while (ONCEb) {
+  work();
+ }
+ var $26 = __ZL3minIiET_S0_S0_12(4096, 4096 - $16 | 0); // cannot eliminate this because the call might modify FUNCTION_TABLE
+ var $27 = FUNCTION_TABLE[$22]($18, $this + ($16 + 27) | 0, $26);
+ print($27);
+ chak();
+ var zzz = 10;
+ do {
+  print(zzz);
+ } while (0);
+ var zzz1 = 10;
+ do {
+  print(zzz1);
+ } while (1); // cannot eliminate a do-while that is not one-time
+}
+// EMSCRIPTEN_GENERATED_FUNCTIONS: ["a"]
+

data/modules/emscripten/tools/emconfiguren.py

@@ -0,0 +1,19 @@
+#!/usr/bin/env python2
+
+import sys
+print >> sys.stderr, '\n\nemconfiguren.py is deprecated! use "emconfigure"\n\n'
+
+'''
+This is a helper script for emmaken.py. See docs in that file for more info.
+'''
+
+import os, sys
+
+__rootpath__ = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+def path_from_root(*pathelems):
+  return os.path.join(__rootpath__, *pathelems)
+sys.path += [path_from_root('')]
+from tools.shared import *
+
+Building.configure(sys.argv[1:])
+

data/modules/emscripten/tools/emmaken.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python2
+
+import sys
+print >> sys.stderr, '\n\nemmaken.py is deprecated! use "emcc"\n\n'
+
+'''
+emmaken - the emscripten make proxy tool
+========================================
+
+Tell your build system to use this instead of the compiler, linker, ar and
+ranlib. All the normal build commands will be sent to this script, which
+will proxy them to the appropriate LLVM build commands, in order to
+generate proper code for Emscripten to later process.
+
+For example, compilation will be translated into calls to llvm-gcc
+with -emit-llvm, and linking will be translated into calls to llvm-link,
+and so forth.
+
+emmaken is only meant to *COMPILE* source code into LLVM bitcode. It does
+not do optimizations (in fact, it will disable -Ox flags and warn you
+about that). The reason is that doing such optimizations early can lead
+to bitcode that Emscripten cannot process properly, or can process but
+not fully optimize. You can (and probably should) still run LLVM
+optimizations though, by telling emscripten.py to do so (or run LLVM
+opt yourself, but be careful with the parameters you pass).
+
+Example uses:
+
+ * For configure, instead of ./configure, cmake, etc., run emconfiguren.py
+   with that command as an argument, for example
+
+    emconfiguren.py ./configure [options]
+  
+   emconfiguren.py is a tiny script that just sets some environment vars
+   as a convenience. The command just shown is equivalent to
+
+    EMMAKEN_JUST_CONFIGURE=1 RANLIB=PATH/emmaken.py AR=PATH/emmaken.py CXX=PATH/emmakenxx.py CC=PATH/emmaken.py ./configure [options]
+
+   where PATH is the path to this file.
+
+   EMMAKEN_JUST_CONFIGURE tells emmaken that it is being run in ./configure,
+   so it should relay everything to gcc/g++. You should not define that when
+   running make, of course.
+
+ * With CMake, the same command will work (with cmake instead of ./configure). You may also be
+   able to do the following in your CMakeLists.txt:
+
+    SET(CMAKE_C_COMPILER "PATH/emmaken.py")
+    SET(CMAKE_CXX_COMPILER "PATH/emmakenxx.py")
+    SET(CMAKE_LINKER "PATH/emmaken.py")
+    SET(CMAKE_CXX_LINKER "PATH/emmaken.py")
+    SET(CMAKE_C_LINK_EXECUTABLE "PATH/emmaken.py")
+    SET(CMAKE_CXX_LINK_EXECUTABLE "PATH/emmaken.py")
+    SET(CMAKE_AR "PATH/emmaken.py")
+    SET(CMAKE_RANLIB "PATH/emmaken.py")
+
+ * For SCons the shared.py can be imported like so:
+    __file__ = str(Dir('#/project_path_to_emscripten/dummy/dummy'))
+    __rootpath__ = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    def path_from_root(*pathelems):
+      return os.path.join(__rootpath__, *pathelems)
+    sys.path += [path_from_root('')]
+    from tools.shared import *
+    
+   For using the Emscripten compilers/linkers/etc. you can do:
+    env = Environment()
+    ...
+    env.Append(CCFLAGS = COMPILER_OPTS)
+    env.Replace(LINK = LLVM_LD)
+    env.Replace(LD   = LLVM_LD)
+   TODO: Document all relevant setup changes
+
+After setting that up, run your build system normally. It should generate
+LLVM instead of the normal output, and end up with .ll files that you can
+give to Emscripten. Note that this tool doesn't run Emscripten itself. Note
+also that you may need to do some manual fiddling later, for example to
+link files that weren't linked, and them llvm-dis them.
+
+Note the appearance of emmakenxx.py instead of emmaken.py
+for the C++ compiler. This is needed for cases where we get
+a C++ file with a C extension, in which case CMake can be told
+to run g++ on it despite the .c extension, see
+
+  https://github.com/kripken/emscripten/issues/6
+
+(If a similar situation occurs with ./configure, you can do the same there too.)
+
+emmaken can be influenced by a few environment variables:
+
+  EMMAKEN_NO_SDK - Will tell emmaken *not* to use the emscripten headers. Instead
+                   your system headers will be used.
+
+  EMMAKEN_COMPILER - The compiler to be used, if you don't want the default clang.
+
+'''
+
+import sys
+import os
+import subprocess
+
+print >> sys.stderr, 'emmaken.py: ', ' '.join(sys.argv)
+
+__rootpath__ = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+def path_from_root(*pathelems):
+  return os.path.join(__rootpath__, *pathelems)
+sys.path += [path_from_root('')]
+from tools.shared import *
+
+# If this is a configure-type thing, just do that
+CONFIGURE_CONFIG = os.environ.get('EMMAKEN_JUST_CONFIGURE')
+CMAKE_CONFIG = 'CMakeFiles/cmTryCompileExec.dir' in ' '.join(sys.argv)# or 'CMakeCCompilerId' in ' '.join(sys.argv)
+if CONFIGURE_CONFIG or CMAKE_CONFIG:
+  compiler = 'g++' if 'CXXCompiler' in ' '.join(sys.argv) or os.environ.get('EMMAKEN_CXX') else 'gcc'
+  cmd = [compiler] + EMSDK_OPTS + sys.argv[1:]
+  print >> sys.stderr, 'emmaken.py, just configuring: ', cmd
+  exit(subprocess.call(cmd))
+
+try:
+  #f=open('/dev/shm/tmp/waka.txt', 'a')
+  #f.write('Args: ' + ' '.join(sys.argv) + '\nCMake? ' + str(CMAKE_CONFIG) + '\n')
+  #f.close()
+
+  if os.environ.get('EMMAKEN_COMPILER'):
+    CXX = os.environ['EMMAKEN_COMPILER']
+  else:
+    CXX = CLANG
+
+  CC = to_cc(CXX)
+
+  # If we got here from a redirection through emmakenxx.py, then force a C++ compiler here
+  if os.environ.get('EMMAKEN_CXX'):
+    CC = CXX
+
+  CC_ADDITIONAL_ARGS = COMPILER_OPTS # + ['-g']?
+  ALLOWED_LINK_ARGS = ['-f', '-help', '-o', '-print-after', '-print-after-all', '-print-before',
+                       '-print-before-all', '-time-passes', '-v', '-verify-dom-info', '-version' ]
+  TWO_PART_DISALLOWED_LINK_ARGS = ['-L'] # Ignore thingsl like |-L .|
+
+  EMMAKEN_CFLAGS = os.environ.get('EMMAKEN_CFLAGS')
+  if EMMAKEN_CFLAGS: CC_ADDITIONAL_ARGS += EMMAKEN_CFLAGS.split(' ')
+
+  # ----------------  End configs -------------
+
+  if len(sys.argv) == 2 and 'conftest' not in ' '.join(sys.argv): # Avoid messing with configure, see below too
+    # ranlib
+    sys.exit(0)
+  if len(sys.argv) == 1 or sys.argv[1] in ['x', 't']:
+    # noop ar
+    sys.exit(0)
+
+  use_cxx = True
+  use_linker = True
+  header = False # pre-compiled headers. We fake that by just copying the file
+
+  opts = []
+  files = []
+  for i in range(1, len(sys.argv)):
+    arg = sys.argv[i]
+    if arg.startswith('-'):
+      opts.append(arg)
+    else:
+      files.append(arg)
+      if arg.endswith('.c'):
+        use_cxx = False
+      if arg.endswith(('.c', '.cc', '.cpp', '.dT')):
+        use_linker = False
+      if arg.endswith('.h') and sys.argv[i-1] != '-include':
+        header = True
+        use_linker = False
+
+  if '--version' in opts:
+    use_linker = False
+
+  if set(sys.argv[1]).issubset(set('-cruqs')): # ar
+    sys.argv = sys.argv[:1] + sys.argv[3:] + ['-o='+sys.argv[2]]
+    assert use_linker, 'Linker should be used in this case'
+
+  if use_linker:
+    call = LLVM_LD
+    newargs = ['-disable-opt']
+    found_o = False
+    i = 0
+    while i < len(sys.argv)-1:
+      i += 1
+      arg = sys.argv[i]
+      if found_o:
+        newargs.append('-o=%s' % arg)
+        found_o = False
+        continue
+      if arg.startswith('-'):
+        if arg == '-o':
+          found_o = True
+          continue
+        prefix = arg.split('=')[0]
+        if prefix in ALLOWED_LINK_ARGS:
+          newargs.append(arg)
+        if arg in TWO_PART_DISALLOWED_LINK_ARGS:
+          i += 1
+      elif arg.endswith('.so'):
+        continue # .so's do not exist yet, in many cases
+      else:
+        # not option, so just append
+        newargs.append(arg)
+  elif not header:
+    call = CXX if use_cxx else CC
+    newargs = sys.argv[1:]
+    for i in range(len(newargs)):
+      if newargs[i].startswith('-O'):
+        print >> sys.stderr, 'emmaken.py: WARNING: Optimization flags (-Ox) are ignored in emmaken. Tell emscripten.py to do that, or run LLVM opt.'
+        newargs[i] = ''
+    newargs = [ arg for arg in newargs if arg is not '' ] + CC_ADDITIONAL_ARGS
+    newargs.append('-emit-llvm')
+    if not use_linker:
+      newargs.append('-c') 
+  else:
+    print >> sys.stderr, 'Just copy.'
+    shutil.copy(sys.argv[-1], sys.argv[-2])
+    exit(0)
+
+  #f=open('/dev/shm/tmp/waka.txt', 'a')
+  #f.write('Calling: ' + ' '.join(newargs) + '\n\n')
+  #f.close()
+
+  print >> sys.stderr, "Running:", call, ' '.join(newargs)
+
+  subprocess.call([call] + newargs)
+except Exception, e:
+  print 'Error in emmaken.py. (Is the config file %s set up properly?) Error:' % EM_CONFIG, e
+  raise
+

data/modules/emscripten/tools/emmakenxx.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python2
+
+'''
+see emmaken.py
+'''
+
+import os, subprocess, sys
+
+__rootpath__ = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+def path_from_root(*pathelems):
+  return os.path.join(__rootpath__, *pathelems)
+sys.path += [path_from_root('')]
+from tools.shared import *
+
+emmaken = path_from_root('tools', 'emmaken.py')
+os.environ['EMMAKEN_CXX'] = '1'
+exit(subprocess.call([PYTHON, emmaken] + sys.argv[1:]))
+

data/modules/emscripten/tools/exec_llvm.py

@@ -0,0 +1,50 @@
+#!/usr/bin/python2
+
+'''
+Small utility to execute some llvm bitcode.
+
+The use case is a Makefile that builds some executable
+and runs it as part of the build process. With emmaken,
+the Makefile will generate llvm bitcode, so we can't
+just execute it directly. This script will get that
+code into a runnable form, and run it.
+
+We cannot just use lli, since code built with debug
+symbols will crash it due to
+
+  http://llvm.org/bugs/show_bug.cgi?id=6981
+
+So we must get around that.
+
+To use this, change the Makefile so that instead of
+running
+
+  /bin/sh THE_FILE PARAMS
+
+it runs
+
+  python $(EMSCRIPTEN_TOOLS)/exec_llvm.py THE_FILE PARAMS
+
+An alternative solution to this problem is to compile
+the .ll into native code, see nativize_llvm.py. That is
+useful when this fails.
+'''
+
+import os, sys
+from subprocess import Popen, PIPE, STDOUT
+
+__rootpath__ = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+def path_from_root(*pathelems):
+  return os.path.join(__rootpath__, *pathelems)
+sys.path += [path_from_root('')]
+from tools.shared import *
+
+Popen([LLVM_OPT, sys.argv[1], '-strip-debug', '-o=' + sys.argv[1]+'.clean.bc']).communicate()[0]
+
+# Execute with empty environment - just like the JS script will have
+Popen([LLVM_INTERPRETER, sys.argv[1]+'.clean.bc'] + sys.argv[2:], env={'HOME': '.'}).communicate()[0]
+
+#Popen([LLVM_COMPILER, '-march=c', sys.argv[1], '-o=' + sys.argv[1]+'.cbe.c']).communicate()[0]
+#Popen(['gcc', sys.argv[1]+'.cbe.c', '-lstdc++']).communicate()[0]
+#Popen(['./a.out'] + sys.argv[2:]).communicate()[0]
+

data/modules/emscripten/tools/file2json.py

@@ -0,0 +1,49 @@
+'''
+Converts a binary file into JSON.
+
+This lets you transform a binary file into something you can
+easily bundle inside a web page.
+
+Usage: file2json.py FILENAME VARNAME
+
+FILENAME - the binary file
+VARNAME - the variable to store it in (the output will be VARNAME = [...])
+'''
+
+import os, sys
+
+data = open(sys.argv[1], 'r').read()
+sdata = map(lambda x: str(ord(x)) + ',', data)
+sdata[-1] = sdata[-1].replace(',', '')
+lined = []
+while len(sdata) > 0:
+  lined += sdata[:30]
+  sdata = sdata[30:]
+  if len(sdata) > 0:
+    lined += ['\n']
+json = '[' + ''.join(lined) + ']'
+
+if len(sys.argv) < 3:
+  print json
+else:
+  print 'var ' + sys.argv[2] + '=' + json + ';'
+
+'''
+or (but this fails, we get a string at runtime?)
+
+data = open(sys.argv[1], 'r').read()
+counter = 0
+print '[',
+for i in range(len(data)):
+  last = i == len(data)-1
+  print ord(data[i]),
+  counter += 1
+  if counter % 20 == 0:
+    print
+  if counter % 1005 == 0 and not last:
+    print '] + [',
+  elif not last: print ',',
+
+print ']'
+'''
+