Upgrade to upstream WebKit 55d9d9007f

CMakePresets.json

@@ -180,6 +180,10 @@
                 "CMAKE_OBJCXX_FLAGS_DEBUG": {
                     "type": "STRING",
                     "value": "-g -O3"
+                },
+                "USE_PCH_CODEGEN": {
+                    "type": "BOOL",
+                    "value": "OFF"
                 }
             }
         },

Configurations/CommonBase.xcconfig

@@ -93,7 +93,7 @@ OTHER_LDFLAGS = $(inherited) $(WK_COMMON_OTHER_LDFLAGS);
 WK_COMMON_OTHER_TAPI_FLAGS = -x objective-c++ -std=c++2b -fno-rtti $(WK_SANITIZER_OTHER_TAPI_FLAGS) $(WK_AVAILABILITY_OVERLAY_FLAGS);
 OTHER_TAPI_FLAGS = $(inherited) $(WK_COMMON_OTHER_TAPI_FLAGS);
 
-WK_DEFAULT_WK_AUDIT_SPI[sdk=iphoneos*] = $(WK_AND_$(WK_NOT_$(WK_ANY_SANITIZER_ENABLED))_$(SUPPORTS_TEXT_BASED_API));
+WK_DEFAULT_WK_AUDIT_SPI[sdk=iphoneos*] = $(WK_NOT_$(WK_ANY_SANITIZER_ENABLED));
 // Explicitly disable auditing on other embedded platforms, because some SDKs
 // fall back to reading settings for iOS.
 WK_DEFAULT_WK_AUDIT_SPI[sdk=appletvos*] = ;
@@ -102,7 +102,9 @@ WK_DEFAULT_WK_AUDIT_SPI[sdk=xros*] = ;
 // Disable auditing on internal builds of already-shipped releases.
 WK_DEFAULT_WK_AUDIT_SPI[sdk=iphoneos26*.internal] = ;
 
-WK_AUDIT_SPI = $(WK_DEFAULT_WK_AUDIT_SPI);
+// Overridden in projects which do not have an InstallAPI requirement to
+// support audit-spi (e.g. WebCore).
+WK_AUDIT_SPI = $(WK_AND_$(WK_DEFAULT_WK_AUDIT_SPI)_$(SUPPORTS_TEXT_BASED_API));
 
 WK_OTHER_AUDIT_SPI_FLAGS = $(WK_OTHER_AUDIT_SPI_FLAGS_148943382) $(WK_OTHER_AUDIT_SPI_FLAGS_164901718) $(WK_OTHER_AUDIT_SPI_FLAGS_$(CONFIGURATION));
 WK_OTHER_AUDIT_SPI_FLAGS_Release = -DNDEBUG;

Introduction.md

@@ -1389,9 +1389,12 @@ mirroring the same directory structure as `LayoutTests`.
 For example, the actual output produced for `LayoutTests/editing/inserting/typing-001.html`,
 if failed, will appear in `WebKitBuild/Debug/layout-test-results/editing/inserting/typing-001-actual.txt`.
 run-webkit-tests also generates a web page with the summary of results in
-`WebKitBuild/Debug/layout-test-results/results.html` and automatically tries to open it in Safari using the local build of WebKit.
+`WebKitBuild/Debug/layout-test-results/results.html`, and prints the path to it at the end of
+a run with unexpected results so that you can open it manually.
 
-> If Safari fails to launch, specify `--no-show-results` and open results.html file manually.
+> Specify `--show-results` to have run-webkit-tests automatically open results.html in a browser
+> using the local build of WebKit once the tests are done. If the browser fails to launch, drop
+> the option and open results.html yourself.
 
 ### Updating Expected Results
 

JSTests/microbenchmarks/float32array-sort-large-array.js

