See https://html.spec.whatwg.org/multipage/dom.html#dom-document-currentscript

Import returns a promise, so things had to be rearranged. I think I could have used promise.resolve() instead, but that's something to revisit if I can actually get this working.

…n the main thread.

I feel like this should break things, but it seems to work properly with my tests.

If EXPORT_ES6 and USE_PTHREADS then redefining functions don't work inside a worker. The only case we seem to do this is in the runtime checks, so don't do those checks in this specific case.
This is basically only for debugging, so I don't think removing this in that specific case is that big of a deal.

Obviously this means that USE_PTHREADS + EXPORT_ES6 + ASSERTIONS won't work. But this never worked, so I think this is fine. Will need to open an issue to fix this.

This change is another part that aims to solve emscripten-core#7883, by adding "-fno-discard-value-names" to clang invocation calls from emcc.py, when debug levels >= 3.

It depends on emscripten-core/emscripten-fastcomp-clang#27.

With wasm SAFE_HEAP always requires `segfault` and friends because
calls to them are constructed by the binaryen pass.

- remove else after return
- use enumerate() rather than manual counting
- remove constant sep argument to parse_string_list_members
- move `check_bad_eq` function inside `parse_args`

See https://www.chromestatus.com/feature/6228189936353280

Fixes emscripten-core#8315.

In this case we use the create_lib wrapper to ensure this.

Fixes emscripten-core#8341

This test currently is currently expected to fail, until we fix
this issue;

See emscripten-core#8268.

This will automate asking people to add themselves to AUTHORS on their first PR.

