Unity-Technologies
/
emscripten
зеркало из https://github.com/Unity-Technologies/emscripten.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность
emscripten/emcc

376 строки
13 KiB
Python
Executable File
Исходник Ответственный История

#!/usr/bin/env python
'''
emcc - compiler helper script
=============================
emcc is a drop-in replacement for a compiler like gcc or clang.
Tell your build system to use this instead of the compiler, and similarly
use emar, emld and emranlib instead of the same command without 'em'.
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/emranlib AR=PATH/emar CXX=PATH/em++ CC=PATH/emcc ./configure [options]
where PATH is the path to this file.
EMMAKEN_JUST_CONFIGURE tells emcc 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/emcc")
SET(CMAKE_CXX_COMPILER "PATH/em++")
SET(CMAKE_LINKER "PATH/emld")
SET(CMAKE_CXX_LINKER "PATH/emld")
SET(CMAKE_C_LINK_EXECUTABLE "PATH/emld")
SET(CMAKE_CXX_LINK_EXECUTABLE "PATH/emld")
SET(CMAKE_AR "PATH/emar")
SET(CMAKE_RANLIB "PATH/emranlib")
* For SCons the shared.py can be imported like so:
__file__ = str(Dir('#/project_path_to_emscripten/dummy/dummy'))
__rootpath__ = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
def path_from_root(*pathelems):
return os.path.join(__rootpath__, *pathelems)
exec(open(path_from_root('tools', 'shared.py'), 'r').read())
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.
Note the appearance of em++ instead of emcc
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.)
emcc can be influenced by a few environment variables:
EMMAKEN_NO_SDK - Will tell emcc *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 os, sys, shutil, tempfile
from subprocess import Popen, PIPE, STDOUT
from tools import shared
DEBUG = os.environ.get('EMCC_DEBUG')
SAVE_FILES = os.environ.get('EMCC_SAVE_FILES') # saves some of the intermediate files
################### XXX
print >> sys.stderr, '\n***This is a WORK IN PROGRESS***'
################### XXX
if DEBUG: print >> sys.stderr, 'emcc: ', ' '.join(sys.argv)
# Handle some global flags
if len(sys.argv) == 1:
print 'emcc: no input files'
exit(0)
if sys.argv[1] == '--version':
print '''emcc (Emscripten GCC-like replacement) 2.0
Copyright (C) 2011 the Emscripten authors.
This is free and open source software under the MIT license.
There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
'''
exit(0)
elif sys.argv[1] == '--help':
this = os.path.basename('em++' if os.environ.get('EMMAKEN_CXX') else 'emcc')
print '''%s [options] file...
Most normal gcc/g++ options will work, for example:
--help Display this information
--version Display compiler version information
Options that are modified or new in %s include:
-O0 No optimizations (default)
-O1 Simple optimizations, including safe LLVM
optimizations, and no runtime assertions
-O2 As -O1, plus code flow optimization (relooper)
Warning: Compiling with this takes a long time!
-O3 As -O2, plus dangerous optimizations that may
break the generated code! If that happens, try
-O2 and then adding dangerous optimizations one
by one.
-s OPTION=VALUE JavaScript code generation option passed
into the emscripten compiler
--typed-arrays <mode> 0: No typed arrays
1: Parallel typed arrays
2: Shared (C-like) typed arrays (default)
--llvm-opts <level> 0: No LLVM optimizations (default in -O0)
1: Safe/portable LLVM optimizations
(default in -O1 and above)
2: Full, unsafe/unportable LLVM optimizations;
this will almost certainly break the
generated code!
The target file, if specified (-o <target>), defines what will
be generated:
<name>.js JavaScript (default)
<name>.html HTML with embedded JavaScript
<name>.bc LLVM bitcode
<name>.o LLVM bitcode
The -c option (which tells gcc not to run the linker) will
cause LLVM bitcode to be generated, as %s only generates
JavaScript in the final linking stage of building.
''' % (this, this, this)
exit(0)
# 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] + shared.EMSDK_OPTS + sys.argv[1:]
if DEBUG: print >> sys.stderr, 'emcc, just configuring: ', cmd
exit(os.execvp(compiler, cmd))
if os.environ.get('EMMAKEN_COMPILER'):
CXX = os.environ['EMMAKEN_COMPILER']
else:
CXX = shared.CLANG
CC = shared.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 = shared.COMPILER_OPTS # + ['-g']?
EMMAKEN_CFLAGS = os.environ.get('EMMAKEN_CFLAGS')
if EMMAKEN_CFLAGS: CC_ADDITIONAL_ARGS += EMMAKEN_CFLAGS.split(' ')
# ---------------- Utilities ---------------
def unsuffixed(name):
return '.'.join(name.split('.')[:-1])
def unsuffixed_basename(name):
return os.path.basename(unsuffixed(name))
# ---------------- End configs -------------
if len(sys.argv) == 1 or sys.argv[1] in ['x', 't']:
# noop ar
if DEBUG: print >> sys.stderr, 'emcc, just ar'
sys.exit(0)
use_cxx = True
header = False # pre-compiled headers. We fake that by just copying the file
for i in range(1, len(sys.argv)):
arg = sys.argv[i]
if not arg.startswith('-'):
if arg.endswith('.c'):
use_cxx = False
if arg.endswith('.h') and sys.argv[i-1] != '-include':
header = True
# Check if a target is specified
target = None
for i in range(len(sys.argv)-1):
if sys.argv[i].startswith('-o='):
raise Exception('Invalid syntax: do not use -o=X, use -o X')
if sys.argv[i] == '-o':
target = sys.argv[i+1]
sys.argv = sys.argv[:i] + sys.argv[i+2:]
break
if header: # header or such
if DEBUG: print >> sys.stderr, 'Just copy.'
shutil.copy(sys.argv[-1], sys.argv[-2])
exit(0)
temp_dir = tempfile.mkdtemp()
def in_temp(name):
return os.path.join(temp_dir, name)
try:
call = CXX if use_cxx else CC
## Parse args
newargs = sys.argv[1:]
opt_level = 0
llvm_opt_level = 0
for i in range(len(newargs)):
if newargs[i].startswith('-O'):
try:
opt_level = int(newargs[i][2])
assert 0 <= opt_level <= 3
except:
raise Exception('Invalid optimization level: ' + newargs[i])
if opt_level >= 1:
llvm_opt_level = 1
newargs[i] = ''
elif newargs[i].startswith('--llvm-opts'):
assert '=' not in newargs[i], 'Invalid llvm opts parameter (do not use "=")'
llvm_opt_level = eval(newargs[i+1])
assert 0 <= llvm_opt_level <= 1, 'Only two levels of LLVM optimizations are supported so far, 0 (none) and 1 (safe)'
newargs[i] = ''
newargs[i+1] = ''
newargs = [ arg for arg in newargs if arg is not '' ]
settings_changes = []
for i in range(len(newargs)):
if newargs[i] == '-s':
settings_changes.append(newargs[i+1])
newargs[i] = newargs[i+1] = ''
elif newargs[i].startswith('--typed-arrays'):
assert '=' not in newargs[i], 'Invalid typed arrays parameter (do not use "=")'
settings_changes.append('USE_TYPED_ARRAYS=' + newargs[i+1])
newargs[i] = ''
newargs[i+1] = ''
newargs = [ arg for arg in newargs if arg is not '' ]
input_files = []
for i in range(len(newargs)): # find input files XXX this a simple heuristic. we should really analyze based on a full understanding of gcc params,
# right now we just assume that what is left contains no more |-x OPT| things
arg = newargs[i]
if arg.endswith(('.c', '.cpp', '.cxx', '.bc', '.o')): # we already removed -o <target>, so all these should be inputs
input_files.append(arg)
newargs[i] = ''
newargs = [ arg for arg in newargs if arg is not '' ]
assert len(input_files) > 0, 'emcc: no input files specified'
newargs += CC_ADDITIONAL_ARGS
specified_target = target
target = specified_target if specified_target is not None else 'a.out.js' # specified_target is the user-specified one, target is what we will generate
target_basename = unsuffixed_basename(target)
if '-c' in newargs: # -c means do not link in gcc, and for us, the parallel is to not go all the way to JS, but stop at bitcode
target = target_basename + '.o'
final_suffix = target.split('.')[-1]
# Apply optimization level settings
if opt_level >= 1:
shared.Settings.ASSERTIONS = 0
if opt_level >= 2:
shared.Settings.RELOOP = 1
print >> sys.stderr, 'Warning: The relooper optimization can be very slow.'
if opt_level >= 3:
shared.Settings.CORRECT_SIGNS = 0
shared.Settings.CORRECT_OVERFLOWS = 0
shared.Settings.CORRECT_ROUNDINGS = 0
shared.Settings.I64_MODE = 0
shared.Settings.DOUBLE_MODE = 0
shared.Settings.DISABLE_EXCEPTION_CATCHING = 1
print >> sys.stderr, 'Warning: Applying some potentially unsafe optimizations! (Use -O2 if this fails.)'
## Compile source code to bitcode
# First, generate LLVM bitcode. For each input file, we get base.o with bitcode
newargs = newargs + ['-emit-llvm', '-c']
for input_file in input_files:
if input_file.endswith(('.c', '.cpp', '.cxx')):
args = newargs + [input_file, '-o', in_temp(unsuffixed_basename(input_file) + '.o')]
if DEBUG: print >> sys.stderr, "emcc running:", call, ' '.join(args)
Popen([call] + args).communicate()
else:
shutil.copyfile(input_file, in_temp(unsuffixed_basename(input_file) + '.o'))
# Optimize, if asked to
if llvm_opt_level > 0:
for input_file in input_files:
shared.Building.llvm_opt(in_temp(unsuffixed_basename(input_file) + '.o'), 2, safe=llvm_opt_level < 2)
# If we were just asked to generate bitcode, stop there
if final_suffix in ['o', 'bc']:
if not specified_target:
for input_file in input_files:
shutil.move(in_temp(unsuffixed_basename(input_file) + '.o'), unsuffixed_basename(input_file) + '.' + final_suffix)
else:
assert len(input_files) == 1, 'fatal error: cannot specify -o with -c with multiple files'
shutil.move(in_temp(unsuffixed_basename(input_files[0]) + '.o'), specified_target)
exit(0)
## Continue on to create JavaScript
# First, combine the bitcode files if there are several
if len(input_files) > 1:
shared.Building.link(map(lambda input_file: in_temp(unsuffixed_basename(input_file) + '.o'), input_files), in_temp(target_basename + '.bc'))
else:
shutil.move(in_temp(unsuffixed_basename(input_files[0]) + '.o'), in_temp(target_basename + '.bc'))
# Apply -s settings in newargs here (after -Ox, so they can override it)
for change in settings_changes:
key, value = change.split('=')
exec('shared.Settings.' + key + ' = ' + value)
final = shared.Building.emscripten(in_temp(target_basename + '.bc'), append_ext=False)
if opt_level >= 1:
# js optimizer
final = shared.Building.js_optimizer(final, 'loopOptimizer')
# eliminator
final = shared.Building.eliminator(final)
if opt_level >= 3:
# closure
final = shared.Building.closure_compiler(final)
if opt_level >= 1:
# js optimizer
final = shared.Building.js_optimizer(final, 'simplifyExpressions')
# If we were asked to also generate HTML, do that
if final_suffix == 'html':
shell = open(shared.path_from_root('src', 'shell.html')).read()
html = open(target_basename + '.html', 'w')
html.write(shell.replace('{{{ SCRIPT_CODE }}}', open(final).read()))
html.close()
else:
# copy final JS to output
shutil.move(final, target_basename + '.js')
finally:
if not SAVE_FILES:
try:
shutil.rmtree(temp_dir)
except:
pass
else:
print >> sys.stderr, 'emcc saved files are in:', temp_dir
Ссылка в новой задаче Показать git blame Копировать постоянную ссылку