diff --git a/em++ b/em++
index 85236ebbcbe07..4aa8100e235da 100755
--- a/em++
+++ b/em++
@@ -3,6 +3,8 @@
 # This script should work in python 2 *or* 3. It loads emcc.py, which needs python 2.
 # It also tells emcc.py that we want C++ and not C by default
 
+from tools.toolchain_profiler import ToolchainProfiler
+
 import sys
 
 sys.argv += ['--emscripten-cxx']
@@ -10,7 +12,9 @@ sys.argv += ['--emscripten-cxx']
 if sys.version_info.major == 2:
   import emcc
   if __name__ == '__main__':
+    ToolchainProfiler.record_process_start()
     emcc.run()
+    sys.exit(0)
 else:
   import os, subprocess
   if __name__ == '__main__':
diff --git a/emar b/emar
index cd86e9e382cbc..4064f4dc19af5 100755
--- a/emar
+++ b/emar
@@ -2,15 +2,16 @@
 
 # This script should work in python 2 *or* 3. It loads emar.py, which needs python 2.
 
+from tools.toolchain_profiler import ToolchainProfiler
 
 import sys
 
-
-
 if sys.version_info.major == 2:
   import emar
   if __name__ == '__main__':
+    ToolchainProfiler.record_process_start()
     emar.run()
+    sys.exit(0)
 else:
   import os, subprocess
   if __name__ == '__main__':
diff --git a/emar.py b/emar.py
index 5f5e548dac623..b09cc6148d761 100755
--- a/emar.py
+++ b/emar.py
@@ -7,6 +7,8 @@
 This script acts as a frontend replacement for ar. See emcc.
 '''
 
+from tools.toolchain_profiler import ToolchainProfiler
+
 import os, subprocess, sys
 from tools import shared
 
@@ -59,4 +61,6 @@ def run():
       shared.try_delete(d)
 
 if __name__ == '__main__':
+  ToolchainProfiler.record_process_start()
   run()
+  sys.exit(0)
diff --git a/emcc b/emcc
index 0ea18a2d08715..6d6b241f33297 100755
--- a/emcc
+++ b/emcc
@@ -2,15 +2,16 @@
 
 # This script should work in python 2 *or* 3. It loads emcc.py, which needs python 2.
 
+from tools.toolchain_profiler import ToolchainProfiler
 
 import sys
 
-
-
 if sys.version_info.major == 2:
   import emcc
   if __name__ == '__main__':
+    ToolchainProfiler.record_process_start()
     emcc.run()
+    sys.exit(0)
 else:
   import os, subprocess
   if __name__ == '__main__':
diff --git a/emcc.py b/emcc.py
index 36f2ffed74c33..16a42a6056d3b 100755
--- a/emcc.py
+++ b/emcc.py
@@ -23,6 +23,10 @@
   EMMAKEN_COMPILER - The compiler to be used, if you don't want the default clang.
 '''
 
+from tools.toolchain_profiler import ToolchainProfiler
+if __name__ == '__main__':
+  ToolchainProfiler.record_process_start()
+
 import os, sys, shutil, tempfile, subprocess, shlex, time, re, logging
 from subprocess import PIPE
 from tools import shared, jsrun, system_libs
@@ -2103,3 +2107,4 @@ def un_src(): # use this if you want to modify the script and need it to be inli
 
 if __name__ == '__main__':
   run()
