Merge remote-tracking branch 'origin/main' into move-epoll

# Conflicts:
#	src/libraries/System.Net.Sockets/src/System/Net/Sockets/SocketAsyncEngine.Wasi.cs
#	src/libraries/System.Net.Sockets/src/System/Net/Sockets/SocketPal.Wasi.cs
#	src/native/libs/System.Native/pal_networking_browser.c

Author: tmds

.config/dotnet-tools.json

@@ -15,7 +15,7 @@
       ]
     },
     "microsoft.dotnet.xharness.cli": {
-      "version": "11.0.0-prerelease.26204.1",
+      "version": "11.0.0-prerelease.26279.1",
       "commands": [
         "xharness"
       ]

.github/skills/ci-pipeline-monitor/pipelines.md

@@ -37,6 +37,10 @@ cached mapping table).
 | runtime-coreclr libraries-pgo | |
 | runtime-coreclr pgostress | |
 | runtime-coreclr jit-cfg | Sat-Sun 22:00 UTC | Control flow guard. |
+| runtime-coreclr crossgen2 | Daily | Crossgen2 R2R + comparison tests. |
+| runtime-coreclr crossgen2 outerloop | Daily | Crossgen2 outerloop R2R tests. |
+| runtime-coreclr crossgen2-composite | Daily | Crossgen2 composite R2R tests. |
+| runtime-coreclr crossgen2-composite gcstress | Weekends | Crossgen2 composite with GC stress. |
 
 ## Cached Definition ID Mapping
 
@@ -64,6 +68,10 @@ entries via the AzDO Definitions API, and adds new rows here.
 | runtime-coreclr superpmi-replay | 150 | |
 | runtime-coreclr superpmi-asmdiffs-checked-release | 153 | |
 | runtime-coreclr jit-cfg | 155 | |
+| runtime-coreclr crossgen2 | 124 | |
+| runtime-coreclr crossgen2 outerloop | 134 | |
+| runtime-coreclr crossgen2-composite | 136 | |
+| runtime-coreclr crossgen2-composite gcstress | 141 | |
 | runtime-coreclr jitstress-random | 159 | |
 | runtime-coreclr libraries-jitstress-random | 160 | |
 | runtime-coreclr pgostress | 230 | |

.github/workflows/ci-failure-scan-feedback.md

@@ -159,6 +159,9 @@ For each row in the pipeline table below:
 | runtime-coreclr r2r | 120 | |
 | runtime-coreclr gc-simulator | 123 | |
 | runtime-coreclr crossgen2 | 124 | |
+| runtime-coreclr crossgen2 outerloop | 134 | |
+| runtime-coreclr crossgen2-composite | 136 | |
+| runtime-coreclr crossgen2-composite gcstress | 141 | Weekends |
 | runtime-jit-experimental | 137 | OSR / partial compilation |
 | runtime-coreclr libraries-jitstress | 138 | |
 | runtime-coreclr ilasm | 140 | |
@@ -231,6 +234,14 @@ test -f /tmp/gh-aw/agent/filed.tsv && cut -f1 /tmp/gh-aw/agent/filed.tsv | grep
 printf '%s\t%s\n' "$key" "aw_<id>" >> /tmp/gh-aw/agent/filed.tsv                              # after emit
 ```
 
+**Cross-definition dedup (check second).** A KBE matches on signature text regardless of which pipeline definition produced it, so do NOT file a second KBE for a signature already filed this run under a different `definition_id`. After the exact-key check above misses, also check the definition-independent key `<queue>|<stress_mode>|<signature_norm>`. On match, record `skipped: cross-def dup of filed-issue #aw_<id> earlier in this run` and stop. Do NOT proceed to Branch B: `aw_<id>` is a safe-output ID from this run, not a real issue number, and rule #9 forbids same-run test-disable PRs. The per-definition test-disable PR (if test-disable is welcome on the resulting KBE) will surface on the next run, once the KBE has a real issue number. Append this key too after every Branch A emission.
+
+```bash
+xkey="<queue>|<stress_mode>|${signature_norm}"
+test -f /tmp/gh-aw/agent/filed.tsv && cut -f1 /tmp/gh-aw/agent/filed.tsv | grep -Fxq "$xkey"  # cross-def dup if exit 0
+printf '%s\t%s\n' "$xkey" "aw_<id>" >> /tmp/gh-aw/agent/filed.tsv                              # after emit
+```
+
 #### Step 4.1 — Load the matching skill
 
 | Pipeline category | Skill |
