Bug 1466118 part 9 - Some more cleanup. r=luke

Bug 1466118 part 8 - Change compartment check to realm check for JSScript and AbstractFramePtr. r=luke

Bug 1466118 part 6 - Rename CompartmentChecker to ContextChecks and support realm checks. r=luke

Bug 1466118 part 5 - Replace assertSameCompartmentImpl with JSContext::checkImpl. r=luke

Bug 1466118 part 4 - Replace assertSameCompartment with JSContext::check. r=luke

Bug 1466118 part 3 - Replace assertSameCompartmentDebugOnly with JSContext::debugOnlyCheck. r=luke

Bug 1466118 part 2 - Replace releaseAssertSameCompartment with JSContext::releaseCheck. r=luke

Bug 1466118 part 1 - Use variadic templates for assertSameCompartment functions. r=luke

Bug 1480725 - stress test wasm atomics. r=luke Atomic operations are stress-tested by having multiple workers work on the same location in ways that would reveal non-atomicity in an incorrect result. We run these tests only on native implementations, not on simulators. Our simulators don't implement atomicity well. This patch has the bare minimum, testing multiple agents that perform the same operation. It's possible to do more, notably, to combine different operations.

Bug 1467632 - Specialize ReadScalar<ExprType>. r=luke Normally ReadScalar uses memcpy from the source stream to the destination object. This is only well-defined if the destination argument is a POD type, which ExprType is not. So specialize ReadScalar for ExprType and make the memcpy target the data payload in that type instead.

Bug 1467632 - Make AsmJSGlobal's pod field be POD. r=luke, r=waldo The pod member needs to be POD but has members that have evolved no longer to be POD - a ValType and a LitVal. We work around the problem locally by using ValType's representation type PackedTypeCode to represent types, and by specializing LitVal as LitValPOD for use in this structure.

Bug 1483182 - Do report OOM failures in HashTable::reserve(). r=luke This fixes a typo.

Bug 1483182 - Don't allocate in HashTable::lookupOrAdd(). r=luke Currently lookupOrAdd() will allocate if the table has no storage. But it doesn't report an error if the allocation fails, which can cause problems. This patch changes things so that lookupOrAdd() doesn't allocate when the table has no storage. Instead, it returns an AddPtr that is not *valid* (its mTable is empty) but it is *live*, and can be used in add(), whereupon the allocation will occur. The patch also makes Ptr::isValid() and AddPtr::isValid() non-public, because the valid vs. live distinction is non-obvious and best kept hidden within the classes.

Bug 1479430 - Make sure TypeNewScript::maybeAnalyze is called in the group's realm. r=luke

Bug 1437065: Rename interpCodeRangeIndex to funcCodeRangeIndex; r=luke

Bug 1437065: Have LookupCode reset the codeRange out-param if it didn't find a Code; r=luke

Bug 1484605 - Tweak some lookupForAdd() uses. r=luke These are cases where the existing code is a little dubious or sub-optimal.

Bug 1483062 - Inline and remove HashTable::{over,under}loaded(). r=luke Because they each only have a single call site, and the "too many items removed?" test is already encapsulated within rehashIfOverloaded().

Bug 1483062 - Merge HashTable::wouldBeUnderloaded() into underloaded(). r=luke

Bug 1483062 - Inline and remove HashTable::overRemoved(). r=luke

Bug 1483062 - Rename HashTable::rehashIfOverRemoved(). r=luke infallibleRehashIfOverloaded() actually matches what it does. Also, the patch removes the `overloaded()` test within the function, because `rehashIfOverloaded()` has the same test.

Bug 1483062 - Rename some HashTable methods. r=luke Specifically: - checkOverloaded -> rehashIfOverloaded - checkUnderloaded -> shrinkIfUnderloaded - checkOverRemoved -> rehashIfOverRemoved Because I've always found that the `check` prefix doesn't clearly explain that the table might be changed, And: - shouldCompressTable -> overRemoved Because that matches `overloaded` and `underloaded`.

Bug 1483062 - Rename HashTable::findFreeEntry() as findNonLiveEntry(). r=luke Because that's a more accurate description of what it does -- it finds free *and* removed entries.

Bug 1483062 - Remove HashTable::maybeCreateTable. r=luke It's dead.