@@ -0,0 +1,22 @@
+var length = 4096;
+
+var seed = 1;
+function nextRandom() {
+    seed ^= seed << 13; seed |= 0;
+    seed ^= seed >>> 17;
+    seed ^= seed << 5; seed |= 0;
+    return seed;
+}
+
+// Two draws per element so the mantissa has entropy in every byte. A single 32-bit draw leaves
+// the low mantissa bytes zero, which lets the sort skip digit passes that real data would not.
+var source = new Float32Array(length);
+for (var i = 0; i < length; ++i)
+    source[i] = nextRandom() + nextRandom() * 2.3283064365386963e-10;
+
+// Restore the unsorted input every iteration so the sort never sees an already sorted array.
+var array = new Float32Array(length);
+for (var i = 0; i < 4000; ++i) {
+    array.set(source);
+    array.sort();
+}

JSTests/microbenchmarks/float64array-sort-large-array.js

@@ -0,0 +1,22 @@
+var length = 16384;
+
+var seed = 1;
+function nextRandom() {
+    seed ^= seed << 13; seed |= 0;
+    seed ^= seed >>> 17;
+    seed ^= seed << 5; seed |= 0;
+    return seed;
+}
+
+// Two draws per element so the mantissa has entropy in every byte. A single 32-bit draw leaves
+// the low mantissa bytes zero, which lets the sort skip digit passes that real data would not.
+var source = new Float64Array(length);
+for (var i = 0; i < length; ++i)
+    source[i] = nextRandom() + nextRandom() * 2.3283064365386963e-10;
+
+// Restore the unsorted input every iteration so the sort never sees an already sorted array.
+var array = new Float64Array(length);
+for (var i = 0; i < 300; ++i) {
+    array.set(source);
+    array.sort();
+}

JSTests/microbenchmarks/float64array-sort-low-entropy.js

@@ -0,0 +1,20 @@
+var length = 16384;
+
+var seed = 1;
+function nextRandom() {
+    seed ^= seed << 13; seed |= 0;
+    seed ^= seed >>> 17;
+    seed ^= seed << 5; seed |= 0;
+    return seed;
+}
+
+var source = new Float64Array(length);
+for (var i = 0; i < length; ++i)
+    source[i] = (nextRandom() & 1) ? 1e10 : 7.5;
+
+// Restore the unsorted input every iteration so the sort never sees an already sorted array.
+var array = new Float64Array(length);
+for (var i = 0; i < 5000; ++i) {
+    array.set(source);
+    array.sort();
+}

JSTests/microbenchmarks/float64array-sort-medium-array.js

@@ -0,0 +1,22 @@
+var length = 8192;
+
+var seed = 1;
+function nextRandom() {
+    seed ^= seed << 13; seed |= 0;
+    seed ^= seed >>> 17;
+    seed ^= seed << 5; seed |= 0;
+    return seed;
+}
+
+// Two draws per element so the mantissa has entropy in every byte. A single 32-bit draw leaves
+// the low mantissa bytes zero, which lets the sort skip digit passes that real data would not.
+var source = new Float64Array(length);
+for (var i = 0; i < length; ++i)
+    source[i] = nextRandom() + nextRandom() * 2.3283064365386963e-10;
+
+// Restore the unsorted input every iteration so the sort never sees an already sorted array.
+var array = new Float64Array(length);
+for (var i = 0; i < 1000; ++i) {
+    array.set(source);
+    array.sort();
+}

JSTests/microbenchmarks/float64array-sort-presorted.js

@@ -0,0 +1,12 @@
+var length = 16384;
+
+var source = new Float64Array(length);
+for (var i = 0; i < length; ++i)
+    source[i] = i * 0.5;
+
+// Keep the input sorted every iteration; sorting it again must stay cheap.
+var array = new Float64Array(length);
+for (var i = 0; i < 7500; ++i) {
+    array.set(source);
+    array.sort();
+}

JSTests/microbenchmarks/float64array-sort-small-array.js

@@ -0,0 +1,22 @@
+var length = 512;
+
+var seed = 1;
+function nextRandom() {
+    seed ^= seed << 13; seed |= 0;
+    seed ^= seed >>> 17;
+    seed ^= seed << 5; seed |= 0;
+    return seed;
+}
+
+// Two draws per element so the mantissa has entropy in every byte. A single 32-bit draw leaves
+// the low mantissa bytes zero, which lets the sort skip digit passes that real data would not.
+var source = new Float64Array(length);
+for (var i = 0; i < length; ++i)
+    source[i] = nextRandom() + nextRandom() * 2.3283064365386963e-10;
+
+// Restore the unsorted input every iteration so the sort never sees an already sorted array.
+var array = new Float64Array(length);
+for (var i = 0; i < 50000; ++i) {
+    array.set(source);
+    array.sort();
+}