@@ -250,6 +261,15 @@ Follow exactly these sections from `.github/workflows/shared/create-kbe.instruct
 3. `<a id="search-existing-prs"></a>` / `## Search for existing PRs already handling the failure`
 4. `<a id="verify-embedded-issues"></a>` / `## Verify every embedded issue number exists`
 
+When searching, account for the fact that the same signature can be filed in
+different `ErrorMessage` representations. A KBE recorded in `<a id="kbe-array-form"></a>`
+multi-line array form will not surface from a single-substring search, and vice
+versa. Before concluding "no existing KBE", also search each individual array
+element / log line of the signature on its own (not just the joined form), and
+search the most distinctive single substring even when you intend to file the
+array form. If any of these variant-form searches surfaces a candidate, treat it
+as `existing-kbe` rather than filing a duplicate.
+
 Record the same outcomes described there:
 
 - `existing-kbe #<n>`
@@ -261,7 +281,8 @@ Record the same outcomes described there:
 
 Read the candidate KBE / tracker body + the latest 5 comments (not just the most recent). Also read the body + latest 5 comments of ANY issue referenced in the KBE body (e.g. `refs #<n>`, `Tracking: dotnet/runtime#<n>`) — maintainer signals on the root-cause issue override the KBE. Skip the test-disable (record `-> skipped: do-not-disable on issue #<n>`) if ANY of:
 
-- Body or recent comment from any `MEMBER`/`OWNER` mentions one of (case-insensitive): `please don't disable`, `do not mute`, `do not disable`, `keep failing`, `investigation in progress`, `fix-forward`, `fix forward`, `should be supported`, `will investigate`, `wait for #`, `landing in #`.
+- Body or recent comment from any `MEMBER`/`OWNER` mentions one of (case-insensitive): `please don't disable`, `do not mute`, `do not disable`, `keep failing`, `investigation in progress`, `fix-forward`, `fix forward`, `should be supported`, `will investigate`, `wait for #`, `landing in #`, `trying to understand`, `without disabling`, `i'm fixing`, `i am fixing`, `understand the problem`, `investigating root cause`, `find the root cause`.
+- Heuristic catch-all: any `MEMBER`/`OWNER` comment expressing investigation or fix-forward intent, even when no exact phrase above matches. Treat first-person statements about understanding, diagnosing, or fixing the failure (e.g. "I'm looking into this", "we should understand why", "I'd rather fix the pipeline than mute") as a do-not-disable signal. When the comment reads as a maintainer choosing to investigate rather than mute, skip the test-disable.
 - Issue carries a label semantically equivalent to "do not mute" (verify the label exists in `dotnet/runtime` before relying on it; do not invent labels).
 - Most recent area-owner comment within the last 14 days opposes disabling on procedural grounds.
 - A prior `[ci-scan]` test-disable PR for the same test (or same KBE `#<n>`) was **closed without merge** within the last 30 days. Search `is:pr is:closed -is:merged "<test-name>" "[ci-scan]" closed:>=<30-days-ago>` and `is:pr is:closed -is:merged "#<n>" "[ci-scan]" closed:>=<30-days-ago>` (compute `<30-days-ago>` as the ISO date 30 days before the scan run). For each hit, fetch the PR comments and skip if any commenter with `authorAssociation` `MEMBER` or `OWNER` used any of the keywords listed above. The combination of a maintainer pushback comment plus a non-merge close is the do-not-disable signal; the closer does not need to be the same maintainer. Re-filing requires fresh evidence such as a new maintainer comment on the KBE greenlighting the disable, or a clearly different failure signature. Record `-> skipped: do-not-disable, prior PR #<n> closed without merge after maintainer pushback`.