(Apparently this works using a magic filename + location, see https://help.github.com/en/articles/creating-a-pull-request-template-for-your-repository )

Both options modify the JS library functions, but LIBRARY_DEBUG did it in a destructive way (removed arguments from the declaration). This refactors both code locations to call a single helper function which does things properly, and adds a tes

And enable under node and v8 (The output seems to match now).

We invoke wasm-opt after finalize, and it needs to be given the source map, and told to emit one, as it changes the binary.

This wasn't noticed in testing because finalize did emit a .map file - it just got out of date later when the binary was changed, but the test just checks for its existence and how many items it has, and doesn't literally understand the source map format and check if things line up to the binary.

This sends clientside browser exceptions to the test runner, and logs them out.

This may help debug failures on our CI, as before this an exception usually just silently hangs the test, and we need to try to reproduce it locally. Now at least we should get a stack trace.

I've noticed that on Firefox the gl tests seem to fail sporadically, hopefully this will help narrow down exactly what is failing.

…-core#8339)

Currently the entire library is printed which makes seeing the
actual error very difficult.  Normally the filename and line number
should be sufficient and we can put the rest of it befind VERBOSE=1.

Closes emscripten-core#8300

so we can handle software that has a `.tar.gz` download and no `.zip`
and don't have to create a repo just to have a `.zip` URL.

Mainly so that editors know that this project uses 2 space indents
for Python instead of the more typical 4.

Add comment noting that `shutil.unpack_archive` can be used when the
project moves to Python 3.

…ten-core#8334)

…pten-core#8363)

This fixes the breakage with latest llvm upstream that honors `-fPIC`.

…ipten-core#8364)

As there is a source of nondeterminism in the JS backend - LLVM IR text names affect asm.js names, which leads to difference code size, which leads to different code sizes. In particular, on the exact same fastcomp+emscripten I get 7 byte larger code sizes locally than the bots do. This appears to have gotten more random since the recent change to LLVM IR debug name changes, but it was probably a problem all along, just became more noticeable.

This appears to be a JS backend issue, so it should not exist with the wasm backend, once we switch over.

Added --no_private_browsing argument to emrun to allow running tests which require features which are disabled in private browsing modes (for example, indexeddb).

…re#8381)

Without this we were needlessly building a second copy of bullet with
-fPIC.  This was causing an llvm crash running wasm0.test_the_bullet.

We need to fix upstream llvm, but in the mean time we can fix the test
by simply not build build in the shared library version of bullet.

…es (emscripten-core#8377)

See emscripten-core#8376 and emscripten-core#8268.

This means we don't need to specify -DBUILD_SHARED_LIBS=OFF since
it will effectively be the default.

…ner.py. NFC. (emscripten-core#8379)

build_library only had one non-test caller, and it turns out that
was itself dead code.

…re#8369)

(for all the static allocation + stack etc.)

Not catching this early leads to late validation errors in asm2wasm.

fixes WebAssembly/binaryen#1968

We this test we were using the library from emscripten ports but the
header from the copy of zlib in the tests directory.

This was resulting a consistent version mismatch.

…ten-core#8382)

These are essentially methods for some reason were defined as free
functions.

…ten-core#8387)

(Without this we don't test metadce + llvm.used anywhere)

…e#8386)

…n't all on one line (emscripten-core#8389)

…mscripten-core#8348)

Use the new emscripten triple in LLVM. This lets us avoid needing to define __EMSCRIPTEN__ ourselves, and enables optimizations for iprintf (integer printf), __small_printf (printf with floats but not long double), and friends.

Refactor/hack musl to have compact versions of those functions. To simplify things and avoid the duplicate code problem of having both printf and iprintf linked in (from separate object files) this uses an indirect call for fmt_fp (the key method that formats a floating point number) and pop_arg_long_double (a new method that pops a long double from the arguments). We then pass around either NULL or function pointers to the real implementation, e.g. iprintf sends NULL for both. This means an extra indirect call on them when they are actually used, but this is not too bad since fmt_fp is fairly heavy anyhow - adding an indirect call or two on top is probably not a huge deal.

This also makes printf only use doubles for actual formatting. That is, it casts a float128 to a float64 for printing. This makes things simpler (no need to create two fmt_fps and avoids having duplicate code if both are linked in. This also keeps us consistent with how fastcomp prints currently, so this is not a regression. If users ask for full float128 printing, we can add it later (it has never come up so far).

Code size wise, iprintf (no float support) is around 3K smaller, and small (just double, no long double) is around 750 bytes smaller. Full printf is larger than small because it has the code to cast a float128 to a double. Note that full printf now does not have long double printing at full precision, so we save 4K or so there.

This appears to have never worked, and was not tested.

*    Ensure _scriptDir exists properly.
*    Do not instantiate Module(), as this mode does so automatically.
*    Add a test.

…ize (emscripten-core#8394)

This is the way the MAIN_MODULE exports global addresses and one
step towards working dynamic linking.

See the corresponding binaryen change that must land after this one:
WebAssembly/binaryen#1979

…re#8396)

This fixes the current crash on the waterfall due to a bug in
`wasm-ld --relocatable`.

…re#8391)

This dates back to when we needed the archive to contain .s
files.

We do still however require that compiler-rt be build as object
files rather then bitcode files.  Having compiler-rt be part of the LTO
causes causes lld link failures.

See https://bugs.llvm.org/show_bug.cgi?id=41384

normalize too-short scores, handle 0 reps, general cleanup, prepare for wasm backend (disable MINIMAL_RUNTIME for now, but remember tests where it can be enabled soon)

 *   Use cDefine at compile time where possible, to avoid using ERRNO_CODES which closure errors on not being present (happens in later PRs; will be tested there).
 *   Translate node errnos and our syscall errnos directly (just need to be negated).

Gets the list of features as metadata['features'] from wasm-emscripten-finalize. It then passes those to the various invocations we do of binaryen tools.

Also updates binaryen to version_77 for the binaryen side of things, and adds a TODO test (which passes on v8 master, but not node LTS yet).

This reduces the noise there. But it is still surprisingly noisy.

This TODO is misleading as it was fixed in emscripten-core#8055.

…orted (emscripten-core#8295)

This ensures that calls to aliases work.

…ore#8365)

(in wasm - no support in asm.js)

Background: WebAssembly/design#1271

* Add GROWABLE_HEAP_* methods that replace each load and store in JS. These safely check if memory grew, and updates the buffer and views if so. The JS optimizer is used to instrument the JS in this way, so it works for user JS as well.
* Show a warning about the slowness during compilation.
* Make sbrk etc. threadsafe.
 * Rewrite brk using sbrk, to avoid writing two pieces of threadsafe code.

After investigation, one major source of our random errors is a test that reports multiple results, and they end up seen as results for the tests after them. We had assertions to prevent that but they didn't work :( Details:

* Unify browser error reporting into a single browser_reporting.js file. Create a run_emcc_for_btest method that includes that code for our tests that run emcc manually
* Error if we try to send more than one response back to the server.
* Actually error on the server when that happens. We had this code before, but it just printed an exception and then it got swallowed in the python webserver code... I guess it doesn't want a single failed request to bring down the server? Anyhow, to do this we save a special message for the code outside to see, and error there where it actually makes the test fail.
* Check for such excessive messages both before a test runs and after. When we error on such a thing, clear the queue so other tests afterwards do not fail too.
* Do not allow a test to be both a reftest and have an expected value, and fix tests that tried to do weird stuff like that.

…e#8334 (emscripten-core#8368)

…with current node (emscripten-core#8417)

Previously we were mangling every single filename just in case it
collided with another.  Now we only mangle names that would collide with
existing names.

This cost of this is that we need to read the archive contents on
startup when that archive we are adding to already exists.  However we
should actually expect a performance increase here since only files that
collide will need to be copied.

Another motivating factor for this change is that it makes linker errors
more sensible since the filenames in the archives will match those on
disk.

This allows us to add more incompatibility checking to the STRICT
option without forcing it on all users or MINIMAL_RUNTIME.

This is part of emscripten-core#8317.

In particular we already already error on the use legacy settings
when in STRICT mode, but I understand that at least on major user (@juj)
wants to be able to continue to use legacy command line settings and
also wants to use MINIMAL_RUNTIME.

These globals are defined in musl C code so as far as I can tell
are never used.

…scripten-core#8422)

…en-core#8424)

Sometimes they are not.

…ten-core#8413)

Part of emscripten-core#8317

This test has been broken for a long time now but was not running
due to a bug in the use of decorators which was recently fixed in emscripten-core#8424
so this test started failing.

…s. NFC (emscripten-core#8420)

This is reduces the number redundant argument on the linker command
line. Mostly useful for EMCC_FORCE_STDLIBS=1 where all libraries are
forced.

)

* Use nontrapping-fptoint by default.
* Recognize v8 (which is how jsvu names it, unlike when building v8 when it arrives as d8).
* Add an EMBENCH_NAME env var in the benchmark runner, which is useful when running a single VM in each invocation of the benchmark suite.

…n-core#8426)

Without this its not possible to use --whole-archive around libc without
introducing duplicate symbol error.

Also fix misnamed `func` variable (it actually holds and i32 address)

…e#8436)

Doing it after libraries means we can know at pre render time which library code is included (which will enable later PRs to do useful things, like see if the FS object was included, and render appropriate code for it or not).

Helps emscripten-core#8421

The hacks for GL are not just ugly, but also bad for code size in some cases, it turns out (apparently closure will not optimize as much in their presence).

This is a step towards emscripten-core#8421, the changes for which end up causing closure to emit worse code if not for this PR.

Fixes emscripten-core#8433

These do not fix all the issues that lead to random test failures, but they do fix at least two:

*    Send a sync message before doing window.close. Otherwise, the close and the message may race (e.g., the close may happen before the message is sent from the browser). In that case, we don't get the exit code, and exit with 0, which makes the test fail.
*    Be careful with the initial ping ("pageload" message) to the server - the server may not be up yet, and if not, the xhr will throw immediately. Keep trying until that succeeds.