JSTests/microbenchmarks/int16array-sort-large-array.js

@@ -0,0 +1,20 @@
+var length = 4096;
+
+var seed = 1;
+function nextRandom() {
+    seed ^= seed << 13; seed |= 0;
+    seed ^= seed >>> 17;
+    seed ^= seed << 5; seed |= 0;
+    return seed;
+}
+
+var source = new Int16Array(length);
+for (var i = 0; i < length; ++i)
+    source[i] = nextRandom();
+
+// Restore the unsorted input every iteration so the sort never sees an already sorted array.
+var array = new Int16Array(length);
+for (var i = 0; i < 6000; ++i) {
+    array.set(source);
+    array.sort();
+}

JSTests/microbenchmarks/int16array-sort-low-entropy.js

@@ -0,0 +1,20 @@
+var length = 4096;
+
+var seed = 1;
+function nextRandom() {
+    seed ^= seed << 13; seed |= 0;
+    seed ^= seed >>> 17;
+    seed ^= seed << 5; seed |= 0;
+    return seed;
+}
+
+var source = new Int16Array(length);
+for (var i = 0; i < length; ++i)
+    source[i] = (nextRandom() & 1) ? 30000 : 7;
+
+// Restore the unsorted input every iteration so the sort never sees an already sorted array.
+var array = new Int16Array(length);
+for (var i = 0; i < 13000; ++i) {
+    array.set(source);
+    array.sort();
+}

JSTests/microbenchmarks/int32array-sort-large-array.js

@@ -0,0 +1,20 @@
+var length = 4096;
+
+var seed = 1;
+function nextRandom() {
+    seed ^= seed << 13; seed |= 0;
+    seed ^= seed >>> 17;
+    seed ^= seed << 5; seed |= 0;
+    return seed;
+}
+
+var source = new Int32Array(length);
+for (var i = 0; i < length; ++i)
+    source[i] = nextRandom();
+
+// Restore the unsorted input every iteration so the sort never sees an already sorted array.
+var array = new Int32Array(length);
+for (var i = 0; i < 6000; ++i) {
+    array.set(source);
+    array.sort();
+}

JSTests/microbenchmarks/int32array-sort-low-entropy.js

@@ -0,0 +1,20 @@
+var length = 4096;
+
+var seed = 1;
+function nextRandom() {
+    seed ^= seed << 13; seed |= 0;
+    seed ^= seed >>> 17;
+    seed ^= seed << 5; seed |= 0;
+    return seed;
+}
+
+var source = new Int32Array(length);
+for (var i = 0; i < length; ++i)
+    source[i] = (nextRandom() & 1) ? 200000 : 7;
+
+// Restore the unsorted input every iteration so the sort never sees an already sorted array.
+var array = new Int32Array(length);
+for (var i = 0; i < 12000; ++i) {
+    array.set(source);
+    array.sort();
+}

JSTests/microbenchmarks/int32array-sort-medium-array.js

@@ -0,0 +1,20 @@
+var length = 512;
+
+var seed = 1;
+function nextRandom() {
+    seed ^= seed << 13; seed |= 0;
+    seed ^= seed >>> 17;
+    seed ^= seed << 5; seed |= 0;
+    return seed;
+}
+
+var source = new Int32Array(length);
+for (var i = 0; i < length; ++i)
+    source[i] = nextRandom();
+
+// Restore the unsorted input every iteration so the sort never sees an already sorted array.
+var array = new Int32Array(length);
+for (var i = 0; i < 60000; ++i) {
+    array.set(source);
+    array.sort();
+}

JSTests/microbenchmarks/int32array-sort-presorted.js