@@ -290,12 +311,16 @@ No meta / aggregate / outage issues. Every KBE is keyed to a single `(definition
 
 **Branch A — No existing KBE; signature is stable.**
 
-Stable means >= 2 occurrences in the ~10-build window, OR a build break that fails all legs of the current build (block-everyone severity that warrants filing on first sight). Emit one `create_issue` using exactly the shared new-KBE template from `.github/workflows/shared/create-kbe.instructions.md` section `<a id="new-kbe-template"></a>` / `## New-KBE template`, including whichever of `<a id="literal-kbe-template"></a>` / `### KBE issue body - literal substring match`, `<a id="regex-kbe-template"></a>` / `### KBE issue body - regex match`, or `<a id="kbe-array-form"></a>` / `### KBE multi-line array form` fits the signature. Apply both `Known Build Error` and `blocking-clean-ci` labels so the org project auto-add rule picks it up; do NOT try to mutate the project from this workflow. Append to the same-run dedup cache (Step 4.0) after emission.
+Stable means >= 2 occurrences across >= 2 distinct builds in the ~10-build window, OR a build break that fails all legs of the current build (block-everyone severity that warrants filing on first sight). Multiple legs, retries, or work items of the SAME build (same build id) count as a single occurrence, not two — a one-off failure that appears in only one build is NOT stable; record `skipped: < 2 occurrences and not blocking` and let the next run revisit. Emit one `create_issue` using exactly the shared new-KBE template from `.github/workflows/shared/create-kbe.instructions.md` section `<a id="new-kbe-template"></a>` / `## New-KBE template`, including whichever of `<a id="literal-kbe-template"></a>` / `### KBE issue body - literal substring match`, `<a id="regex-kbe-template"></a>` / `### KBE issue body - regex match`, or `<a id="kbe-array-form"></a>` / `### KBE multi-line array form` fits the signature. Apply both `Known Build Error` and `blocking-clean-ci` labels so the org project auto-add rule picks it up; do NOT try to mutate the project from this workflow. Append to the same-run dedup cache (Step 4.0) after emission.
+
+**Match-count gate.** Reject the emit if the body lacks `<!-- ci-scan-match-count: <N> hits in failure.log -->` with `N >= 1`. Treat an absent marker as `N=0` and record the same skip reason check #7 of the shared instructions uses: `skipped: signature did not match failure.log (N=<count>)`. Rationale, log-source caveats, and native-assert handling live in check #7.
 
 If the shared KBE lookup flow recorded `linked-tracker #<tracker>`, cross-link it as `Tracking: dotnet/runtime#<tracker>` in the KBE body. Test-disable PR is deferred to the next run.
 
 **Branch B — Existing KBE; no test-disable PR; test-disable is welcome (Step 4.7 clean).**
 
