256 строки
8.8 KiB
Plaintext
256 строки
8.8 KiB
Plaintext
|
#!/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, 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 clang
|
||
|
|
with -emit-llvm, and linking will be translated into calls to llvm-link,
|
||
|
|
and so forth.
|
||
|
|
|
||
|
|
emcc 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/emcc.py AR=PATH/emcc.py CXX=PATH/em++.py CC=PATH/emcc.py ./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.py")
|
||
|
|
SET(CMAKE_CXX_COMPILER "PATH/em++.py")
|
||
|
|
SET(CMAKE_LINKER "PATH/emcc.py")
|
||
|
|
SET(CMAKE_CXX_LINKER "PATH/emcc.py")
|
||
|
|
SET(CMAKE_C_LINK_EXECUTABLE "PATH/emcc.py")
|
||
|
|
SET(CMAKE_CXX_LINK_EXECUTABLE "PATH/emcc.py")
|
||
|
|
SET(CMAKE_AR "PATH/emcc.py")
|
||
|
|
SET(CMAKE_RANLIB "PATH/emcc.py")
|
||
|
|
|
||
|
|
* 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. 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 em++.py instead of emcc.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.)
|
||
|
|
|
||
|
|
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 sys
|
||
|
|
import os
|
||
|
|
import subprocess
|
||
|
|
|
||
|
|
DEBUG = 0
|
||
|
|
|
||
|
|
################### XXX
|
||
|
|
print >> sys.stderr, '***This is a WORK IN PROGRESS***'
|
||
|
|
################### XXX
|
||
|
|
|
||
|
|
if DEBUG: print >> sys.stderr, 'emcc.py: ', ' '.join(sys.argv)
|
||
|
|
|
||
|
|
__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())
|
||
|
|
|
||
|
|
# Handle some global flags
|
||
|
|
if sys.argv[1] == '--version':
|
||
|
|
print '''emcc 2.X
|
||
|
|
This is drop-in compiler replacement for Emscripten
|
||
|
|
http://emscripten.org
|
||
|
|
'''
|
||
|
|
exit(0)
|
||
|
|
elif sys.argv[1] == '--help':
|
||
|
|
print '''OVERVIEW: Emscripten "gcc-compatible" driver script, using LLVM/Clang
|
||
|
|
Many but not all gcc options can be used.
|
||
|
|
|
||
|
|
USAGE: emcc [options] <inputs>
|
||
|
|
|
||
|
|
OPTIONS:
|
||
|
|
-O0 No optimization. Enables runtime assertions. This is the default.
|
||
|
|
-O1 Basic optimizations. Disables runtime assertions.
|
||
|
|
-O2 Like -O2, but includes loop recreation optimization (relooper).
|
||
|
|
-O3 Like -O3, but includes closure compiler advanced optimizations.
|
||
|
|
Use with care and read the closure compiler docs.
|
||
|
|
'''
|
||
|
|
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] + EMSDK_OPTS + sys.argv[1:]
|
||
|
|
if DEBUG: print >> sys.stderr, 'emcc.py, just configuring: ', cmd
|
||
|
|
exit(os.execvp(compiler, 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'):
|
||
|
|
if DEBUG: print >> sys.stderr, 'emcc.py: WARNING: Optimization flags (-Ox) are ignored in emcc. 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:
|
||
|
|
if DEBUG: 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()
|
||
|
|
|
||
|
|
if DEBUG: print >> sys.stderr, "Running:", call, ' '.join(newargs)
|
||
|
|
|
||
|
|
os.execvp(call, [call] + newargs)
|
||
|
|
except Exception, e:
|
||
|
|
print 'Error in emcc.py. (Is the config file ~/.emscripten set up properly?) Error:', e
|
||
|
|
raise
|
||
|
|
|