+  sys.exit(0)
diff --git a/emprofile.bat b/emprofile.bat
new file mode 100644
index 0000000000000..f9d8033274278
--- /dev/null
+++ b/emprofile.bat
@@ -0,0 +1,2 @@
+@echo off
+python "%~dp0\emprofile.py" %*
\ No newline at end of file
diff --git a/emprofile.py b/emprofile.py
new file mode 100755
index 0000000000000..d84444edab913
--- /dev/null
+++ b/emprofile.py
@@ -0,0 +1,92 @@
+#!/usr/bin/env python
+
+import sys, shutil, os, json, tempfile, time
+
+profiler_logs_path = os.path.join(tempfile.gettempdir(), 'emscripten_toolchain_profiler_logs')
+
+# If set to 1, always generates the output file under the same filename and doesn't delete the temp data.
+DEBUG_EMPROFILE_PY = 0
+
+OUTFILE = 'toolchain_profiler.results_' + time.strftime('%Y%m%d_%H%M')
+for arg in sys.argv:
+  if arg.startswith('--outfile='):
+    OUTFILE = arg.split('=')[1].strip().replace('.html', '')
+
+# Deletes all previously captured log files to make room for a new clean run.
+def delete_profiler_logs():
+  try:
+    shutil.rmtree(profiler_logs_path)
+  except:
+    pass
+
+def list_files_in_directory(d):
+  files = []
+  try:
+    items = os.listdir(d)
+    for i in items:
+      f = os.path.join(d, i)
+      if os.path.isfile(f):
+        files += [f]
+    return files
+  except:
+    return []
+
+def create_profiling_graph():
+  log_files = [f for f in list_files_in_directory(profiler_logs_path) if 'toolchain_profiler.pid_' in f]
+
+  all_results = []
+  if len(log_files) > 0:
+    print 'Processing ' + str(len(log_files)) + ' profile log files in "' + profiler_logs_path + '"...'
+  for f in log_files:
+    try:
+      json_data = open(f, 'r').read()
+      lines = json_data.split('\n')
+      lines = filter(lambda x: x != '[' and x != ']' and x != ',' and len(x.strip()) > 0, lines)
+      lines = map(lambda x: (x + ',') if not x.endswith(',') else x, lines)
+      lines[-1] = lines[-1][:-1]
+      json_data = '[' + '\n'.join(lines) + ']'
+      all_results += json.loads(json_data)
+    except Exception, e:
+      print >> sys.stderr, str(e)
+      print >> sys.stderr, 'Failed to parse JSON file "' + f + '"!'
+      sys.exit(1)
+  if len(all_results) == 0:
+    print 'No profiler logs were found in path "' + profiler_logs_path + '". Try setting the environment variable EM_PROFILE_TOOLCHAIN=1 and run some emcc commands, and then rerun "python emprofile.py --graph" again.'
+    return
+
+  all_results.sort(key=lambda x: x['time'])
+
+  json_file = OUTFILE + '.json'
+  open(json_file, 'w').write(json.dumps(all_results, indent=2))
+  print 'Wrote "' + json_file + '"'
+
+  html_file = OUTFILE + '.html'
+  html_contents = open(os.path.join(os.path.dirname(os.path.realpath(__file__)), 'tools', 'toolchain_profiler.results_template.html'), 'r').read().replace('{{{results_log_file}}}', '"' + json_file + '"')
+  open(html_file, 'w').write(html_contents)
+  print 'Wrote "' + html_file + '"'
+
+  if not DEBUG_EMPROFILE_PY:
+    delete_profiler_logs()
+
+if len(sys.argv) < 2:
+  print '''Usage:
+       emprofile.py --reset
+         Deletes all previously recorded profiling log files.
+
+       emprofile.py --graph
+         Draws a graph from all recorded profiling log files.
+
+Optional parameters:
+
+        --outfile=x.html
+          Specifies the name of the results file to generate.
+'''
+  sys.exit(1)
+
+if '--reset' in sys.argv:
+  delete_profiler_logs()
+elif '--graph' in sys.argv:
+  create_profiling_graph()
+else:
+  print 'Unknown command "' + sys.argv[1] + '"!'
+  sys.exit(1)
diff --git a/emscripten.py b/emscripten.py
index 265cc9eeea36d..6fab043c11170 100755
--- a/emscripten.py
+++ b/emscripten.py
@@ -9,6 +9,10 @@
 headers, for the libc implementation in JS).
 '''
 
+from tools.toolchain_profiler import ToolchainProfiler
+if __name__ == '__main__':
+  ToolchainProfiler.record_process_start()
+
 import os, sys, json, optparse, subprocess, re, time, logging
 
 from tools import shared
@@ -1729,3 +1733,4 @@ def _main(args=None):
 
 if __name__ == '__main__':
   _main()
+  sys.exit(0)
diff --git a/tools/js_optimizer.py b/tools/js_optimizer.py
index f6f5c8073a5a7..86c1a673081e9 100644
--- a/tools/js_optimizer.py
+++ b/tools/js_optimizer.py
@@ -1,4 +1,8 @@
 
+from toolchain_profiler import ToolchainProfiler
+if __name__ == '__main__':
+  ToolchainProfiler.record_process_start()
+
 import os, sys, subprocess, multiprocessing, re, string, json, shutil, logging
 import shared
 
@@ -559,4 +563,5 @@ def run(filename, passes, js_engine=shared.NODE_JS, source_map=False, extra_info
     extra_info = None
   out = run(sys.argv[1], sys.argv[2:], extra_info=extra_info)
   shutil.copyfile(out, sys.argv[1] + '.jsopt.js')
+  sys.exit(0)
 
diff --git a/tools/jsrun.py b/tools/jsrun.py
index 0f315e6d288d0..7f18418ecd1b5 100644
--- a/tools/jsrun.py
+++ b/tools/jsrun.py
@@ -1,3 +1,4 @@
+from toolchain_profiler import ToolchainProfiler
 import time, os, sys, logging
 from subprocess import Popen, PIPE, STDOUT
 
diff --git a/tools/shared.py b/tools/shared.py
index 2b22fd05bf05e..89592974b450b 100644
--- a/tools/shared.py
+++ b/tools/shared.py
@@ -1,3 +1,4 @@
+from toolchain_profiler import ToolchainProfiler
 import shutil, time, os, sys, json, tempfile, copy, shlex, atexit, subprocess, hashlib, cPickle, re, errno
 from subprocess import Popen, PIPE, STDOUT
 from tempfile import mkstemp
diff --git a/tools/toolchain_profiler.py b/tools/toolchain_profiler.py
new file mode 100644
index 0000000000000..f2f99e7b253c7
--- /dev/null
+++ b/tools/toolchain_profiler.py
@@ -0,0 +1,220 @@
+import subprocess, os, time, sys, tempfile
+
+EM_PROFILE_TOOLCHAIN = int(os.getenv('EM_PROFILE_TOOLCHAIN')) if os.getenv('EM_PROFILE_TOOLCHAIN') != None else 0
+
+if EM_PROFILE_TOOLCHAIN:
+  original_sys_exit = sys.exit
+  original_subprocess_call = subprocess.call
+  original_subprocess_check_call = subprocess.check_call
+  original_subprocess_check_output = subprocess.check_output
+  original_Popen = subprocess.Popen
+
+  def profiled_sys_exit(returncode):
+    ToolchainProfiler.record_process_exit(returncode)
+    original_sys_exit(returncode)
+
+  def profiled_call(cmd, *args, **kw):
+    pid = ToolchainProfiler.imaginary_pid()
+    ToolchainProfiler.record_subprocess_spawn(pid, cmd)
+    try:
+      returncode = original_subprocess_call(cmd, *args, **kw)
+    except Exception as e:
+      ToolchainProfiler.record_subprocess_finish(pid, 1)
+      raise e
+    ToolchainProfiler.record_subprocess_finish(pid, returncode)
+    return returncode
+
+  def profiled_check_call(cmd, *args, **kw):
+    pid = ToolchainProfiler.imaginary_pid()
+    ToolchainProfiler.record_subprocess_spawn(pid, cmd)
+    try:
+      ret = original_subprocess_check_call(cmd, *args, **kw)
+    except Exception as e:
+      ToolchainProfiler.record_subprocess_finish(pid, e.returncode)
+      raise e
+    ToolchainProfiler.record_subprocess_finish(pid, 0)
+    return ret
+
+  def profiled_check_output(cmd, *args, **kw):
+    pid = ToolchainProfiler.imaginary_pid()
+    ToolchainProfiler.record_subprocess_spawn(pid, cmd)
+    try:
+      ret = original_subprocess_check_output(cmd, *args, **kw)
+    except Exception as e:
+      ToolchainProfiler.record_subprocess_finish(pid, e.returncode)
+      raise e
+    ToolchainProfiler.record_subprocess_finish(pid, 0)
+    return ret
+
+  class ProfiledPopen:
+    def __init__(self, args, bufsize=0, executable=None, stdin=None, stdout=None, stderr=None, preexec_fn=None, close_fds=False,
+                 shell=False, cwd=None, env=None, universal_newlines=False, startupinfo=None, creationflags=0):
+      self.process = original_Popen(args, bufsize, executable, stdin, stdout, stderr, preexec_fn, close_fds, shell, cwd, env, universal_newlines, startupinfo, creationflags)
+      self.pid = self.process.pid
+      ToolchainProfiler.record_subprocess_spawn(self.pid, args)
+
+    def communicate(self, input=None):
+      ToolchainProfiler.record_subprocess_wait(self.pid)
+      output = self.process.communicate(input)
+      self.returncode = self.process.returncode
+      ToolchainProfiler.record_subprocess_finish(self.pid, self.returncode)
+      return output
+
+    def wait(self):
+      return self.process.wait()
+
+    def poll(self):
+      return self.process.poll()
+
+    def kill(self):
+      return self.process.kill()
+
+  sys.exit = profiled_sys_exit
+  subprocess.call = profiled_call
+  subprocess.check_call = profiled_check_call
+  subprocess.check_output = profiled_check_output
+  subprocess.Popen = ProfiledPopen
+
+  class ToolchainProfiler:
+    # Provide a running counter towards negative numbers for PIDs for which we don't know what the actual process ID is
+    imaginary_pid_ = 0
+
+    @staticmethod
+    def timestamp():
+      return '{0:.3f}'.format(time.time())
+
+    @staticmethod
+    def log_access():
+      # Note: This function is called in two importantly different contexts: in "main" process and in python subprocesses
+      # invoked via subprocessing.Pool.map(). The subprocesses have their own PIDs, and hence record their own data JSON
+      # files, but since the process pool is maintained internally by python, the toolchain profiler does not track the
+      # parent->child process spawns for the subprocessing pools. Therefore any profiling events that the subprocess
+      # children generate are virtually treated as if they were performed by the parent PID.
+      return open(os.path.join(ToolchainProfiler.profiler_logs_path, 'toolchain_profiler.pid_' + str(os.getpid()) + '.json'), 'a')
+
+    @staticmethod
+    def record_process_start(write_log_entry=True):
+      ToolchainProfiler.block_stack = []
+      # For subprocessing.Pool.map() child processes, this points to the PID of the parent process that spawned
+      # the subprocesses. This makes the subprocesses look as if the parent had called the functions.
+      ToolchainProfiler.mypid_str = str(os.getpid())
+      ToolchainProfiler.profiler_logs_path = os.path.join(tempfile.gettempdir(), 'emscripten_toolchain_profiler_logs')
+      try:
+        os.makedirs(ToolchainProfiler.profiler_logs_path)
+      except:
+        pass
+      if write_log_entry:
+        with ToolchainProfiler.log_access() as f:
+          f.write('[\n')
+          f.write('{"pid":' + ToolchainProfiler.mypid_str + ',"subprocessPid":' + str(os.getpid()) + ',"op":"start","time":' + ToolchainProfiler.timestamp() + ',"cmdLine":["' + '","'.join(sys.argv).replace('\\', '\\\\') + '"]}')
+
+    @staticmethod
+    def record_process_exit(returncode):
+      ToolchainProfiler.exit_all_blocks()
+      with ToolchainProfiler.log_access() as f:
+        f.write(',\n{"pid":' + ToolchainProfiler.mypid_str + ',"subprocessPid":' + str(os.getpid()) + ',"op":"exit","time":' + ToolchainProfiler.timestamp() + ',"returncode":' + str(returncode) + '}')
+        f.write('\n]\n')
+
+    @staticmethod
+    def record_subprocess_spawn(process_pid, process_cmdline):
+      with ToolchainProfiler.log_access() as f:
+        f.write(',\n{"pid":' + ToolchainProfiler.mypid_str + ',"subprocessPid":' + str(os.getpid()) + ',"op":"spawn","targetPid":' + str(process_pid) + ',"time":' + ToolchainProfiler.timestamp() + ',"cmdLine":["' + '","'.join(process_cmdline).replace('\\', '\\\\') + '"]}')
+
+    @staticmethod
+    def record_subprocess_wait(process_pid):
+      with ToolchainProfiler.log_access() as f:
+        f.write(',\n{"pid":' + ToolchainProfiler.mypid_str + ',"subprocessPid":' + str(os.getpid()) + ',"op":"wait","targetPid":' + str(process_pid) + ',"time":' + ToolchainProfiler.timestamp() + '}')
+
+    @staticmethod
+    def record_subprocess_finish(process_pid, returncode):
+      with ToolchainProfiler.log_access() as f:
+        f.write(',\n{"pid":' + ToolchainProfiler.mypid_str + ',"subprocessPid":' + str(os.getpid()) + ',"op":"finish","targetPid":' + str(process_pid) + ',"time":' + ToolchainProfiler.timestamp() + ',"returncode":' + str(returncode) + '}')
+
+    block_stack = []
+
+    @staticmethod
+    def enter_block(block_name):
+      with ToolchainProfiler.log_access() as f:
+        f.write(',\n{"pid":' + ToolchainProfiler.mypid_str + ',"subprocessPid":' + str(os.getpid()) + ',"op":"enterBlock","name":"' + block_name + '","time":' + ToolchainProfiler.timestamp() + '}')
+
+      ToolchainProfiler.block_stack.append(block_name)
+
+    @staticmethod
+    def remove_last_occurrence_if_exists(lst, item):
+      for i in xrange(len(lst)):
+        if lst[i] == item:
+          lst.pop(i)
+          return True
+      return False
+
+    @staticmethod
+    def exit_block(block_name):
+      if ToolchainProfiler.remove_last_occurrence_if_exists(ToolchainProfiler.block_stack, block_name):
+        with ToolchainProfiler.log_access() as f:
+          f.write(',\n{"pid":' + ToolchainProfiler.mypid_str + ',"subprocessPid":' + str(os.getpid()) + ',"op":"exitBlock","name":"' + block_name + '","time":' + ToolchainProfiler.timestamp() + '}')
+
+    @staticmethod
+    def exit_all_blocks():
+      for b in ToolchainProfiler.block_stack[::-1]:
+        ToolchainProfiler.exit_block(b)
+
+    class ProfileBlock:
+      def __init__(self, block_name):
+        self.block_name = block_name
+
+      def __enter__(self):
+        ToolchainProfiler.enter_block(self.block_name)
+
+      def __exit__(self, type, value, traceback):
+        ToolchainProfiler.exit_block(self.block_name)
+
+    @staticmethod
+    def profile_block(block_name):
+      return ToolchainProfiler.ProfileBlock(block_name)
+
+    @staticmethod
+    def imaginary_pid():
+      ToolchainProfiler.imaginary_pid_ -= 1
+      return ToolchainProfiler.imaginary_pid_
+
+else:
+  class ToolchainProfiler:
+    @staticmethod
+    def record_process_start():
+      pass
+
+    @staticmethod
+    def record_process_exit(returncode):
+      pass
+
+    @staticmethod
+    def record_subprocess_spawn(process_pid, process_cmdline):
+      pass
+
+    @staticmethod
+    def record_subprocess_wait(process_pid):
+      pass
+
+    @staticmethod
+    def record_subprocess_finish(process_pid, returncode):
+      pass
+
+    @staticmethod
+    def enter_block(block_name):
+      pass
+
+    @staticmethod
+    def exit_block(block_name):
+      pass
+
+    class ProfileBlock:
+      def __init__(self, block_name):
+        pass
+      def __enter__(self):
+        pass
+      def __exit__(self, type, value, traceback):
+        pass
+
+    @staticmethod
+    def profile_block(block_name):
+      return ToolchainProfiler.ProfileBlock(block_name)
diff --git a/tools/toolchain_profiler.results_template.html b/tools/toolchain_profiler.results_template.html
new file mode 100644
index 0000000000000..1094f831a0018
--- /dev/null
+++ b/tools/toolchain_profiler.results_template.html
@@ -0,0 +1,601 @@
+<!--
+The MIT License (MIT)
+
+Copyright (c) 2013 bill@bunkat.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+-->
+
+<!--
+
+d3.js swimlane chart example adapted to use in Emscripten from http://bl.ocks.org/bunkat/1962173
+
+-->
+
+<html><head>
+<meta charset="UTF-8">
+<title>Emscripten toolchain profiler results</title>
+<script src="https://d3js.org/d3.v3.min.js"></script>
+<style>
+.chart { shape-rendering: crispEdges; }
+.mini text { font: 9px sans-serif; }
+.main text { font: 12px sans-serif; }
+.month text { text-anchor: start; }
+.todayLine { stroke: blue; stroke-width: 1.5; }
+.axis line, .axis path { stroke: black; }
+.miniItem { stroke-width: 6; }
+.future { stroke: gray; fill: #ddd; }
+.past { stroke: green; }
+.brush .extent { stroke: gray; fill: blue; fill-opacity: .165; }
+</style>
+</head><body>
+
+<p>Show only blocks that took at least <input id='hideBlocksSmallerThan' value='10'></input> msecs (0=show all).<input type='button' value='Refresh' onclick='refresh()'></input>
+
+<script type="text/javascript">
+
+function getValueOfParam(param) {
+  var e = location.search.substr(1).split('&');
+  for(var i in e) {
+    var p = e[i].split('=');
+    if (p.length == 2 && p[0] == param) return p[1];
+  }
+}
+
+if (location.search.indexOf('hideBlocksSmallerThan') != -1) {
+  document.getElementById('hideBlocksSmallerThan').value = parseInt(getValueOfParam('hideBlocksSmallerThan'));
+}
+
+function refresh() {
+  var hideBlocksSmallerThan = parseInt(document.getElementById('hideBlocksSmallerThan').value);
+  var url = window.location.href;
+  if (url.indexOf('?') != -1) url = url.split('?')[0]
+  window.location.href = url + '?hideBlocksSmallerThan=' + hideBlocksSmallerThan;
+}
+
+// Dataset elements for d3.js: 'lanes' specify the rows, 'items' specify the individual blocks on the lanes.
+var lanes = [];
+var items = [];
+
+function pathBasename(absPath) {
+  return absPath.substr(Math.max(absPath.lastIndexOf('\\'), absPath.lastIndexOf('/'))+1);
+}
+
+function findPositionalParams(cmdLine, argsTakingParams) {
+  var np = [];
+  for(var i = 1; i < cmdLine.length; ++i) {
+    var perhapsKey = cmdLine[i-1];
+    var value = cmdLine[i];
+    if (value[0] != '-' && value[0] != '@' && argsTakingParams.indexOf(perhapsKey) == -1) {
+      np.push(value);
+    }
+  }
+  return np;
+}
+
+function cmdLineBasename(cmdLine) {
+  var cmd = cmdLine[0];
+  cmdname = pathBasename(cmd);
+
+  // cmdline could be '/path/to/node --param /path/to/file/to/run', in which case
+  // we want to return 'run' as the interesting command that was executed
+  if (cmdname.indexOf('node') == 0 || cmdname.indexOf('python') == 0) {
+    var positionalParams = findPositionalParams(cmdLine, []);
+    if (positionalParams.length > 0) cmdLineBasename(positionalParams);
+  }
+  return cmdname;
+}
+
+function findValueOfParam(cmdLine, key) {
+  var i = cmdLine.indexOf(key);
+  if (i != -1) return cmdLine[i+1];
+}
+
+function findInterestingParams(cmdLine, interestingParams) {
+  p = [];
+  for(var i in interestingParams) {
+    if (cmdLine.indexOf(interestingParams[i]) != -1)
+      p.push(interestingParams[i]);
+  }
+  return p;
+}
+
+function startsWith(str, substr) {
+  return str.indexOf(substr) == 0;
+}
+
+// A heuristic approach to finding print-worthy elements from a given command line array.
+function findInterestingBits(cmdLine) {
+  var basename = cmdLineBasename(cmdLine);
+  if (startsWith(basename, 'em++') || startsWith(basename, 'emcc')) {
+    src = findValueOfParam(cmdLine, '-c');
+    if (src) src = '-c ' + pathBasename(src);
+    else {
+      src = findValueOfParam(cmdLine, '-o');
+      if (src) src = '-o ' + pathBasename(src);
+    }
+    return [basename, src];
+  } else if (startsWith(basename, 'clang') || startsWith(basename, 'clang++')) {
+    var posParams = findPositionalParams(cmdLine, ['-target', '-o']);
+    for(var i = 0; i < posParams.length; ++i) {
+      if (posParams[i].indexOf('.c') != -1 && (posParams[i].indexOf('/') != -1 || posParams[i].indexOf('\\') != -1))
+        posParams[i] = pathBasename(posParams[i]);
+    }
+    var out = findValueOfParam(cmdLine, '-o');
+    if (out) out = '-o ' + pathBasename(out);
+    if (cmdLine.length <= 3) return [basename].concat(cmdLine.slice(1));
+    return [basename].concat(posParams).concat([out]);
+  } else if (startsWith(basename, 'llvm-ar') || startsWith(basename, 'optimizer') || startsWith(basename, 'asm2wasm') || startsWith(basename, 'wasm-as')) {
+    for(var i = 0; i < cmdLine.length; ++i) {
+      if (cmdLine[i].indexOf('/') != -1 || cmdLine[i].indexOf('\\') != -1)
+        cmdLine[i] = pathBasename(cmdLine[i]);
+    }
+    return cmdLine;
+  } else if (startsWith(basename, 'opt')) {
+    var interestingParams = findInterestingParams(cmdLine, ['-O0', '-O1', '-O2', '-O3', '-Os', '-Oz'])
+    var out = findValueOfParam(cmdLine, '-o');
+    if (out) out = '-o ' + pathBasename(out);
+    return [basename].concat(interestingParams).concat([out]);
+  } else if (startsWith(basename, 'llvm-nm')) {
+    var posParams = findPositionalParams(cmdLine, []);
+    for(var i = 0; i < posParams.length; ++i) {
+      if (posParams[i].indexOf('/') != -1 || posParams[i].indexOf('\\') != -1)
+        posParams[i] = pathBasename(posParams[i]);
+    }
+    return [basename].concat(posParams);
+  } else if (startsWith(basename, 'llc')) {
+    var interestingParams = findInterestingParams(cmdLine, ['-O0', '-O1', '-O2', '-O3', '-Os', '-Oz'])
+    var posParams = findPositionalParams(cmdLine, ['-o']);
+    for(var i = 0; i < posParams.length; ++i) {
+      if (posParams[i].indexOf('/') != -1 || posParams[i].indexOf('\\') != -1)
+        posParams[i] = pathBasename(posParams[i]);
+    }
+    var ret = [basename].concat(interestingParams).concat(posParams);
+    var out = findValueOfParam(cmdLine, '-o');
+    if (out) {
+      out = '-o ' + pathBasename(out);
+      if (out.indexOf('tmp') != 0)
+        ret.concat([out]);
+    }
+    return ret;
+  } else if (startsWith(basename, 'compiler.js')) {
+    var posParams = findPositionalParams(cmdLine, []);
+    var interestingParams = [];
+    for(var i = 1; i < posParams.length; ++i) {
+      if (posParams[i].indexOf('/') != -1 || posParams[i].indexOf('\\') != -1)
+        posParams[i] = pathBasename(posParams[i]);
+      interestingParams.push(posParams[i]);
+    }
+    return [basename].concat(interestingParams);
+  } else if (startsWith(basename, 'js-optimizer.js')) {
+    var posParams = findPositionalParams(cmdLine, []);
+    var interestingParams = [];
+    for(var i = 1; i < posParams.length; ++i) {
+      if (posParams[i].indexOf('/') != -1 || posParams[i].indexOf('\\') != -1)
+        posParams[i] = pathBasename(posParams[i]);
+      if (posParams[i].indexOf('tmp') != 0)
+        interestingParams.push(posParams[i]);
+    }
+    return [basename].concat(interestingParams);
+  } else {
+    return [basename];
+  }
+}
+
+// Time extents of the times on the swimlane
+var firstStartTime = Infinity;
+var lastEndTime = -Infinity;
+
+function createSwimlaneChart(data) {
+  var itemsByPid = {};
+
+  var t0 = Infinity;
+  for(var i in data) {
+    t0 = Math.min(t0, data[i].time)
+    lastEndTime = Math.max(lastEndTime, data[i].time);
+  }
+  firstStartTime = t0;
+
+  var itemsOrdered = [];
+
+  var itemStackByPid = {};
+  function pushItemToStack(item, pid) {
+    if (!itemStackByPid[pid]) itemStackByPid[pid] = [item];
+    else {
+      var parent = topOnStack(pid);
+      if (parent) {
+        parent.children.push(item);
+      }
+      itemStackByPid[pid].push(item);
+    }
+  }
+  function topOnStack(pid) {
+    if (!itemStackByPid[pid]) return null;
+    return itemStackByPid[pid][itemStackByPid[pid].length-1];
+  }
+  function popItemFromStack(item, pid) {
+    var stack = itemStackByPid[pid];
+    for(var i = stack.length-1; i >= 0; --i)
+      if (stack[i] === item) {
+        stack.splice(i, 1);
+        return;
+      }
+  }
+
+  var startOrder = 0; // Tiebreaker for sorting predicate
+  for(var i in data) {
+    var d = data[i];
+    if (d.op === 'start') { // A top-level tool process has started
+      itemsByPid[d.pid] = {
+        pid: d.pid,
+        start: (d.time - t0)*1000,
+        end: null,
+        startOrder: startOrder++,
+        cmdLine: d.cmdLine,
+        cmd: findInterestingBits(d.cmdLine).join(' '),
+        color: d3.rgb('#80ff80'),
+        parent: null,
+        children: []
+      };
+      pushItemToStack(itemsByPid[d.pid], d.pid);
+    } else if (d.op === 'exit') { // A top-level tool process has finished
+      itemsByPid[d.pid].end = (d.time - t0)*1000;
+      d.end = (d.time - t0)*1000;
+      itemsOrdered.push(itemsByPid[d.pid]);
+      popItemFromStack(itemsByPid[d.pid], d.pid);
+      delete itemsByPid[d.pid];
+    } else if (d.op === 'spawn') { // A subprocess was spawned
+      itemsByPid[d.targetPid] = {
+        parentPid: d.pid,
+        pid: d.targetPid,
+        start: (d.time - t0)*1000,
+        end: null,
+        startOrder: startOrder++,
+        cmdLine: d.cmdLine,
+        cmd: findInterestingBits(d.cmdLine).join(' '),
+        color: d3.rgb('#80ff80'),
+        parent: topOnStack(d.pid),
+        children: []
+      };
+      pushItemToStack(itemsByPid[d.targetPid], d.pid);
+      pushItemToStack(itemsByPid[d.targetPid], d.targetPid);
+    } else if (d.op === 'finish') { // A subprocess has finished
+      itemsByPid[d.targetPid].end = (d.time - t0)*1000;
+      itemsOrdered.push(itemsByPid[d.targetPid]);
+      popItemFromStack(itemsByPid[d.targetPid], d.pid);
+      popItemFromStack(itemsByPid[d.targetPid], d.targetPid);
+      delete itemsByPid[d.targetPid];
+    } else if (d.op === 'enterBlock') { // A custom profiling block has been stepped into
+      var id = d.pid + '-' + d.name + '-' + d.subprocessPid;
+      itemsByPid[id] = {
+        pid: d.pid,
+        start: (d.time - t0)*1000,
+        end: null,
+        startOrder: startOrder++,
+        cmd: d.name,
+        color: d3.rgb('#8080ff'),
+        parent: topOnStack(d.pid),
+        children: []
+      };
+      pushItemToStack(itemsByPid[id], d.pid);
+    } else if (d.op === 'exitBlock') { // A custom profiling block has been exited
+      var id = d.pid + '-' + d.name + '-' + d.subprocessPid;
+      itemsByPid[id].end = (d.time - t0)*1000;
+      itemsOrdered.push(itemsByPid[id]);
+      popItemFromStack(itemsByPid[id], d.pid);
+      delete itemsByPid[id];
+    }
+  }
+
+  // Need to have siblings in proceeding time order so that they appear on the lanes correctly.
+  for(var i in itemsByPid) itemsOrdered.push(itemsByPid[i]);
+  itemsOrdered.sort(function(a, b) { if (a.start == b.start) return a.startOrder - b.startOrder; else return a.start - b.start;});
+
+  // Specifies for each lane (row) how far to the right it is used.
+  var laneOccupancy = [];
+  var lanes = [];
+
+  // Tests whether the whole tree of items, with its root/parent node 'item', fits if
+  // the root 'item' is placed on lane index 'lane' (and the children placed on the subsequent lanes underneath)
+  function itemHierarchyFitsRootedOnLane(item, lane) {
+    var i = item;
+    while(i && lane < laneOccupancy.length) {
+      if (i.start < laneOccupancy[lane]) return false;
+      ++lane;
+      i = i.children[0];
+    }
+    return true;
+  }
+  function fitLaneHierarchy(item) {
+    var parent = item.parent;
+    var highestLaneAllowed = 0;
+    // Child should never be drawn on the same or above lane as its parent.
+    if (parent) highestLaneAllowed = parent.visualBlock.lane+1;
+    for(var lane = highestLaneAllowed; lane < laneOccupancy.length; ++lane) {
+      if (itemHierarchyFitsRootedOnLane(item, lane)) {
+        laneOccupancy[lane] = item.visualEnd;
+        return lane;
+      }
+    }
+    laneOccupancy.push(item.visualEnd);
+    lanes.push({
+      id: laneOccupancy.length-1,
+      label: laneOccupancy.length-1
+    });
+    return laneOccupancy.length-1;
+  }
+
+  // Filter items that took too little time and should not be displayed.
+  var hideBlocksSmallerThan = parseInt(document.getElementById('hideBlocksSmallerThan').value);
+  for(var i = 0; i < itemsOrdered.length; ++i) {
+    var p = itemsOrdered[i];
+    var duration = p.end - p.start;
+    if (duration < hideBlocksSmallerThan) { // Should this be hidden?
+      // removing this node, so connect the parent and children.
+      var parent = p.parent;
+      var children = p.children;
+
+      // Disconnect this node from the child list of its parent, and root up all children of this
+      // to be children of the parent, but be careful to preserve position, i.e. the children should
+      // appear in the place in array where the current node was.
+      if (parent) {
+        var parentIdx = parent.children.indexOf(p);
+        if (parentIdx < 0) throw 'internal error: inconsistent tree structure!';
+        var head = parent.children.slice(0, parentIdx);
+        var tail = parent.children.slice(parentIdx + 1, parent.children.length);
+        parent.children = head.concat(children).concat(tail);
+      }
+
+      // Update the parent node of each child.
+      for(var c in children) children[c].parent = parent;
+
+      itemsOrdered.splice(i, 1);
+      --i;
+    }
+  }
+
+  var id = 0;
+  for(var i in itemsOrdered) {
+    var p = itemsOrdered[i];
+
+    var label = '(' + (p.end - p.start).toFixed(0) + 'ms) ' + p.cmd;
+    p.visualEnd = Math.max(p.end, p.start + label.length*14);
+    var laneIndex = fitLaneHierarchy(p);
+
+    var item = {
+      class: 'past',
+      desc: 'Description',
+      start: p.start,
+      end: p.end,
+      id: id,
+      lane: laneIndex,
+      cmdLine: p.cmdLine,
+      cmd: p.cmd,
+      color: p.color,
+      label: label
+    };
+    p.visualBlock = item;
+    items.push(item);
+    ++id;
+  }
+
+  var margin = {top: 20, right: 15, bottom: 15, left: 60};
+  var width = document.body.clientWidth - margin.left - margin.right - 50;
+  var height = lanes.length * 30;
+  var miniHeight = lanes.length*7;
+  var mainHeight = height - miniHeight - 50;
+
+  var x = d3.scale.linear().domain([
+            d3.min(items, function(d) { return d.start; }),
+            d3.max(items, function(d) { return d.end; })])
+    .range([0, width]);
+
+  var x1 = d3.scale.linear().range([0, width]);
+
+  var ext = d3.extent(lanes, function(d) { return d.id; });
+  var y1 = d3.scale.linear().domain([ext[0], ext[1] + 1]).range([0, mainHeight]);
+  var y2 = d3.scale.linear().domain([ext[0], ext[1] + 1]).range([0, miniHeight]);
+
+  var chart = d3.select('body')
+    .append('svg:svg')
+    .attr('width', width + margin.right + margin.left)
+    .attr('height', height + margin.top + margin.bottom)
+    .attr('class', 'chart');
+
+  chart.append('defs').append('clipPath')
+    .attr('id', 'clip')
+    .append('rect')
+    .attr('width', width)
+    .attr('height', mainHeight);
+
+  var mini = chart.append('g')
+    .attr('transform', 'translate(' + margin.left + ',' + margin.top + ')')
+    .attr('width', width)
+    .attr('height', miniHeight)
+    .attr('class', 'mini');
+
+  var main = chart.append('g')
+    .attr('transform', 'translate(' + margin.left + ',' + (margin.top + miniHeight + 20) + ')')
+    .attr('width', width)
+    .attr('height', mainHeight)
+    .attr('class', 'main');
+
+  // draw the lanes for the main chart
+  main.append('g').selectAll('.laneLines')
+    .data(lanes)
+    .enter().append('line')
+    .attr('x1', 0)
+    .attr('y1', function(d) { return d3.round(y1(d.id)) + 0.5; })
+    .attr('x2', width)
+    .attr('y2', function(d) { return d3.round(y1(d.id)) + 0.5; })
+    .attr('stroke', function(d) { return d.label === '' ? 'white' : 'lightgray' });
+
+  main.append('g').selectAll('.laneText')
+    .data(lanes)
+    .enter().append('text')
+    .text(function(d) { return d.label; })
+    .attr('x', -10)
+    .attr('y', function(d) { return y1(d.id + .5); })
+    .attr('dy', '0.5ex')
+    .attr('text-anchor', 'end')
+    .attr('class', 'laneText');
+
+  // draw the lanes for the mini chart
+  mini.append('g').selectAll('.laneLines')
+    .data(lanes)
+    .enter().append('line')
+    .attr('x1', 0)
+    .attr('y1', function(d) { return d3.round(y2(d.id)) + 0.5; })
+    .attr('x2', width)
+    .attr('y2', function(d) { return d3.round(y2(d.id)) + 0.5; })
+    .attr('stroke', function(d) { return d.label === '' ? 'white' : 'lightgray' });
+
+  mini.append('g').selectAll('.laneText')
+    .data(lanes)
+    .enter().append('text')
+    .text(function(d) { return d.label; })
+    .attr('x', -10)
+    .attr('y', function(d) { return y2(d.id + .5); })
+    .attr('dy', '0.5ex')
+    .attr('text-anchor', 'end')
+    .attr('class', 'laneText');
+
+  // draw the x axis
+
+  var xDateAxis = d3.svg.axis()
+    .scale(x)
+    .orient('bottom')
+    .tickFormat(function(e) { return e + ' ms' })
+    .tickSize(6, 0, 0);
+
+  var x1DateAxis = d3.svg.axis()
+    .scale(x1)
+    .orient('bottom')
+    .tickFormat(function(e) { return e + ' ms' })
+    .tickSize(6, 0, 0);
+
+  main.append('g')
+    .attr('transform', 'translate(0,' + mainHeight + ')')
+    .attr('class', 'main axis')
+    .call(x1DateAxis);
+
+  mini.append('g')
+    .attr('transform', 'translate(0,' + miniHeight + ')')
+    .attr('class', 'axis')
+    .call(xDateAxis);
+
+  // draw the items
+  var itemRects = main.append('g')
+    .attr('clip-path', 'url(#clip)');
+
+  // generates a single path for each item class in the mini display
+  // ugly - but draws mini 2x faster than append lines or line generator
+  // is there a better way to do a bunch of lines as a single path with d3?
+  function getPaths(items) {
+    var paths = {}, d, offset = .5 * y2(1) + 0.5, result = [];
+    for (var i = 0; i < items.length; i++) {
+      d = items[i];
+      if (!paths[d.class]) paths[d.class] = '';
+      paths[d.class] += ['M',x(d.start),(y2(d.lane) + offset),'H',x(d.end)].join(' ');
+    }
+
+    for (var className in paths) {
+      result.push({class: className, path: paths[className]});
+    }
+
+    return result;
+  }
+
+  mini.append('g').selectAll('miniItems')
+    .data(getPaths(items))
+    .enter().append('path')
+    .attr('class', function(d) { return 'miniItem ' + d.class; })
+    .attr('d', function(d) { return d.path; });
+
+  // draw the selection area
+  var brush = d3.svg.brush()
+    .x(x)
+    .extent([
+         d3.min(items, function(d) { return d.start; }),
+         d3.max(items, function(d) { return d.end; })])
+    .on("brush", display);
+
+  mini.append('g')
+    .attr('class', 'x brush')
+    .call(brush)
+    .selectAll('rect')
+      .attr('y', 1)
+      .attr('height', miniHeight - 1);
+
+  mini.selectAll('rect.background').remove();
+  display();
+
+  function display () {
+    var minExtent = Math.max(0, brush.extent()[0]);
+    var maxExtent = Math.min(lastEndTime, brush.extent()[1]);
+    var visItems = items.filter(function (d) { return d.start < maxExtent && d.end > minExtent});
+
+    mini.select('.brush').call(brush.extent([minExtent, maxExtent]));
+    x1.domain([minExtent, maxExtent]);
+    main.select('.main.axis').call(x1DateAxis);
+
+    // upate the item rects
+    var rects = itemRects.selectAll('rect')
+      .data(visItems, function (d) { return d.id; })
+      .attr('x', function(d) { return x1(d.start); })
+      .attr('width', function(d) { return x1(d.end) - x1(d.start); });
+
+    rects.enter().append('rect')
+      .attr('x', function(d) { return x1(d.start); })
+      .attr('y', function(d) { return y1(d.lane) + .1 * y1(1) + 0.5; })
+      .attr('width', function(d) { return x1(d.end) - x1(d.start); })
+      .attr('height', function(d) { return .8 * y1(1); })
+      .attr('class', function(d) { return 'mainItem ' + d.class; })
+      .attr('fill', function(d) { return d.color; });
+
+    rects.exit().remove();
+
+    // update the item labels
+    var labels = itemRects.selectAll('text')
+      .data(visItems, function (d) { return d.id; })
+      .attr('x', function(d) { return x1(Math.max(d.start, minExtent)) + 2; });
+
+    labels.enter().append('text')
+      .text(function (d) { return d.label; })
+      .attr('x', function(d) { return x1(Math.max(d.start, minExtent)) + 2; })
+      .attr('y', function(d) { return y1(d.lane) + .4 * y1(1) + 6.5; })
+      .attr('text-anchor', 'start')
+      .attr('class', 'itemLabel');
+
+    labels.exit().remove();
+  }
+}
+
+var xhr = new XMLHttpRequest();
+xhr.onreadystatechange = function() {
+  if (xhr.readyState == 4 && (xhr.status == 200 || xhr.status == 0)) {
+    createSwimlaneChart(JSON.parse(xhr.responseText));
+  }
+};
+xhr.open("GET", {{{results_log_file}}}, true);
+xhr.send();
+
+</script>
+</body>
+</html>