+Before emitting, re-confirm the linked KBE is still `open`. If it has been closed (fixed, not planned, or duplicate), do NOT emit a test-disable PR against it — an orphaned PR referencing a closed KBE has no tracking issue to gate its revert. Record `skipped: linked KBE #<n> is closed` and stop for this signature; the next run will re-evaluate via Step 4.2 and may file a fresh KBE through Branch A if the failure still recurs. Do not fall through to Branch A this run (Step 5's one-outcome-per-signature rule).
+
 Emit one `create_pull_request` using the Test-disable PR template. Diff <= 5 lines; only test annotations or csproj flags. Body MUST include `Linked KBE: #<n>` as a top-level line plus the Step 4.8 four-question block.
 
 Build-break KBEs cannot be disabled — there is no test annotation that can skip a compile error. Skip Branch B for build-break signatures (record `skipped: build break — no test-disable path` in the tally) and rely on Branch C (small-fix PR) when the fix is mechanical, or on the area owner otherwise.

.github/workflows/ci-failure-scan.md

@@ -88,6 +88,8 @@ The following code block can be used as the contents of the `pre-commit` file to
 
 ```sh
 #!/bin/sh
-./eng/formatting/format.sh
 
+./eng/formatting/format.sh
 ```
+
+Make sure the file is executable (`chmod +x .git/hooks/pre-commit`). If `git config core.hooksPath` points elsewhere, set it with `git config core.hooksPath .git/hooks`.

docs/coding-guidelines/code-formatting-tools.md

@@ -34,7 +34,7 @@ internal static partial class Interop
 ...
 internal static partial class Interop
 {
-    internal static partial class mincore { ... }
+    internal static partial class Mincore { ... }
 }
 ```
 - With few exceptions, the only methods that should be defined in these interop types are DllImports.
@@ -49,7 +49,9 @@ internal static partial class Interop
 ```
 \Common\src\Interop
     \Windows
-        \mincore
+        \Kernel32
+            ... interop files
+        \Mincore
             ... interop files
     \Unix
         \libc
@@ -71,8 +73,8 @@ As shown above, platforms may be additive, in that an assembly may use functiona
         \libc
             \Interop.strerror.cs
     \Windows
-        \mincore
-            \Interop.OutputDebugString.cs
+        \Mincore
+            \Interop.WaitOnAddress.cs    <-- Also contains WakeByAddressSingle
 ```
 
 - If structs/constants will be used on their own without an associated DllImport, or if they may be used with multiple DllImports not in the same file, they should be declared in a separate file.
@@ -81,9 +83,9 @@ As shown above, platforms may be additive, in that an assembly may use functiona
 ```
 \Common\src\Interop
     \Windows
-        \mincore
-            \Interop.DuplicateHandle_SafeTokenHandle.cs
-            \Interop.DuplicateHandle_IntPtr.cs
+        \Kernel32
+            \Interop.DuplicateHandle_SafeFileHandle.cs
+            \Interop.DuplicateHandle_SafePipeHandle.cs
 ```
 
 - The library names used per-platform are stored in internal constants in the Interop class in a private Libraries class in a per-platform file named Interop.Libraries.cs. These constants are then used for all DllImports to that library, rather than having the string duplicated each time, e.g.
@@ -94,12 +96,9 @@ internal static partial class Interop // contents of Common\src\Interop\Windows\
     private static class Libraries
     {
         internal const string Kernel32 = "kernel32.dll";
+        internal const string OleAut32 = "oleaut32.dll";
         internal const string Localization = "api-ms-win-core-localization-l1-2-0.dll";
-        internal const string Handle = "api-ms-win-core-handle-l1-1-0.dll";
-        internal const string ProcessThreads = "api-ms-win-core-processthreads-l1-1-0.dll";
-        internal const string File = "api-ms-win-core-file-l1-1-0.dll";
-        internal const string NamedPipe = "api-ms-win-core-namedpipe-l1-1-0.dll";
-        internal const string IO = "api-ms-win-core-io-l1-1-0.dll";
+        internal const string Synch = "api-ms-win-core-synch-l1-2-0.dll";
         ...
     }
 }

docs/coding-guidelines/interop-guidelines.md

@@ -413,6 +413,36 @@ which encodes an extra 4-byte representing the end RVA of the unwind info blob.
 |      4 |    4 | Unwind info end RVA (1 plus RVA of last byte)
 |      8 |    4 | GC info start RVA
 
+### RUNTIME_FUNCTION (wasm, size = 8 bytes)
+
+On WebAssembly, the `RUNTIME_FUNCTION` uses a virtual IP as the `BeginAddress` rather than an RVA
+into the image. The high bit of the `BeginAddress` field indicates whether the entry represents a
+funclet (1) or a main method body (0). The remaining 31 bits encode the virtual IP of the start of
+the function or funclet.
+
+| Offset | Size | Value
+|-------:|-----:|:-----
+|      0 |    4 | Virtual IP (bits 30:0) | IsFunclet flag (bit 31)
+|      4 |    4 | UnwindData RVA (GC info follows immediately after the unwind blob)
+
+The table is terminated by a sentinel entry with all bits set (`0xFFFFFFFF`), followed by a 4-byte
+value containing the minimum WebAssembly function table index for the image.
+
+### UnwindInfo (wasm)
+
+On WebAssembly, the unwind info blob associated with each `RUNTIME_FUNCTION` entry is encoded as
+two consecutive ULEB128 values:
+
+| Order | Encoding | Value
+|------:|:---------|:-----
+|     1 | ULEB128  | Frame size in bytes (the number of bytes to unwind from the stack)
+|     2 | ULEB128  | Virtual IP count divided by 2 (the number of virtual IPs logically present in the function, halved)
+
+The virtual IP count (after multiplying by 2) gives the span of virtual IPs covered by this
+function or funclet. All virtual IPs are forced to even numbers so that the runtime can force all virtual
+ips to have odd numbers and fit into the address space in a manner which cannot conflict with either interpreter
+IPs or PortableEntryPoint structures.
+
 ## ReadyToRunSectionType.MethodDefEntryPoints
 
 This section contains a native format sparse array (see 4 Native Format) that maps methoddef rows to

docs/design/coreclr/botr/readytorun-format.md

@@ -130,6 +130,17 @@ public readonly struct GCOomData
     // describes a single segment with the inclusive start and exclusive end of its memory range
     // and its generation tag (or Ephemeral).
     IEnumerable<GCHeapSegmentInfo> EnumerateHeapSegments(GCHeapData heapData);
+
+    // Given the current probe address within a heap segment and the (aligned) size of the
+    // object that lives at that address, returns the next candidate object address.
+    // Implementations may consult cached per-target allocation-context state.
+    TargetPointer GetPotentialNextObjectAddress(
+        TargetPointer currentAddress,
+        ulong currentObjectSize,
+        GCHeapSegmentInfo segment);
+
+    // Aligns an object's raw size (base size + component bytes) to the alignment required by its containing segment
+    ulong AlignObjectSize(ulong size, GCSegmentClassification generation);
 ```
 
 ```csharp
@@ -306,12 +317,15 @@ Contracts used:
 | --- |
 | BuiltInCOM |
 | Object |
+| Thread |
 
 Constants used:
 | Name | Type | Purpose | Value |
 | --- | --- | --- | --- |
 | `WRK_HEAP_COUNT` | uint | The number of heaps in the `workstation` GC type | `1` |
 | `HEAP_SEGMENT_FLAGS_READONLY` | ulong | `HeapSegment.Flags` bit identifying a readonly (e.g. frozen, non-GC) segment. | `1` |
+| `ALIGNCONST` | uint | Alignment mask for small object heaps | Target pointer size - 1 |
+| `ALIGNCONST_LARGE` | uint | Alignment mask for large/pinned object heaps | `7` |
 
 ```csharp
 GCHeapType IGC.GetGCIdentifiers()
@@ -1129,3 +1143,49 @@ IEnumerable<(HeapSegment Segment, TargetPointer Address)> WalkSegmentList(Target
     }
 }
 ```
+
+GetPotentialNextObjectAddress
+
+Computes the next candidate object address when walking a Gen0/Ephemeral segment.
+Active allocation contexts (per-thread, the global non-thread-local context, and
+the per-heap Gen0 context) carve out reserved-but-not-yet-allocated ranges inside
+such segments; when the naive `current + size` lands on one of those ranges the
+walk must skip past it. The contexts are collected via `IThread.GetThreadStoreData`
+and `IThread.GetThreadData` (per-thread contexts), `IGC.GetGlobalAllocationContext`
+(global context), and `IGC.GetGCIdentifiers` + `IGC.GetGCHeaps` + `IGC.GetHeapData`
+(per-heap Gen0 contexts).
+
+```csharp
+TargetPointer IGC.GetPotentialNextObjectAddress(
+    TargetPointer currentAddress,
+    ulong currentObjectSize,
+    GCHeapSegmentInfo segment)
+{
+    TargetPointer next = new TargetPointer(currentAddress.Value + currentObjectSize);
+
+    if (segment.Generation is not (GCSegmentClassification.Gen0 or GCSegmentClassification.Ephemeral))
+        return next;
+
+    ulong minObjSize = AlignForSmallObject((ulong)_target.PointerSize * 3);
+    foreach (/* context in allocation contexts */ )
+    {
+        if (next == /* context pointer */)
+            return new TargetPointer(/* context limit */ + minObjSize);
+    }
+    return next;
+}
+```
+
+AlignObjectSize
+
+Aligns a raw object size to the alignment required by its containing segment. SOH segments
+use pointer-sized alignment; LOH/POH use 8-byte alignment.
+
+```csharp
+ulong IGC.AlignObjectSize(ulong size, GCSegmentClassification generation)
+{
+    return generation is GCSegmentClassification.LOH or GCSegmentClassification.POH
+        ? AlignForLargeObject(size)     // (size + ALIGNCONST_LARGE) & ~ALIGNCONST_LARGE
+        : AlignForSmallObject(size);    // (size + ALIGNCONST) & ~ALIGNCONST
+}
+```