@@ -0,0 +1,12 @@
+var length = 4096;
+
+var source = new Int32Array(length);
+for (var i = 0; i < length; ++i)
+    source[i] = i * 1024;
+
+// Keep the input sorted every iteration; sorting it again must stay cheap.
+var array = new Int32Array(length);
+for (var i = 0; i < 40000; ++i) {
+    array.set(source);
+    array.sort();
+}

JSTests/microbenchmarks/int32array-sort-small-array.js

@@ -0,0 +1,20 @@
+var length = 192;
+
+var seed = 1;
+function nextRandom() {
+    seed ^= seed << 13; seed |= 0;
+    seed ^= seed >>> 17;
+    seed ^= seed << 5; seed |= 0;
+    return seed;
+}
+
+var source = new Int32Array(length);
+for (var i = 0; i < length; ++i)
+    source[i] = nextRandom();
+
+// Restore the unsorted input every iteration so the sort never sees an already sorted array.
+var array = new Int32Array(length);
+for (var i = 0; i < 190000; ++i) {
+    array.set(source);
+    array.sort();
+}

JSTests/microbenchmarks/map-for-each-deleted-entries.js

@@ -0,0 +1,17 @@
+function sumEntries(map) {
+    var sum = 0;
+    map.forEach(function (value, key) {
+        sum += value - key;
+    });
+    return sum;
+}
+noInline(sumEntries);
+
+var map = new Map;
+for (var i = 0; i < 1500; ++i)
+    map.set(i, i * 2);
+for (var i = 0; i < 1500; i += 3)
+    map.delete(i);
+
+for (var i = 0; i < 1e4; ++i)
+    sumEntries(map);

JSTests/microbenchmarks/map-for-each-key-value.js

@@ -0,0 +1,15 @@
+function sumEntries(map) {
+    var sum = 0;
+    map.forEach(function (value, key) {
+        sum += value + key;
+    });
+    return sum;
+}
+noInline(sumEntries);
+
+var map = new Map;
+for (var i = 0; i < 1000; ++i)
+    map.set(i, i * 2);
+
+for (var i = 0; i < 1e4; ++i)
+    sumEntries(map);

JSTests/microbenchmarks/object-assign-clone-multiple-sources.js

@@ -0,0 +1,4 @@
+var cities = ["a", "b", "c", "d", "e", "f", "g", "h"];
+var state = { id: 1, name: "x", age: 3, city: "z", zip: 0, flag: true, score: 1.5, tag: "t" };
+for (var i = 0; i < 1e4; ++i)
+    state = Object.assign({}, state, { city: cities[i & 7], zip: i });

JSTests/microbenchmarks/regexp-lookbehind-backreference.js

@@ -0,0 +1,10 @@
+let text = "abab-abcabc-xyxy-abcabd-aa-a-".repeat(40);
+let re = /(?<=\1(\w+))-/g;
+let result = 0;
+for (let i = 0; i < 1e4; ++i) {
+    re.lastIndex = 0;
+    while (re.exec(text))
+        result++;
+}
+if (result !== 160 * 1e4)
+    throw new Error("Bad result: " + result);

JSTests/microbenchmarks/set-for-each-value.js

@@ -0,0 +1,15 @@
+function sumValues(set) {
+    var sum = 0;
+    set.forEach(function (value) {
+        sum += value;
+    });
+    return sum;
+}
+noInline(sumValues);
+
+var set = new Set;
+for (var i = 0; i < 1000; ++i)
+    set.add(i);
+
+for (var i = 0; i < 1e4; ++i)
+    sumValues(set);

JSTests/microbenchmarks/uint16array-sort-large-array.js

@@ -0,0 +1,20 @@
+var length = 4096;
+
+var seed = 1;
+function nextRandom() {
+    seed ^= seed << 13; seed |= 0;
+    seed ^= seed >>> 17;
+    seed ^= seed << 5; seed |= 0;
+    return seed;
+}
+
+var source = new Uint16Array(length);
+for (var i = 0; i < length; ++i)
+    source[i] = nextRandom();
+
+// Restore the unsorted input every iteration so the sort never sees an already sorted array.
+var array = new Uint16Array(length);
+for (var i = 0; i < 6000; ++i) {
+    array.set(source);
+    array.sort();
+}