Bug 1481171 - Properly emit signal handling metadata for wasm on aarch64. r=luke As the aarch64 instruction emitters do not return the BufferOffset of the access instruction, we have to resort to AutoForbidPools to keep the metadata emitted at the correct address of the access. Manual inspection of the assembler code and the addressing modes used reveals that this is viable, if it's done just so. I've added comments to highlight the fact that it is a little brittle, and the AutoForbidPools with an instruction window of 1 instruction will cause failures if assumptions about the machine code should be violated accidentally in the future.

Bug 1481998 - Make mozilla::Hash{Map,Set}'s entry storage allocation lazy. r=luke,sfink Entry storage allocation now occurs on the first lookupForAdd()/put()/putNew(). This removes the need for init() and initialized(), and matches how PLDHashTable/nsTHashtable work. It also removes the need for init() functions in a lot of types that are built on top of mozilla::Hash{Map,Set}. Pros: - No need for init() calls and subsequent checks. - No memory allocated for empty tables, which are not that uncommon. Cons: - An extra branch in lookup() and lookupForAdd(), but not in put()/putNew(), because the existing checkOverloaded() can handle it. Specifics: - Construction now can take a length parameter. - init() is removed. Explicit length-setting, when necessary, now occurs in the constructors. - initialized() is removed. - capacity() now returns zero when the entry storage is absent. - lookupForAdd() is no longer `const`, because it can instantiate the storage, which requires modifications. - lookupForAdd() can now return an invalid AddPtr in two cases: - old: hashing failure (due to OOM in the hasher) - new: OOM while instantiating entry storage The existing failure handling paths for the old case work for the new case. - clear(), finish(), and clearAndShrink() are replaced by clear(), compact(), and reserve(). The old compactIfUnderloaded() is also removed. - Capacity computation code is now in its own functions, bestCapacity() and hashShift(). setTableSizeLog2() is removed. - uint32_t is used throughout for capacities, instead of size_t, for consistency with other similar values. - changeTableSize() now takes a capacity instead of a deltaLog2, and it can now handle !mTable. Measurements: - Total source code size is reduced by over 900 lines. Also, lots of existing lines got shorter (i.e. two checks were reduced to one). - Executable size barely changed, down by 2 KiB on Linux64. The extra branches are compensated for by the lack of init() calls. - Speed changed negligibly. The instruction count for Bench_Cpp_MozHash increased from 2.84 billion to 2.89 billion but any execution time change was well below noise.

Bug 1481998 - Define lookup() in terms of readonlyThreadsafeLookup(). r=luke The two functions are almost identical. This change minimizes duplication.

Bug 1481998 - Change sJSObjWrappers initialization. r=luke GCHashMap will shortly lose its initialized() function, so we need another way to indicate whether this table has been created. This patch changes it to use a pointer instead.

Bug 1482423 part 1 - Assert compartments don't contain both system/non-system realms. r=luke

Bug 1481171 - Remove failure path for lookupTrap(). r=luke With asm.js atomics gone and wasm atomics opting in to standard trap-based OOB handling, we should never fail to find a trap site. So assert that we always find it, and remove code that is now dead.

Bug 1481171 - Wasm-specific atomics operations. r=luke A large and mostly mechanical change: Prune the non-JS atomic APIs in MacroAssembler.h and add many wasm-specific APIs instead. The three non-JS APIs that remain in MacroAssembler.h could also be removed but are used in multiple places to implement the JS APIs, and it seemed fine to just leave them in. They are after all generally useful. Note, this patch changes MIPS code so that it compiles, but it does not insert the necessary emitting of metadata, partly because the mechanics of that for 64-bit ops on 32-bit systems depends on the implementation of those 64-bit ops, and partly because I am happy to let the MIPS maintainers do the work and check it. I have left behind FIXME comments where changes are needed. The one additional test case in jit-test is a result of closely reading existing code and finding a bug that should have caused a failure, but didn't, once the wasm/asm.js fallback for signal handling was removed.

Bug 1481793 part 3 - Assert cross-compartment wrappers don't wrap other CCWs. r=luke

Bug 1481793 part 2 - Do a CheckedUnwrap in JS_StructuredClone. r=luke

Bug 1481793 part 1 - Use assertSameCompartment instead of AutoRealm in JSStructuredCloneWriter::write. r=luke

Bug 1478713 - Add some tests for the Wasm JS API; r=luke+bbouvier

Bug 1481138 - Clarify that Hash{Map,Set}::putNew() can be used if elements have been removed. r=luke Hash{Map,Set}::putNew() can be used on a table that has had elements removed, despite some comments to the contrary. This patch fixes those comments. It also clarifies when putNewInfallible() can be used. This patch also removes the !isRemoved() assertion in findFreeEntry(), which is confusing -- !isLive() would be more precise, but also obvious from the surrounding code. MozReview-Commit-ID: q4qwKGBsHx

