Remove fastcomp-only PRECISE_F32 setting (#11863)

Removing this also means we can remove the "client mods"
stuff that used to do various things but recently has only done
PRECISE_F32.

Also the optimizeFrounds optimizer pass was only for this
option, and the asm2f test mode.

Author: kripken

emcc.py

@@ -40,7 +40,7 @@
 from subprocess import PIPE
 
 import emscripten
-from tools import shared, system_libs, client_mods, js_optimizer
+from tools import shared, system_libs, js_optimizer
 from tools import colored_logger, diagnostics, building
 from tools.shared import unsuffixed, unsuffixed_basename, WINDOWS, safe_move, run_process, asbytes, read_and_preprocess, exit_with_error, DEBUG
 from tools.response_file import substitute_response_files
@@ -369,8 +369,6 @@ def flush(self, title='js_opts'):
   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=' + shared.replace_or_append_suffix(self.target, '.symbols')]
     if self.profiling_funcs and 'minifyNames' in passes:
@@ -1258,9 +1256,6 @@ def get_last_setting_change(setting):
     wasm_binary_target = asm_target.replace('.asm.js', '.wasm') # ditto, might not be used
     wasm_source_map_target = shared.replace_or_append_suffix(wasm_binary_target, '.map')
 
-    if final_suffix == '.html' and not options.separate_asm and 'PRECISE_F32=2' in settings_changes:
-      options.separate_asm = True
-      diagnostics.warning('emcc', '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)
 
@@ -1879,8 +1874,6 @@ def include_and_export(name):
       if shared.Settings.ELIMINATE_DUPLICATE_FUNCTIONS:
         diagnostics.warning('emcc', 'for wasm there is no need to set ELIMINATE_DUPLICATE_FUNCTIONS, the binaryen optimizer does it automatically')
         shared.Settings.ELIMINATE_DUPLICATE_FUNCTIONS = 0
-      # default precise-f32 to on, since it works well in wasm
-      shared.Settings.PRECISE_F32 = 1
       if options.js_opts and not options.force_js_opts:
         options.js_opts = None
         logger.debug('asm.js opts not forced by user or an option that depends them, and we do not intend to run the asm.js, so disabling and leaving opts to the binaryen optimizer')
@@ -2001,10 +1994,6 @@ def include_and_export(name):
     if (shared.Settings.MAIN_MODULE or shared.Settings.SIDE_MODULE) and shared.Settings.ALLOW_MEMORY_GROWTH and not shared.Settings.WASM:
       exit_with_error('memory growth is not supported with shared asm.js modules')
 
-    if shared.Settings.MINIMAL_RUNTIME:
-      if shared.Settings.PRECISE_F32 == 2:
-        exit_with_error('-s PRECISE_F32=2 is not supported with -s MINIMAL_RUNTIME=1')
-
     if shared.Settings.ALLOW_MEMORY_GROWTH and shared.Settings.ASM_JS == 1:
       # this is an issue in asm.js, but not wasm
       if not shared.Settings.WASM:
@@ -2705,9 +2694,6 @@ def get_eliminate():
           if shared.Settings.SIMPLIFY_IFS and debugging and not shared.Settings.WASM:
             optimizer.queue += ['simplifyIfs']
 
-          if shared.Settings.PRECISE_F32:
-            optimizer.queue += ['optimizeFrounds']
-
       if options.js_opts:
         if shared.Settings.SAFE_HEAP and not building.is_wasm_only():
           optimizer.queue += ['safeHeap']
@@ -3523,8 +3509,6 @@ def generate_traditional_runtime_html(target, options, js_target, target_basenam
   assert '{{{ SCRIPT }}}' in shell, 'HTML shell must contain  {{{ SCRIPT }}}  , see src/shell.html for an example'
   base_js_target = os.path.basename(js_target)
 
-  asm_mods = []
-
   if options.proxy_to_worker:
     proxy_worker_filename = (shared.Settings.PROXY_TO_WORKER_FILENAME or target_basename) + '.js'
     worker_js = worker_js_script(proxy_worker_filename)
@@ -3534,7 +3518,6 @@ def generate_traditional_runtime_html(target, options, js_target, target_basenam
     console.log('running code in a web worker');
 ''' % shared.JS.get_subresource_location(proxy_worker_filename)) + worker_js + '''
   } else {
-    // note: no support for code mods (PRECISE_F32==2)
     console.log('running code on the main thread');
     var fileBytes = tryParseAsDataURI(filename);
     var script = document.createElement('script');
@@ -3550,10 +3533,6 @@ def generate_traditional_runtime_html(target, options, js_target, target_basenam
     # Normal code generation path
     script.src = base_js_target
 
-    asm_mods = client_mods.get_mods(shared.Settings,
-                                    minified='minifyNames' in optimizer.queue_history,
-                                    separate_asm=options.separate_asm)
-
   if not shared.Settings.SINGLE_FILE:
     if options.memory_init_file and not shared.Settings.MEM_INIT_IN_WASM:
       # start to load the memory init file in the HTML, in parallel with the JS
@@ -3571,13 +3550,11 @@ def generate_traditional_runtime_html(target, options, js_target, target_basenam
     # Download .asm.js if --separate-asm was passed in an asm.js build, or if 'asmjs' is one
     # of the wasm run methods.
     if not options.separate_asm or shared.Settings.WASM:
-      if len(asm_mods):
-         exit_with_error('no --separate-asm means no client code mods are possible')
+      pass
     else:
       script.un_src()
-      if len(asm_mods) == 0:
-        # just load the asm, then load the rest
-        script.inline = '''
+      # just load the asm, then load the rest
+      script.inline = '''
     var filename = '%s';
     var fileBytes = tryParseAsDataURI(filename);
     var script = document.createElement('script');
@@ -3593,38 +3570,6 @@ def generate_traditional_runtime_html(target, options, js_target, target_basenam
     };
     document.body.appendChild(script);
 ''' % (shared.JS.get_subresource_location(asm_target), script.inline)
-      else:
-        # may need to modify the asm code, load it as text, modify, and load asynchronously
-        script.inline = '''
-    var codeURL = '%s';
-    var codeXHR = new XMLHttpRequest();
-    codeXHR.open('GET', codeURL, true);
-    codeXHR.onload = function() {
-      var code;
-      if (codeXHR.status === 200 || codeXHR.status === 0) {
-        code = codeXHR.responseText;
-      } else {
-        var codeURLBytes = tryParseAsDataURI(codeURL);
-        if (codeURLBytes) {
-          code = intArrayToString(codeURLBytes);
-        }
-      }
-      %s
-      var blob = new Blob([code], { type: 'text/javascript' });
-      codeXHR = null;
-      var src = URL.createObjectURL(blob);
-      var script = document.createElement('script');
-      script.src = src;
-      script.onload = function() {
-        setTimeout(function() {
-          %s
-        }, 1); // delaying even 1ms is enough to allow compilation memory to be reclaimed
-        URL.revokeObjectURL(script.src);
-      };
-      document.body.appendChild(script);
-    };
-    codeXHR.send(null);
-''' % (shared.JS.get_subresource_location(asm_target), '\n'.join(asm_mods), script.inline)
 
     if shared.Settings.WASM and not shared.Settings.WASM_ASYNC_COMPILATION:
       # We need to load the wasm file before anything else, it has to be synchronously ready TODO: optimize

emscripten.py

@@ -154,10 +154,6 @@ def parse_fastcomp_output(backend_output, DEBUG):
   if 'Float64Array' in metadata['externUses']:
     metadata['externUses'] += ['Float32Array']
 
-  # If we are generating references to Math.fround() from here in emscripten.py, declare it used as well.
-  if provide_fround():
-    metadata['externUses'] += ['Math.fround']
-
   # functions marked llvm.used in the code are exports requested by the user
   building.user_requested_exports += metadata['exports']
 
@@ -514,10 +510,10 @@ def create_module_asmjs(function_table_sigs, metadata,
       stack += apply_memory('  var STACK_MAX = {{{ STACK_MAX }}};\n')
 
   if 'tempFloat' in shared.Settings.ASM_PRIMITIVE_VARS:
-    temp_float = '  var tempFloat = %s;\n' % ('Math_fround(0)' if provide_fround() else '0.0')
+    temp_float = '  var tempFloat = %s;\n' % 'Math_fround(0)'
   else:
     temp_float = ''
-  f0_fround = '  const f0 = Math_fround(0);\n' if provide_fround() else ''
+  f0_fround = '  const f0 = Math_fround(0);\n'
 
   replace_memory = create_replace_memory(metadata)
 
@@ -574,8 +570,6 @@ def create_backend_cmd(infile, temp_js):
     '-emscripten-stack-size=%d' % shared.Settings.TOTAL_STACK,
     '-O%s' % shared.Settings.OPT_LEVEL,
   ]
-  if shared.Settings.PRECISE_F32:
-    args += ['-emscripten-precise-f32']
   if shared.Settings.USE_PTHREADS:
     args += ['-emscripten-enable-pthreads']
   if shared.Settings.WARN_UNALIGNED:
@@ -1346,9 +1340,7 @@ def asm_backend_uses(metadata, symbol):
 
 
 def create_asm_global_funcs(bg_funcs, metadata):
-  maths = ['Math.' + func for func in ['floor', 'abs', 'sqrt', 'pow', 'cos', 'sin', 'tan', 'acos', 'asin', 'atan', 'atan2', 'exp', 'log', 'ceil', 'imul', 'min', 'max', 'clz32']]
-  if provide_fround():
-    maths += ['Math.fround']
+  maths = ['Math.' + func for func in ['floor', 'abs', 'sqrt', 'pow', 'cos', 'sin', 'tan', 'acos', 'asin', 'atan', 'atan2', 'exp', 'log', 'ceil', 'imul', 'min', 'max', 'clz32', 'fround']]
 
   asm_global_funcs = ''
   for math in maths:
@@ -1375,10 +1367,6 @@ def asm_safe_heap():
   return shared.Settings.SAFE_HEAP and not shared.Settings.SAFE_HEAP_LOG and not shared.Settings.RELOCATABLE
 
 
-def provide_fround():
-  return shared.Settings.PRECISE_F32
-
-
 def create_asm_setup(debug_tables, function_table_data, invoke_function_names, metadata):
   function_table_sigs = function_table_data.keys()
 

site/source/docs/api_reference/emscripten.h.rst

@@ -1031,9 +1031,9 @@ Functions
 
   Returns the value of a compiler setting.
 
-  For example, to return the integer representing the value of ``PRECISE_F32`` during compilation: ::
+  For example, to return the integer representing the value of ``INITIAL_MEMORY`` during compilation: ::
 
-    emscripten_get_compiler_setting("PRECISE_F32")
+    emscripten_get_compiler_setting("INITIAL_MEMORY")
 
   For values containing anything other than an integer, a string is returned (you will need to cast the ``int`` return value to a ``char*``).
 

site/source/docs/compiling/Building-Projects.rst

@@ -85,7 +85,6 @@ Emscripten compiler output often consists of several files and not just one. The
  - `emcc ... -o output.a` generates a single archive file `output.a`.
  - `emcc ... -o output.{html,js} -s WASM=0` causes the compiler to target asm.js, and therefore a `.wasm` file is not produced.
  - `emcc ... -o output.{html,js} -s WASM=0 --separate-asm` likewise targets asm.js, but splits up the generated code to two files, `output.js` and `output.asm.js`.
- - `emcc ... -o output.html -s WASM=0 -s PRECISE_F32=2` (combination of targeting .html, asm.js and PRECISE_F32=2) implies as if `--separate-asm` was passed, so also produces `output.asm.js`.
  - `emcc ... -o output.{html,js} --emit-symbol-map` produces a file `output.{html,js}.symbols` if WebAssembly is being targeted (`-s WASM=0` not specified), or if asm.js is being targeted and `-Os`, `-Oz` or `-O2` or higher is specified, but debug level setting is `-g1` or lower (i.e. if symbols minification did occur).
  - `emcc ... -o output.{html,js} -s WASM=0 --memory-init-file 1` causes the generation of `output.{html,js}.mem` memory initializer file. Pasing `-O2`, `-Os` or `-Oz` also implies `--memory-init-file 1`.
  - `emcc ... -o output.{html,js} -g4` generates a source map file `output.wasm.map`. If targeting asm.js with `-s WASM=0`, the filename is `output.{html,js}.map`.

site/source/docs/compiling/WebAssembly.rst

@@ -145,7 +145,6 @@ asm.js support is considered very stable now, and you can change between it and
 - Timing issues - wasm might run faster or slower. To some extent you can mitigate that by building with ``-s DETERMINISTIC=1``.
 - Trap mode. As mentioned above, we can generate wasm that traps or that avoids traps. Make sure the trap mode is ``"js"`` when comparing builds. The ``"js"`` trap mode is also useful in a single build, as otherwise operations like division or float-to-int may trap, and the optimizer may happen to change whether a trap occurs or not, which can be confusing (for example, enabling ``SAFE_HEAP`` may prevent some optimizations, and a trap may start to occur). Instead, in the ``"js"`` trap mode there are no traps and all operations are deterministically defined as identical to JavaScript.
 - Minor libc and runtime differences exist between wasm and asm.js. We used to have a way to emit more compatable builds (``-s "BINARYEN_METHOD='asmjs,native-wasm'"`` etc.) but due to its complexity and low value it was removed.
-- Floating-point behavior: WebAssembly uses 32-bit floats in a standard way, while asm.js by default implements floats using doubles. That can lead to differences in the precision of results. You can force 32-bit float behavior in asm.js with ``-s PRECISE_F32=1``, in which case it should be identical to wasm.
 - Browser instability: It's worth testing multiple browsers, as one might have a wasm bug that another doesn't. You can also test the Binaryen interpreter (e.g. using the ``interpret-binary`` method, as discussed above).
 
 If you find that an asm.js build has the same behavior as a wasm one, then it is currently easier to debug the asm.js build: you can edit the source easily (add debug printouts, etc.), there is debug info and source maps support, etc.

site/source/docs/getting_started/FAQ.rst

@@ -502,16 +502,6 @@ Building :ref:`Fastcomp from source <building-fastcomp-from-source>` (and hence
 The solution is to ensure the system has sufficient memory. On Ubuntu 14.04.1 LTS 64bit, you should use at least 6Gb.
 
 
-Why do I get odd rounding errors when using float variables?
-============================================================
-
-In asm.js, by default Emscripten uses doubles for all floating-point variables, that is, 64-bit floats even when C/C++ code contains 32-bit floats. This is simplest and most efficient to implement in JS as doubles are the only native numeric type. As a result, you may see rounding errors compared to native code using 32-bit floats, just because of the difference in precision between 32-bit and 64-bit floating-point values.
-
-To check if this is the issue you are seeing, build with ``-s PRECISE_F32=1``. This uses proper 32-bit floating-point values, at the cost of some extra code size overhead. This may be faster in some browsers, if they optimize ``Math.fround``, but can be slower in others. See ``src/settings.js`` for more details on this option.
-
-(This is not an issue for wasm, which has native float types.)
-
-
 How do I pass int64_t and uint64_t values from js into wasm functions?
 ======================================================================
 

src/parseTools.js

@@ -757,7 +757,7 @@ function ensureDot(value) {
 
 function asmEnsureFloat(value, type) { // ensures that a float type has either 5.5 (clearly a float) or +5 (float due to asm coercion)
   if (!isNumber(value)) return value;
-  if (PRECISE_F32 && type === 'float') {
+  if (type === 'float') {
     // normally ok to just emit Math_fround(0), but if the constant is large we may need a .0 (if it can't fit in an int)
     if (value == 0) return 'Math_fround(0)';
     value = ensureDot(value);
@@ -772,7 +772,7 @@ function asmEnsureFloat(value, type) { // ensures that a float type has either 5
 
 function asmInitializer(type) {
   if (type in Compiletime.FLOAT_TYPES) {
-    if (PRECISE_F32 && type === 'float') return 'Math_fround(0)';
+    if (type === 'float') return 'Math_fround(0)';
     return RUNNING_JS_OPTS ? '+0' : '.0';
   } else {
     return '0';
@@ -793,7 +793,7 @@ function asmCoercion(value, type, signedness) {
           value = '(' + value + ')|0';
         }
       }
-      if (PRECISE_F32 && type === 'float') {
+      if (type === 'float') {
         return 'Math_fround(' + value + ')';
       } else {
         return '(+(' + value + '))';
@@ -1461,7 +1461,7 @@ function ensureValidFFIType(type) {
 // FFI return values must arrive as doubles, and we can force them to floats afterwards
 function asmFFICoercion(value, type) {
   value = asmCoercion(value, ensureValidFFIType(type));
-  if (PRECISE_F32 && type === 'float') value = asmCoercion(value, 'float');
+  if (type === 'float') value = asmCoercion(value, 'float');
   return value;
 }
 

src/runtime_math.js

@@ -19,16 +19,10 @@ if (!Math.imul || Math.imul(0xffffffff, 5) !== -5) Math.imul = function imul(a,
 
 // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/fround
 #if POLYFILL_OLD_MATH_FUNCTIONS || MIN_CHROME_VERSION < 38 || MIN_EDGE_VERSION < 12 || MIN_FIREFOX_VERSION < 26 || MIN_IE_VERSION != TARGET_NOT_SUPPORTED || MIN_SAFARI_VERSION < 80000 // || MIN_NODE_VERSION < 0.12
-#if PRECISE_F32
-#if PRECISE_F32 == 1
 if (!Math.fround) {
   var froundBuffer = new Float32Array(1);
   Math.fround = function(x) { froundBuffer[0] = x; return froundBuffer[0] };
 }
-#else // 2
-if (!Math.fround) Math.fround = function(x) { return x };
-#endif
-#endif
 #endif
 
 // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32

src/settings.js

@@ -265,29 +265,6 @@ var DOUBLE_MODE = 1;
 // wasm.
 var WARN_UNALIGNED = 0;
 
-// 0: Use JS numbers for floating-point values. These are 64-bit and do not model C++
-//    floats exactly, which are 32-bit.
-// 1: Model C++ floats precisely, using Math.fround, polyfilling when necessary. This
-//    can be slow if the polyfill is used on heavy float32 computation. See note on
-//    browser support below.
-// 2: Model C++ floats precisely using Math.fround if available in the JS engine, otherwise
-//    use an empty polyfill. This will have much less of a speed penalty than using the full
-//    polyfill in cases where engine support is not present. In addition, we can
-//    remove the empty polyfill calls themselves on the client when generating html,
-//    which should mean that this gives you the best of both worlds of 0 and 1, and is
-//    therefore recommended, *unless* you need a guarantee of proper float32 precision
-//    (in that case, use option 1).
-// XXX Note: To optimize float32-using code, we use the 'const' keyword in the emitted
-//           code. This allows us to avoid unnecessary calls to Math.fround, which would
-//           slow down engines not yet supporting that function. 'const' is present in
-//           all modern browsers, including Firefox, Chrome and Safari, but in IE is only
-//           present in IE11 and above. Therefore if you need to support legacy versions of
-//           IE, you should not enable PRECISE_F32 1 or 2.
-// [fastcomp-only]
-// With upstream backend and WASM=0, JS output always uses Math.fround for consistent
-// behavior with WebAssembly.
-var PRECISE_F32 = 0;
-
 // Whether closure compiling is being run on this output
 var USE_CLOSURE_COMPILER = 0;
 

tests/fuzz/test.sh

@@ -7,8 +7,8 @@ rm *.out *.bc *.js
 gcc $@ -m32 -I/home/alon/Dev/csmith/runtime -o n1.out &> /dev/null
 /home/alon/Dev/fastcomp/build/Release+Asserts/bin/clang -m32 -I/home/alon/Dev/csmith/runtime -o n2.out $@ &> /dev/null
 /home/alon/Dev/fastcomp/build/Release+Asserts/bin/clang -m32 -I/home/alon/Dev/csmith/runtime -emit-llvm -c -o bc.bc $@ &> o
-~/Dev/emscripten/emcc $@ -I/home/alon/Dev/csmith/runtime -s PRECISE_F32=1 -o fc.out.js --memory-init-file 0 -profiling &> /dev/null
-~/Dev/emscripten/emcc $@ -s SAFE_HEAP=1 -I/home/alon/Dev/csmith/runtime -s PRECISE_F32=1 -o fc-sh.out.js &> /dev/null
+~/Dev/emscripten/emcc $@ -I/home/alon/Dev/csmith/runtime -o fc.out.js --memory-init-file 0 -profiling &> /dev/null
+~/Dev/emscripten/emcc $@ -s SAFE_HEAP=1 -I/home/alon/Dev/csmith/runtime -o fc-sh.out.js &> /dev/null
 echo "run n1"
 ./n1.out &> n1
 echo "run n2"