forked from emscripten-core/emscripten
-
Notifications
You must be signed in to change notification settings - Fork 0
/
emcc.py
executable file
·3300 lines (2853 loc) · 144 KB
/
emcc.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
#!/usr/bin/env python2
# Copyright 2011 The Emscripten Authors. All rights reserved.
# Emscripten is available under two separate licenses, the MIT license and the
# University of Illinois/NCSA Open Source License. Both these licenses can be
# found in the LICENSE file.
"""emcc - compiler helper script
=============================
emcc is a drop-in replacement for a compiler like gcc or clang.
See emcc --help for details.
emcc can be influenced by a few environment variables:
EMCC_DEBUG - "1" will log out useful information during compilation, as well as
save each compiler step as an emcc-* file in the temp dir
(by default /tmp/emscripten_temp). "2" will save additional emcc-*
steps, that would normally not be separately produced (so this
slows down compilation).
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.
"""
from __future__ import print_function
import json
import logging
import os
import re
import shlex
import shutil
import stat
import sys
import time
from subprocess import PIPE
from tools import shared, system_libs, client_mods, js_optimizer, jsrun
from tools.shared import unsuffixed, unsuffixed_basename, WINDOWS, safe_copy, safe_move, run_process, asbytes, read_and_preprocess, exit_with_error, DEBUG
from tools.response_file import substitute_response_files
import tools.line_endings
from tools.toolchain_profiler import ToolchainProfiler
if __name__ == '__main__':
ToolchainProfiler.record_process_start()
try:
from urllib.parse import quote
except ImportError:
# Python 2 compatibility
from urllib import quote
logger = logging.getLogger('emcc')
# endings = dot + a suffix, safe to test by filename.endswith(endings)
C_ENDINGS = ('.c', '.C', '.i')
CXX_ENDINGS = ('.cpp', '.cxx', '.cc', '.c++', '.CPP', '.CXX', '.CC', '.C++', '.ii')
OBJC_ENDINGS = ('.m', '.mi')
OBJCXX_ENDINGS = ('.mm', '.mii')
SPECIAL_ENDINGLESS_FILENAMES = ('/dev/null',)
SOURCE_ENDINGS = C_ENDINGS + CXX_ENDINGS + OBJC_ENDINGS + OBJCXX_ENDINGS + SPECIAL_ENDINGLESS_FILENAMES
C_ENDINGS = C_ENDINGS + SPECIAL_ENDINGLESS_FILENAMES # consider the special endingless filenames like /dev/null to be C
JS_CONTAINING_ENDINGS = ('.js', '.mjs', '.html')
BITCODE_ENDINGS = ('.bc', '.o', '.obj', '.lo')
DYNAMICLIB_ENDINGS = ('.dylib', '.so') # Windows .dll suffix is not included in this list, since those are never linked to directly on the command line.
STATICLIB_ENDINGS = ('.a',)
ASSEMBLY_ENDINGS = ('.ll',)
HEADER_ENDINGS = ('.h', '.hxx', '.hpp', '.hh', '.H', '.HXX', '.HPP', '.HH')
WASM_ENDINGS = ('.wasm', '.wast')
SUPPORTED_LINKER_FLAGS = (
'--start-group', '--end-group',
'-(', '-)',
'--whole-archive', '--no-whole-archive',
'-whole-archive', '-no-whole-archive')
LIB_PREFIXES = ('', 'lib')
DEFERRED_RESPONSE_FILES = ('EMTERPRETIFY_BLACKLIST', 'EMTERPRETIFY_WHITELIST', 'EMTERPRETIFY_SYNCLIST')
# Mapping of emcc opt levels to llvm opt levels. We use llvm opt level 3 in emcc
# opt levels 2 and 3 (emcc 3 is unsafe opts, so unsuitable for the only level to
# get llvm opt level 3, and speed-wise emcc level 2 is already the slowest/most
# optimizing level)
LLVM_OPT_LEVEL = {
0: ['-O0'],
1: ['-O1'],
2: ['-O3'],
3: ['-O3'],
}
# Do not compile .ll files into .bc, just compile them with emscripten directly
# Not recommended, this is mainly for the test runner, or if you have some other
# specific need.
# One major limitation with this mode is that libc and libc++ cannot be
# added in. Also, LLVM optimizations will not be done, nor dead code elimination
LEAVE_INPUTS_RAW = int(os.environ.get('EMCC_LEAVE_INPUTS_RAW', '0'))
# If emcc is running with LEAVE_INPUTS_RAW and then launches an emcc to build
# something like the struct info, then we don't want LEAVE_INPUTS_RAW to be
# active in that emcc subprocess.
if LEAVE_INPUTS_RAW:
del os.environ['EMCC_LEAVE_INPUTS_RAW']
# If set to 1, we will run the autodebugger (the automatic debugging tool, see
# tools/autodebugger). Note that this will disable inclusion of libraries. This
# is useful because including dlmalloc makes it hard to compare native and js
# builds
AUTODEBUG = os.environ.get('EMCC_AUTODEBUG')
# Target options
final = None
class Intermediate(object):
counter = 0
# this function uses the global 'final' variable, which contains the current
# final output file. if a method alters final, and calls this method, then it
# must modify final globally (i.e. it can't receive final as a param and
# return it)
# TODO: refactor all this, a singleton that abstracts over the final output
# and saving of intermediates
def save_intermediate(name, suffix='js'):
if not DEBUG:
return
name = os.path.join(shared.get_emscripten_temp_dir(), 'emcc-%d-%s.%s' % (Intermediate.counter, name, suffix))
if isinstance(final, list):
logger.debug('(not saving intermediate %s because deferring linking)' % name)
return
shutil.copyfile(final, name)
Intermediate.counter += 1
def save_intermediate_with_wasm(name, wasm_binary):
if not DEBUG:
return
save_intermediate(name) # save the js
name = os.path.join(shared.get_emscripten_temp_dir(), 'emcc-%d-%s.wasm' % (Intermediate.counter - 1, name))
shutil.copyfile(wasm_binary, name)
class TimeLogger(object):
last = time.time()
@staticmethod
def update():
TimeLogger.last = time.time()
def log_time(name):
"""Log out times for emcc stages"""
if DEBUG:
now = time.time()
logger.debug('emcc step "%s" took %.2f seconds', name, now - TimeLogger.last)
TimeLogger.update()
class EmccOptions(object):
def __init__(self):
self.opt_level = 0
self.debug_level = 0
self.shrink_level = 0
self.requested_debug = ''
self.profiling = False
self.profiling_funcs = False
self.tracing = False
self.emit_symbol_map = False
self.js_opts = None
self.force_js_opts = False
self.llvm_opts = None
self.llvm_lto = None
self.default_cxx_std = '-std=c++03' # Enforce a consistent C++ standard when compiling .cpp files, if user does not specify one on the cmdline.
self.use_closure_compiler = None
self.js_transform = None
self.pre_js = '' # before all js
self.post_js = '' # after all js
self.preload_files = []
self.embed_files = []
self.exclude_files = []
self.ignore_dynamic_linking = False
self.shell_path = shared.path_from_root('src', 'shell.html')
self.source_map_base = ''
self.js_libraries = []
self.bind = False
self.emrun = False
self.cpu_profiler = False
self.thread_profiler = False
self.memory_profiler = False
self.save_bc = False
self.memory_init_file = None
self.use_preload_cache = False
self.no_heap_copy = False
self.use_preload_plugins = False
self.proxy_to_worker = False
self.default_object_extension = '.o'
self.valid_abspaths = []
self.separate_asm = False
self.cfi = False
# Specifies the line ending format to use for all generated text files.
# Defaults to using the native EOL on each platform (\r\n on Windows, \n on
# Linux & MacOS)
self.output_eol = os.linesep
def use_source_map(options):
return options.debug_level >= 4
def will_metadce(options):
return options.opt_level >= 3 or options.shrink_level >= 1
class JSOptimizer(object):
def __init__(self, target, options, js_transform_tempfiles, in_temp):
self.queue = []
self.extra_info = {}
self.queue_history = []
self.blacklist = os.environ.get('EMCC_JSOPT_BLACKLIST', '').split(',')
self.minify_whitespace = False
self.cleanup_shell = False
self.target = target
self.opt_level = options.opt_level
self.debug_level = options.debug_level
self.emit_symbol_map = options.emit_symbol_map
self.profiling_funcs = options.profiling_funcs
self.use_closure_compiler = options.use_closure_compiler
self.js_transform_tempfiles = js_transform_tempfiles
self.in_temp = in_temp
def flush(self, title='js_opts'):
self.queue = [p for p in self.queue if p not in self.blacklist]
assert not shared.Settings.WASM_BACKEND, 'JSOptimizer should not run with pure wasm output'
if self.extra_info is not None and len(self.extra_info) == 0:
self.extra_info = None
if len(self.queue) and not(not shared.Settings.ASM_JS and len(self.queue) == 1 and self.queue[0] == 'last'):
passes = self.queue[:]
if DEBUG != 2 or len(passes) < 2:
# by assumption, our input is JS, and our output is JS. If a pass is going to run in the native optimizer in C++, then we
# must give it JSON and receive from it JSON
chunks = []
curr = []
for p in passes:
if len(curr) == 0:
curr.append(p)
else:
native = js_optimizer.use_native(p, source_map=use_source_map(self))
last_native = js_optimizer.use_native(curr[-1], source_map=use_source_map(self))
if native == last_native:
curr.append(p)
else:
curr.append('emitJSON')
chunks.append(curr)
curr = ['receiveJSON', p]
if len(curr):
chunks.append(curr)
if len(chunks) == 1:
self.run_passes(chunks[0], title, just_split=False, just_concat=False)
else:
for i, chunk in enumerate(chunks):
self.run_passes(chunk, 'js_opts_' + str(i),
just_split='receiveJSON' in chunk,
just_concat='emitJSON' in chunk)
else:
# DEBUG 2, run each pass separately
extra_info = self.extra_info
for p in passes:
self.queue = [p]
self.flush(p)
self.extra_info = extra_info # flush wipes it
log_time('part of js opts')
self.queue_history += self.queue
self.queue = []
self.extra_info = {}
def run_passes(self, passes, title, just_split, just_concat):
global final
passes = ['asm'] + passes
if shared.Settings.PRECISE_F32:
passes = ['asmPreciseF32'] + passes
if (self.emit_symbol_map or shared.Settings.CYBERDWARF) and 'minifyNames' in passes:
passes += ['symbolMap=' + self.target + '.symbols']
if self.profiling_funcs and 'minifyNames' in passes:
passes += ['profilingFuncs']
if self.minify_whitespace and 'last' in passes:
passes += ['minifyWhitespace']
if self.cleanup_shell and 'last' in passes:
passes += ['cleanup']
logger.debug('applying js optimization passes: %s', ' '.join(passes))
final = shared.Building.js_optimizer(final, passes, use_source_map(self),
self.extra_info, just_split=just_split,
just_concat=just_concat,
output_filename=self.in_temp(os.path.basename(final) + '.jsopted.js'))
self.js_transform_tempfiles.append(final)
save_intermediate(title, suffix='js' if 'emitJSON' not in passes else 'json')
def do_minify(self):
"""minifies the code.
this is also when we do certain optimizations that must be done right before or after minification
"""
if self.opt_level >= 2:
if self.debug_level < 2 and not self.use_closure_compiler == 2:
self.queue += ['minifyNames']
if self.debug_level == 0:
self.minify_whitespace = True
if self.use_closure_compiler == 1:
self.queue += ['closure']
elif self.debug_level <= 2 and shared.Settings.FINALIZE_ASM_JS and not self.use_closure_compiler:
self.cleanup_shell = True
def embed_memfile(options):
return (shared.Settings.SINGLE_FILE or
(shared.Settings.MEM_INIT_METHOD == 0 and
(not shared.Settings.MAIN_MODULE and
not shared.Settings.SIDE_MODULE and
not use_source_map(options))))
def apply_settings(changes):
"""Take a list of settings in form `NAME=VALUE` and apply them to the global
Settings object.
"""
def standardize_setting_change(key, value):
# Handle aliases in settings flags. These are settings whose name
# has changed.
settings_aliases = {
'BINARYEN': 'WASM',
'BINARYEN_MEM_MAX': 'WASM_MEM_MAX',
# TODO: change most (all?) other BINARYEN* names to WASM*
}
key = settings_aliases.get(key, key)
# boolean NO_X settings are aliases for X
# (note that *non*-boolean setting values have special meanings,
# and we can't just flip them, so leave them as-is to be
# handled in a special way later)
if key.startswith('NO_') and value in ('0', '1'):
key = key[3:]
value = str(1 - int(value))
return key, value
for change in changes:
key, value = change.split('=', 1)
key, value = standardize_setting_change(key, value)
# In those settings fields that represent amount of memory, translate suffixes to multiples of 1024.
if key in ('TOTAL_STACK', 'TOTAL_MEMORY', 'GL_MAX_TEMP_BUFFER_SIZE',
'WASM_MEM_MAX', 'DEFAULT_PTHREAD_STACK_SIZE'):
value = str(shared.expand_byte_size_suffixes(value))
if value[0] == '@':
if key not in DEFERRED_RESPONSE_FILES:
value = open(value[1:]).read()
else:
value = value.replace('\\', '\\\\')
try:
setattr(shared.Settings, key, parse_value(value))
except Exception as e:
exit_with_error('a problem occured in evaluating the content after a "-s", specifically "%s": %s', change, str(e))
if key == 'EXPORTED_FUNCTIONS':
# used for warnings in emscripten.py
shared.Settings.ORIGINAL_EXPORTED_FUNCTIONS = shared.Settings.EXPORTED_FUNCTIONS[:]
def find_output_arg(args):
"""Find and remove any -o arguments. The final one takes precedence.
Return the final -o target along with the remaining (non-o) arguments.
"""
outargs = []
specified_target = None
use_next = False
for arg in args:
if use_next:
specified_target = arg
use_next = False
continue
if arg == '-o':
use_next = True
elif arg.startswith('-o'):
specified_target = arg[2:]
else:
outargs.append(arg)
return specified_target, outargs
#
# Main run() function
#
def run(args):
global final
target = None
# Additional compiler flags that we treat as if they were passed to us on the
# commandline
EMCC_CFLAGS = os.environ.get('EMCC_CFLAGS')
if DEBUG:
cmd = ' '.join(args)
if EMCC_CFLAGS:
cmd += ' + ' + EMCC_CFLAGS
logger.warning('invocation: ' + cmd + ' (in ' + os.getcwd() + ')')
if EMCC_CFLAGS:
args.extend(shlex.split(EMCC_CFLAGS))
# Strip args[0] (program name)
args = args[1:]
if DEBUG and LEAVE_INPUTS_RAW:
logger.warning('leaving inputs raw')
if '--emscripten-cxx' in args:
run_via_emxx = True
args = [x for x in args if x != '--emscripten-cxx']
else:
run_via_emxx = False
misc_temp_files = shared.configuration.get_temp_files()
# Handle some global flags
# read response files very early on
args = substitute_response_files(args)
if '--help' in args:
# Documentation for emcc and its options must be updated in:
# site/source/docs/tools_reference/emcc.rst
# A prebuilt local version of the documentation is available at:
# site/build/text/docs/tools_reference/emcc.txt
# (it is read from there and printed out when --help is invoked)
# You can also build docs locally as HTML or other formats in site/
# An online HTML version (which may be of a different version of Emscripten)
# is up at http://kripken.github.io/emscripten-site/docs/tools_reference/emcc.html
print('''%s
------------------------------------------------------------------
emcc: supported targets: llvm bitcode, javascript, NOT elf
(autoconf likes to see elf above to enable shared object support)
''' % (open(shared.path_from_root('site', 'build', 'text', 'docs', 'tools_reference', 'emcc.txt')).read()))
return 0
if '--version' in args:
revision = '(unknown revision)'
here = os.getcwd()
os.chdir(shared.path_from_root())
try:
revision = run_process(['git', 'show'], stdout=PIPE, stderr=PIPE).stdout.split('\n')[0]
except:
pass
finally:
os.chdir(here)
print('''emcc (Emscripten gcc/clang-like replacement) %s (%s)
Copyright (C) 2014 the Emscripten authors (see AUTHORS.txt)
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.
''' % (shared.EMSCRIPTEN_VERSION, revision))
return 0
if len(args) == 1 and args[0] == '-v': # -v with no inputs
# autoconf likes to see 'GNU' in the output to enable shared object support
print('emcc (Emscripten gcc/clang-like replacement + linker emulating GNU ld) %s' % shared.EMSCRIPTEN_VERSION, file=sys.stderr)
code = run_process([shared.CLANG_CC, '-v'], check=False).returncode
shared.check_sanity(force=True)
return code
shared.check_sanity(force=DEBUG)
# This check comes after check_sanity because test_sanity expects this.
if not args:
logger.warning('no input files')
return 1
if '-dumpmachine' in args:
print(shared.get_llvm_target())
return 0
if '-dumpversion' in args: # gcc's doc states "Print the compiler version [...] and don't do anything else."
print(shared.EMSCRIPTEN_VERSION)
return 0
if '--cflags' in args:
# fake running the command, to see the full args we pass to clang
debug_env = os.environ.copy()
debug_env['EMCC_DEBUG'] = '1'
args = [x for x in args if x != '--cflags']
with misc_temp_files.get_file(suffix='.o') as temp_target:
input_file = 'hello_world.c'
err = run_process([shared.PYTHON, sys.argv[0]] + args + [shared.path_from_root('tests', input_file), '-c', '-o', temp_target], stderr=PIPE, env=debug_env).stderr
lines = [x for x in err.split('\n') if shared.CLANG_CC in x and input_file in x]
line = re.search('running: (.*)', lines[0]).group(1)
parts = shlex.split(line.replace('\\', '\\\\'))
parts = [x for x in parts if x != '-c' and x != '-o' and input_file not in x and temp_target not in x and '-emit-llvm' not in x]
print(' '.join(shared.Building.doublequote_spaces(parts[1:])))
return 0
# Default to using C++ even when run as `emcc`.
# This means that emcc will act as a C++ linker when no source files are
# specified. However, when a C source is specified we do default to C.
# This differs to clang and gcc where the default is always C unless run as
# clang++/g++.
use_cxx = True
def get_language_mode(args):
return_next = False
for item in args:
if return_next:
return item
if item == '-x':
return_next = True
continue
if item.startswith('-x'):
return item[2:]
return None
def has_c_source(args):
for a in args:
if a[0] != '-' and a.endswith(C_ENDINGS + OBJC_ENDINGS):
return True
return False
language_mode = get_language_mode(args)
has_fixed_language_mode = language_mode is not None
if language_mode == 'c':
use_cxx = False
if not has_fixed_language_mode:
if not run_via_emxx and has_c_source(args):
use_cxx = False
def is_minus_s_for_emcc(args, i):
# -s OPT=VALUE or -s OPT are interpreted as emscripten flags.
# -s by itself is a linker option (alias for --strip-all)
assert args[i] == '-s'
if len(args) > i + 1:
arg = args[i + 1]
if arg.split('=')[0].isupper():
return True
logger.debug('treating -s as linker option and not as -s OPT=VALUE for js compilation')
return False
# If this is a configure-type thing, do not compile to JavaScript, instead use clang
# to compile to a native binary (using our headers, so things make sense later)
CONFIGURE_CONFIG = (os.environ.get('EMMAKEN_JUST_CONFIGURE') or 'conftest.c' in args) and not os.environ.get('EMMAKEN_JUST_CONFIGURE_RECURSE')
CMAKE_CONFIG = 'CMakeFiles/cmTryCompileExec.dir' in ' '.join(args)# or 'CMakeCCompilerId' in ' '.join(args)
if CONFIGURE_CONFIG or CMAKE_CONFIG:
# XXX use this to debug configure stuff. ./configure's generally hide our
# normal output including stderr so we write to a file
debug_configure = 0
# Whether we fake configure tests using clang - the local, native compiler -
# or not. if not we generate JS and use node with a shebang
# Neither approach is perfect, you can try both, but may need to edit
# configure scripts in some cases
# By default we configure in js, which can break on local filesystem access,
# etc., but is otherwise accurate so we
# disable this if we think we have to. A value of '2' here will force JS
# checks in all cases. In summary:
# 0 - use native compilation for configure checks
# 1 - use js when we think it will work
# 2 - always use js for configure checks
use_js = int(os.environ.get('EMCONFIGURE_JS') or 2)
if debug_configure:
tempout = '/tmp/emscripten_temp/out'
if not os.path.exists(tempout):
open(tempout, 'w').write('//\n')
src = None
for arg in args:
if arg.endswith(SOURCE_ENDINGS):
try:
src = open(arg).read()
if debug_configure:
open(tempout, 'a').write('============= ' + arg + '\n' + src + '\n=============\n\n')
except:
pass
elif arg.endswith('.s'):
if debug_configure:
open(tempout, 'a').write('(compiling .s assembly, must use clang\n')
if use_js == 1:
use_js = 0
elif arg == '-E' or arg == '-M' or arg == '-MM':
if use_js == 1:
use_js = 0
if src:
if 'fopen' in src and '"w"' in src:
if use_js == 1:
use_js = 0 # we cannot write to files from js!
if debug_configure:
open(tempout, 'a').write('Forcing clang since uses fopen to write\n')
# if CONFIGURE_CC is defined, use that. let's you use local gcc etc. if you need that
compiler = os.environ.get('CONFIGURE_CC')
if not compiler:
compiler = shared.EMXX if use_js else shared.CLANG_CPP
if 'CXXCompiler' not in ' '.join(args) and not use_cxx:
compiler = shared.to_cc(compiler)
def filter_emscripten_options(argv):
skip_next = False
for idx, arg in enumerate(argv):
if skip_next:
skip_next = False
continue
if not use_js and arg == '-s' and is_minus_s_for_emcc(argv, idx):
# skip -s X=Y if not using js for configure
skip_next = True
continue
if use_js or arg != '--tracing':
yield arg
if compiler in (shared.EMCC, shared.EMXX):
compiler = [shared.PYTHON, compiler]
else:
compiler = [compiler]
cmd = compiler + list(filter_emscripten_options(args))
if not use_js:
cmd += shared.EMSDK_OPTS + ['-D__EMSCRIPTEN__']
# The preprocessor define EMSCRIPTEN is deprecated. Don't pass it to code
# in strict mode. Code should use the define __EMSCRIPTEN__ instead.
if not shared.Settings.STRICT:
cmd += ['-DEMSCRIPTEN']
if use_js:
# configure tests want a more shell-like style, where we emit return codes on exit()
cmd += ['-s', 'NO_EXIT_RUNTIME=0']
# use node.js raw filesystem access, to behave just like a native executable
cmd += ['-s', 'NODERAWFS=1']
# Disable wasm in configuration checks so that (1) we do not depend on
# wasm support just for configuration (perhaps the user does not intend
# to build to wasm; using asm.js only depends on js which we need anyhow),
# and (2) we don't have issues with a separate .wasm file
# on the side, async startup, etc..
if not shared.Settings.WASM_BACKEND:
cmd += ['-s', 'WASM=0']
logger.debug('just configuring: ' + ' '.join(cmd))
if debug_configure:
open(tempout, 'a').write('emcc, just configuring: ' + ' '.join(cmd) + '\n\n')
if not use_js:
return run_process(cmd, check=False).returncode
only_object = '-c' in cmd
for i in reversed(range(len(cmd) - 1)): # Last -o directive should take precedence, if multiple are specified
if cmd[i] == '-o':
if not only_object:
cmd[i + 1] += '.js'
target = cmd[i + 1]
break
if not target:
target = 'a.out.js'
os.environ['EMMAKEN_JUST_CONFIGURE_RECURSE'] = '1'
ret = run_process(cmd, check=False).returncode
os.environ['EMMAKEN_JUST_CONFIGURE_RECURSE'] = ''
if not os.path.exists(target):
# note that emcc -c will cause target to have the wrong value here;
# but then, we don't care about bitcode outputs anyhow, below, so
# skipping returning early is fine
return ret
if target.endswith('.js'):
shutil.copyfile(target, unsuffixed(target))
target = unsuffixed(target)
if not target.endswith(BITCODE_ENDINGS):
src = open(target).read()
full_node = ' '.join(shared.NODE_JS)
if os.path.sep not in full_node:
full_node = '/usr/bin/' + full_node # TODO: use whereis etc. And how about non-*NIX?
open(target, 'w').write('#!' + full_node + '\n' + src) # add shebang
try:
os.chmod(target, stat.S_IMODE(os.stat(target).st_mode) | stat.S_IXUSR) # make executable
except:
pass # can fail if e.g. writing the executable to /dev/null
return ret
CXX = os.environ.get('EMMAKEN_COMPILER', shared.CLANG_CPP)
CC = shared.to_cc(CXX)
EMMAKEN_CFLAGS = os.environ.get('EMMAKEN_CFLAGS')
if EMMAKEN_CFLAGS:
args += shlex.split(EMMAKEN_CFLAGS)
# ---------------- Utilities ---------------
def suffix(name):
"""Return the file extension"""
return os.path.splitext(name)[1]
seen_names = {}
def uniquename(name):
if name not in seen_names:
seen_names[name] = str(len(seen_names))
return unsuffixed(name) + '_' + seen_names[name] + suffix(name)
# ---------------- End configs -------------
# Check if a target is specified on the command line
specified_target, args = find_output_arg(args)
# specified_target is the user-specified one, target is what we will generate
if specified_target:
target = specified_target
else:
target = 'a.out.js'
shared.Settings.TARGET_BASENAME = target_basename = unsuffixed_basename(target)
final_suffix = suffix(target)
temp_dir = shared.get_emscripten_temp_dir()
def in_temp(name):
return os.path.join(temp_dir, os.path.basename(name))
def get_file_suffix(filename):
"""Parses the essential suffix of a filename, discarding Unix-style version
numbers in the name. For example for 'libz.so.1.2.8' returns '.so'"""
if filename in SPECIAL_ENDINGLESS_FILENAMES:
return filename
while filename:
filename, suffix = os.path.splitext(filename)
if not suffix[1:].isdigit():
return suffix
return ''
def optimizing(opts):
return '-O0' not in opts
with ToolchainProfiler.profile_block('parse arguments and setup'):
## Parse args
newargs = list(args)
# Scan and strip emscripten specific cmdline warning flags.
# This needs to run before other cmdline flags have been parsed, so that
# warnings are properly printed during arg parse.
newargs = shared.WarningManager.capture_warnings(newargs)
for i in range(len(newargs)):
if newargs[i] in ('-l', '-L', '-I'):
# Scan for individual -l/-L/-I arguments and concatenate the next arg on
# if there is no suffix
newargs[i] += newargs[i + 1]
newargs[i + 1] = ''
options, settings_changes, newargs = parse_args(newargs)
if use_cxx:
clang_compiler = CXX
# If user did not specify a default -std for C++ code, specify the emscripten default.
if options.default_cxx_std:
newargs += [options.default_cxx_std]
else:
# Compiling C code with .c files, don't enforce a default C++ std.
clang_compiler = CC
if options.emrun:
options.pre_js += open(shared.path_from_root('src', 'emrun_prejs.js')).read() + '\n'
options.post_js += open(shared.path_from_root('src', 'emrun_postjs.js')).read() + '\n'
# emrun mode waits on program exit
shared.Settings.EXIT_RUNTIME = 1
if options.cpu_profiler:
options.post_js += open(shared.path_from_root('src', 'cpuprofiler.js')).read() + '\n'
if options.memory_profiler:
options.post_js += open(shared.path_from_root('src', 'memoryprofiler.js')).read() + '\n'
if options.thread_profiler:
options.post_js += open(shared.path_from_root('src', 'threadprofiler.js')).read() + '\n'
if options.js_opts is None:
options.js_opts = options.opt_level >= 2
if options.llvm_opts is None:
options.llvm_opts = LLVM_OPT_LEVEL[options.opt_level]
elif type(options.llvm_opts) == int:
options.llvm_opts = ['-O%d' % options.llvm_opts]
if options.memory_init_file is None:
options.memory_init_file = options.opt_level >= 2
# TODO: support source maps with js_transform
if options.js_transform and use_source_map(options):
logger.warning('disabling source maps because a js transform is being done')
options.debug_level = 3
if DEBUG:
start_time = time.time() # done after parsing arguments, which might affect debug state
for i in range(len(newargs)):
if newargs[i] == '-s':
if is_minus_s_for_emcc(newargs, i):
key = newargs[i + 1]
# If not = is specified default to 1
if '=' not in key:
key += '=1'
settings_changes.append(key)
newargs[i] = newargs[i + 1] = ''
if key == 'WASM_BACKEND=1':
exit_with_error('do not set -s WASM_BACKEND, instead set EMCC_WASM_BACKEND=1 in the environment')
newargs = [arg for arg in newargs if arg is not '']
settings_key_changes = set()
for s in settings_changes:
key, value = s.split('=', 1)
settings_key_changes.add(key)
# Find input files
# These three arrays are used to store arguments of different types for
# type-specific processing. In order to shuffle the arguments back together
# after processing, all of these arrays hold tuples (original_index, value).
# Note that the index part of the tuple can have a fractional part for input
# arguments that expand into multiple processed arguments, as in -Wl,-f1,-f2.
input_files = []
libs = []
link_flags = []
# All of the above arg lists entries contain indexes into the full argument
# list. In order to add extra implicit args (embind.cc, etc) below, we keep a
# counter for the next index that should be used.
next_arg_index = len(newargs)
has_source_inputs = False
has_header_inputs = False
lib_dirs = [shared.path_from_root('system', 'local', 'lib'),
shared.path_from_root('system', 'lib')]
# find input files 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
for i in range(len(newargs)):
arg = newargs[i]
if i > 0:
prev = newargs[i - 1]
if prev in ('-MT', '-MF', '-MQ', '-D', '-U', '-o', '-x',
'-Xpreprocessor', '-include', '-imacros', '-idirafter',
'-iprefix', '-iwithprefix', '-iwithprefixbefore',
'-isysroot', '-imultilib', '-A', '-isystem', '-iquote',
'-install_name', '-compatibility_version',
'-current_version', '-I', '-L', '-include-pch'):
continue # ignore this gcc-style argument
if os.path.islink(arg) and get_file_suffix(os.path.realpath(arg)) in SOURCE_ENDINGS + BITCODE_ENDINGS + DYNAMICLIB_ENDINGS + ASSEMBLY_ENDINGS + HEADER_ENDINGS:
arg = os.path.realpath(arg)
if not arg.startswith('-'):
if not os.path.exists(arg):
exit_with_error('%s: No such file or directory ("%s" was expected to be an input file, based on the commandline arguments provided)', arg, arg)
file_suffix = get_file_suffix(arg)
if file_suffix in SOURCE_ENDINGS + BITCODE_ENDINGS + DYNAMICLIB_ENDINGS + ASSEMBLY_ENDINGS + HEADER_ENDINGS or shared.Building.is_ar(arg): # we already removed -o <target>, so all these should be inputs
newargs[i] = ''
if file_suffix.endswith(SOURCE_ENDINGS):
input_files.append((i, arg))
has_source_inputs = True
elif file_suffix.endswith(HEADER_ENDINGS):
input_files.append((i, arg))
has_header_inputs = True
elif file_suffix.endswith(ASSEMBLY_ENDINGS) or shared.Building.is_bitcode(arg) or shared.Building.is_ar(arg):
input_files.append((i, arg))
elif 'WASM_OBJECT_FILES=0' not in settings_changes and shared.Building.is_wasm(arg):
# this is before libraries, since wasm static libraries (wasm.so that contains wasm) are just
# object files to be linked
input_files.append((i, arg))
elif file_suffix.endswith(STATICLIB_ENDINGS + DYNAMICLIB_ENDINGS):
# if it's not, and it's a library, just add it to libs to find later
l = unsuffixed_basename(arg)
for prefix in LIB_PREFIXES:
if not prefix:
continue
if l.startswith(prefix):
l = l[len(prefix):]
break
libs.append((i, l))
newargs[i] = ''
else:
logger.warning(arg + ' is not a valid input file')
elif file_suffix.endswith(STATICLIB_ENDINGS):
if not shared.Building.is_ar(arg):
if shared.Building.is_bitcode(arg):
message = arg + ': File has a suffix of a static library ' + str(STATICLIB_ENDINGS) + ', but instead is an LLVM bitcode file! When linking LLVM bitcode files, use one of the suffixes ' + str(BITCODE_ENDINGS)
else:
message = arg + ': Unknown format, not a static library!'
exit_with_error(message)
else:
if has_fixed_language_mode:
newargs[i] = ''
input_files.append((i, arg))
has_source_inputs = True
else:
exit_with_error(arg + ": Input file has an unknown suffix, don't know what to do with it!")
elif arg.startswith('-L'):
lib_dirs.append(arg[2:])
newargs[i] = ''
elif arg.startswith('-l'):
libs.append((i, arg[2:]))
newargs[i] = ''
elif arg.startswith('-Wl,'):
# Multiple comma separated link flags can be specified. Create fake
# fractional indices for these: -Wl,a,b,c,d at index 4 becomes:
# (4, a), (4.25, b), (4.5, c), (4.75, d)
link_flags_to_add = arg.split(',')[1:]
for flag_index, flag in enumerate(link_flags_to_add):
if flag.startswith('-l'):
libs.append((i, flag[2:]))
elif flag.startswith('-L'):
lib_dirs.append(flag[2:])
else:
link_flags.append((i + float(flag_index) / len(link_flags_to_add), flag))
newargs[i] = ''
elif arg == '-s':
# -s and some other compiler flags are normally passed onto the linker
# TODO(sbc): Pass this and other flags through when using lld
# link_flags.append((i, arg))
newargs[i] = ''
original_input_files = input_files[:]
newargs = [a for a in newargs if a is not '']
# -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
has_dash_c = '-c' in newargs
if has_dash_c:
assert has_source_inputs or has_header_inputs, 'Must have source code or header inputs to use -c'
target = target_basename + '.o'
final_suffix = '.o'
if '-E' in newargs:
final_suffix = '.eout' # not bitcode, not js; but just result from preprocessing stage of the input file
if '-M' in newargs or '-MM' in newargs:
final_suffix = '.mout' # not bitcode, not js; but just dependency rule of the input file
# target is now finalized, can finalize other _target s
if final_suffix == '.mjs':
shared.Settings.EXPORT_ES6 = 1
shared.Settings.MODULARIZE = 1
js_target = target
else:
js_target = unsuffixed(target) + '.js'
asm_target = unsuffixed(js_target) + '.asm.js' # might not be used, but if it is, this is the name
wasm_text_target = asm_target.replace('.asm.js', '.wast') # ditto, might not be used
wasm_binary_target = asm_target.replace('.asm.js', '.wasm') # ditto, might not be used
wasm_source_map_target = wasm_binary_target + '.map'
if final_suffix == '.html' and not options.separate_asm and 'PRECISE_F32=2' in settings_changes:
options.separate_asm = True
logger.warning('forcing separate asm output (--separate-asm), because -s PRECISE_F32=2 was passed.')
if options.separate_asm:
shared.Settings.SEPARATE_ASM = shared.JS.get_subresource_location(asm_target)
# Libraries are searched before settings_changes are applied, so apply the
# value for STRICT and ERROR_ON_MISSING_LIBRARIES from command line already
# now.
def get_last_setting_change(setting):
return ([None] + [x for x in settings_changes if x.startswith(setting + '=')])[-1]
strict_cmdline = get_last_setting_change('STRICT')
if strict_cmdline:
shared.Settings.STRICT = int(strict_cmdline.split('=', 1)[1])
if shared.Settings.STRICT:
shared.Settings.ERROR_ON_MISSING_LIBRARIES = 1
error_on_missing_libraries_cmdline = get_last_setting_change('ERROR_ON_MISSING_LIBRARIES')
if error_on_missing_libraries_cmdline:
shared.Settings.ERROR_ON_MISSING_LIBRARIES = int(error_on_missing_libraries_cmdline[len('ERROR_ON_MISSING_LIBRARIES='):])
settings_changes.append(process_libraries(libs, lib_dirs, input_files))
# If not compiling to JS, then we are compiling to an intermediate bitcode objects or library, so
# ignore dynamic linking, since multiple dynamic linkings can interfere with each other
if get_file_suffix(target) not in JS_CONTAINING_ENDINGS or options.ignore_dynamic_linking:
def check(input_file):
if get_file_suffix(input_file) in DYNAMICLIB_ENDINGS:
if not options.ignore_dynamic_linking:
logger.warning('ignoring dynamic library %s because not compiling to JS or HTML, remember to link it when compiling to JS or HTML at the end', os.path.basename(input_file))
return False
else:
return True