Bug 1481138 - Remove HashMap::lookupWithDefault(). r=luke Because it's quite strange, badly named, not that useful, and barely used. Also remove WeakMap::lookupWithDefault(), which is similar, but not used at all. MozReview-Commit-ID: IhIl4hQ73U1

Bug 1481138 - Remove the add() variant in HashTable and GCHashTable that uses a default value. r=luke Because (a) it's kinda weird, and (b) only used in a single test, where it can be easily replaced with a vanilla add(). MozReview-Commit-ID: L4RoxFb7yGG

Bug 1423577 - Remove asm.js atomics support. r=luke

Bug 1481138 - Clarify that Hash{Map,Set}::putNew() can be used if elements have been removed. r=luke Hash{Map,Set}::putNew() can be used on a table that has had elements removed, despite some comments to the contrary. This patch fixes those comments. This patch also removes the !isRemoved() assertion in findFreeEntry(), which is confusing -- !isLive() would be more precise, but also obvious from the surrounding code. MozReview-Commit-ID: q4qwKGBsHx

Bug 1481138 - Remove Hash{Map,Set}::putNewInfallible. r=luke The difference between putNew() and putNewInfallible() is subtle -- the latter omits three checks. Omitting two of them (SimulatedOOM and checkOverloaded()) is reasonable, but omitting the EnsureHash() check is dubious. Furthermore, putNewInfallible() has very few uses; in my opinion, not enough to warrant its existence. So this patch removes it, simplifying the API and the implementation. MozReview-Commit-ID: 3KfpVERhqTh

Bug 1481138 - Remove HashMap::lookupWithDefault(). r=luke Because it's quite strange, badly named, not that useful, and barely used. Also remove WeakMap::lookupWithDefault(), which is similar, but not used at all. MozReview-Commit-ID: IhIl4hQ73U1

Bug 1481138 - Remove the add() variant in HashTable and GCHashTable that uses a default value. r=luke Because (a) it's kinda weird, and (b) only used in a single test, where it can be easily replaced with a vanilla add(). MozReview-Commit-ID: L4RoxFb7yGG

Bug 1480668 - Remove js::CStringHashPolicy. r=luke It's identical to mozilla::CStringHasher. Also fix a comment at the top of HashTable.h about CStringHasher.

Bug 1480650 - Remove mozilla::HashTable::Stats. r=luke I bet nobody has used them in years. The use of ad hoc profiling (printfs plus post-processing with a tool like https://github.com/nnethercote/counts) is generally a better approach. Bug 1179657 did likewise for PLDHashTable.

Bug 1480323 - Reorder methods in Hash{Set,Map}. r=luke And add comments delimiting different operation groups. Together these changes make Hash{Set,Map} much easier to navigate.

Bug 1480588 - restrict rtdsc Time.h functions to x86ish processors on Windows; r=luke __rtdsc is not going to work so well on AArch64.

Bug 1480012 - Generalize JS shell mailbox to Wasm memories and modules. r=luke In the old days we could only share a SharedArrayBuffer, but now we can also share WasmMemory and WasmModule objects. Rename the shell's get/setSharedArrayBuffer as get/setSharedObject and generalize them to handle the new types. Leave the old names in place as aliases of the new names. We rename /some/ uses of get/setSharedArrayBuffer in existing test cases, but leave uses in test262 alone; we need to upstream those more carefully.

Bug 1480361 - Introduce HashTable::LookupReason. r=luke Again inspired by PLDHashTable, this makes things a bit clearer than passing 0 or sCollisionBit. It also guarantees more strongly that we'll end up with appropriately specialized code for the Add vs. NonAdd cases. (That guarantee isn't currently needed because the compiler inlines things sufficiently anyway, but it can't hurt.)

Bug 1480361 - Tweak handling of removed entries in HashTable::lookup(). r=luke There are two improvements here. - When we're just doing a lookup (i.e. aCollisionBit==0), we don't need to do any special handling of removed entries. (Inlining means that the removed entry code is entirely removed for lookups.) - When we're doing an insertion (i.e. aCollisionBit==sCollisionBit), we now stop adding collision markings once we find a removed entry, because they're unnecessary after that point. This change brings the code in alignment with PLDHashTable::SearchTable().