Repository navigation
Description
Successor to #317, which closed once its collected nits were shipped. These three came out of the same review pass but are not nits — two need measurement we cannot currently perform, and one needs research rather than a fix.
As with #317: these are ours, not up for grabs. They come out of reviewing contributions, so it is on us to close them.
1. ARM64 PE exception-directory seeding over-reports on MSVC-built images
USE_PE_ARM64_PDATA_CANDIDATES is on by default, and #312 (d111548) documented — honestly, and at our request — that it over-reports on images MSVC built.
An MSVC ARM64 build gives a separated chunk of a routine its own RUNTIME_FUNCTION record, and the chunk sets up its own frame, so the entry-shape filter reads it as an entry. On ping/robocopy/bcrypt that is 78 seeded starts sitting inside a function IDA labels, 73 of them beginning exactly where another record's extent ends with nothing referencing them. Microsoft's own public PDBs name 88.5% of the addresses IDA calls functions but only 6.4% of those 78, so they are chunks rather than entries.
What makes this an open problem rather than a one-line fix:
- Refusing them by that shape costs 13 addresses the PDBs do name.
- The obvious exact test does not reach. The parent's
.xdatahandler data names its exception funclets, but only 25 of the 145 chunks have a parent carrying any; the other 120 continue a record with the X bit clear or no.xdataat all, so they are not exception funclets and nothing in the unwind data distinguishes them. - clang/llvm-mingw emits one record per function symbol and does not split them, so a from-source ARM64 PE is unaffected either way — which is also why this is invisible on anything we build ourselves.
So the default is defensible but knowingly imprecise on exactly the images most likely to be analysed. Worth either finding a discriminator or deciding the trade explicitly.
2. Two shipped figures that no bundled fixture can verify
Both went into the v4.5.1 entry marked as the contributor's own rather than reproduced, which is the honest framing but not a permanent answer.
| figure | why it cannot be checked here |
|---|---|
#310's bti j 803 false / 0 true split against bti c's 505/0 |
no bundled fixture contains a single bti j word, and every bundled AArch64 fixture is bit-identical across that change |
| #312's ARM64 PE interior-gap result | no bundled fixture is an ARM64 PE. Scanning all 104 fixture files for a PE machine field: 8 × i386, 4 × AMD64, 1 × 0xFD1D (the ReadyToRun image), 0 × 0xAA64 |
Both mechanisms were verified directly — the BTI encodings against capstone, and #312's extent reconstruction against hand-computed spec values including the packed 11-bit and .xdata 18-bit mask boundaries — so this is about magnitudes, not correctness.
Two ways forward, not exclusive:
- Bundle fixtures that reach these paths. A small ARM64 PE, and an AArch64 binary built with BTI. This is the durable fix: it makes the paths regression-testable rather than only reviewable.
- Use the corpus benchmark. refactor(common): type the attributes the dropped annotations rest on #320 confirmed the Malpedia benchmark does run on a same-repo branch (155 files, 175,946 functions), so the mechanism works. Open question is whether that corpus holds any ARM64 PE or BTI-carrying sample; if it does not, the first option is the only one.
3. The AArch64 interior-gap hook logs nothing where its intel twin logs the refused address
intel/FunctionCandidateManager emits a LOGGER.debug naming the address it refuses inside a declared .pdata extent. The AArch64 hook added by #312 does not — consistent with its own file, which has no logging anywhere in that loop, so this is not an omission in the diff.
Recording it because the two paths are now deliberately identical in every other respect, and the first ARM64 PE that suppresses something surprising will be harder to explain than the x64 equivalent. Fixing it properly probably means giving the AArch64 gap loop the same debug coverage its intel counterpart has, rather than one line.
Activity
danielplohmann commentedon Sep 8, 2026
4. The corpus benchmark's timing verdict is dominated by cross-runner variance
Relevant to item 2 above, since that item proposes using this benchmark to settle figures the fixtures cannot.
Its correctness half is trustworthy and did real work today: #320 and #321 each came back "0 of 155 common files differ" over 175,946 functions, which is a much stronger behaviour-neutrality statement than the bundled fixtures can make.
Its timing half, on the same two PRs, reported:
Both PRs are behaviour-neutral typing changes with no meaningful runtime component.
extract_stringscannot make a corpus 14.78% faster. So a tight confidence interval and evenp = 0.0000are not evidence of a real difference here, because base and PR are timed on separate runners and the between-runner spread swamps the within-runner one — #320's own diagnostic matrix spanned −17.21% to +1.20% across individual run pairings.The noise band does its job on #320 and fails on #321, where a 14.78% runner difference sails past a ±3.8% band and gets rendered as a verdict. Worth either pinning both sides to one runner, or widening the band to reflect between-runner variance rather than the within-runner CV it currently derives from. Until then, a "PR is faster" from this gate should not be quoted in a release entry.
danielplohmann commentedon Sep 10, 2026
Two more for this list, both from reviewing #300 (merged as
50d3289) and both ours for the same reason as the three above: they are about how durable our own paths are, not about anything wrong in that branch. #325 carries the three findings from the same pass that were corrections to what #300 shipped.5. The interior-prologue refusal depends on the order two pattern lists are scanned in
intel/FunctionCandidateManager._opensInsideAnEarlierProloguerefuses a seeded prologue match that begins exactly where an earlier one ends. The "already a candidate" condition is what keeps it off byte coincidences, and it is also what makes the rule order-dependent: the earlier match has to have been seeded already, andlocatePrologueCandidatesscansDEFAULT_PROLOGUESbeforeDEFAULT_PROLOGUES_64.The clang case the rule was written for is in the favourable order —
push rbp; mov rbp, rsp(554889e5, inDEFAULT_PROLOGUES) thenpush r15; push r14(41574156, inDEFAULT_PROLOGUES_64). Measured on the branch, through the PR's ownseededStartsstub:push rbp; mov rbp, rspthenpush r15; push r14push r15; push r14thenpush rbp; mov rbp, rspNothing says the order has to stay that way — not a comment, not a test. Reordering the two lists for any unrelated reason would silently turn off most of what the rule measured (912 false positives removed, 0 true positives lost).
Whether the reverse layout occurs in practice is a separate question and I have not measured it;
push rbp; mov rbp, rspis a frame setup rather than a callee-saved push, so it is unlikely to follow a callee-saved run. That makes this a robustness item rather than a recall item. The fix is probably a test that pins the ordering invariant, or making_seeded_prologuesaccumulate in a way that does not care.6. One read path in the LSDA decoder is not charged to its budget
MAX_LSDA_TABLE_BYTESbounds the call-site table bytes decoded across a section, and_fdeLandingPadschecks it before callingread_va— the comment there says "the budget gates the read as well as the decode". It gates the read only once the budget has already been spent by successful decodes._decodeLsdaLandingPadsdecrements it where it parses the table length, so an LSDA that fails before that point (an unsupported LPStart application mode, a short buffer, a TType offset that will not read) costs aread_vaof up toMAX_LSDA_BYTESand charges nothing.So a section naming
MAX_RECORDSdistinct LSDA pointers that all fail early performs 199,999 reads of up to 64 KB. Measured:getBytesslicingBounded, and nothing like the 155s shape the memoisation fixed, so this is a comment that overstates what the code does plus about a second of avoidable work on a section built to be hostile. Charging the read at the point it happens, rather than only the table it might have led to, is the whole fix.
r0ny123 commentedon Sep 10, 2026
Status on four of the six, with measurements where I have them. Nothing here touches items 1 and 2.
4 — resolved by #300
perf_benchmark.ymlandevaluate_runtime.pywere rewritten in50d3289to time both sides in the same job on the same runner, interleaved base/PR/PR/base/base/PR, which is the cross-runner variance this item was about.It works on the first case that exercised it. #325 is a comments-and-one-expression change and the verdict came back inconclusive — within run-to-run noise (±3.8%), median +0.19% with CI [−0.78%, +0.82%] and Wilcoxon p = 0.72 — against #321's +14.78% "PR is faster" for a change of the same character. Strikeable as far as I can tell.
5 — #326
The scan order is pinned there, and one thing worth correcting from the write-up: it said the order is held by "not a comment, not a test". The comment half is right; the test half is not. The behavioural cases in
testInteriorPrologueSuppressionalready fail on both reorder shapes — 2 failures when the two family scans swap, 2 when a single pattern crosses the family boundary. What they lack is legibility: they fail asAssertionError: 4194324 unexpectedly found, which names an address rather than an invariant and invites being quieted by editing the expected set.Sweeping the class also turned up a second site the item did not name. The hotpatch adjustment four lines below carries the same dependency, but within
DEFAULT_PROLOGUES—\x55\x8b\xechas to be scanned after\x8b\xff\x55\x8b\xec. A test pinning only the family order leaves it uncovered, so #326 states the containment relation over the pattern lists instead of over the pair that exists today.6 — the one-line description does not survive contact with the corpus
The diagnosis is exactly right: a read of up to
MAX_LSDA_BYTEShappens before anything is charged, so an LSDA failing early is free. But "charge the read at the point it happens" cannot mean charging it toMAX_LSDA_TABLE_BYTES, and the reason is thatread_va(lsda_va, MAX_LSDA_BYTES)almost always returns the full 64 KB — the section is larger than the request, so the length of the read says nothing about the size of the table behind it.Measured on master, instrumenting the reads:
googletest_gcc-arm64_O2-statictinyxml2_gcc-arm64_O2-staticsqlite3_gcc-arm64_O2-staticThe budget is 8 MB. Charging reads against it exhausts it after roughly 128 of googletest's 1,133 reads, on an ordinary C++ binary, and every LSDA after that reads as "declares nothing" — a recall loss on exactly the images the rule exists for. The comment that says the budget "counts what is decoded rather than what is read" is not a wording slip; it is the reason the current bound works at all, since real tables decode ~26 KB where their reads return ~70 MB.
Charging only the failures does not rescue it either. Failures are not rare on real images: googletest has 100 of 1,133 and tinyxml2 24 of 128, so that variant charges googletest 6.4 MB of its 8 MB budget and still lands in the same place.
So the fix wants a second bound on reads, separate from the table-bytes budget, rather than a change to how the existing one is charged. Sizing it is the part that is yours: the heaviest real image measured here is 1,133 reads / 70.8 MB, and the hostile shape is
MAX_RECORDSdistinct pointers, so anything in the low tens of MB caps the pathological case while leaving an order of magnitude over anything real. I did not pick a number because it is a corpus judgement rather than a code one.3 — happy to take it if you want it
The AArch64 gap loop having no debug coverage where its intel twin names the refused address is a small, self-contained change and I have the ARM64 PE corpus locally to exercise it.
Noting the "these are ours, not up for grabs" line, so this is an offer rather than a PR: say the word and it is done, otherwise it is yours. Same for the read bound in 6 once you have picked the number.
r0ny123 commentedon Sep 10, 2026
1 — I went looking for the discriminator and found the trap instead
Reproduced the baseline first: seeding on the three MSVC system images books 700 addresses, 78 of which IDA does not label (bcrypt 4, ping 3, robocopy 71), which is your 78 exactly.
Then searched conjunctions of four features over that population — whether the previous word ends a function, whether the address begins exactly where another record's extent ends, 16-byte alignment, and whether anything the analysis recovered references it.
The best predicate found looked very good:
abutsANDnot aligned16ANDnot referencedabuts(your shape, alone)not prev_ends51 of 78 for two real functions, against the 13 the shape test costs. It is not real.
The per-binary split gives it away before any holdout does. All 51 removals are in
robocopy.exe;bcrypt.dllgets 0 removed and both losses;ping.exegets nothing. A rule whose entire effect lives in one of three binaries is a layout artefact.On the held-out .NET ARM64 corpus it inverts completely. Thirteen MSVC-built images with private-PDB extents, scored on the six with
.pdb.offsets:Zero of the thing it is for, and it destroys a quarter of the truth.
hostfxr.dllandhostpolicy.dllalone lose 601 between them.The reason is written down in that corpus's own README, and I walked into it anyway: those images pack functions back to back where the three system binaries pad between them, so any rule reading the gap between adjacent functions — which
abutsandaligned16both do — behaves in opposite directions on the two populations. It notes a PR was already built and validated on the padded three alone and cost exactly this.Which I think means the item's premise has already been settled
That corpus is described as the one that closed #167, with the argument that leaves nothing for a shape-based rule to find: the entry-shape gate in
locatePeExceptionCandidatesalready refuses 2,829 of 3,473 chunks (81.5%), and of the 644 that survive into seeding, 643 open with a genuine routine shape — a recognised prologue, a BTI pad, a single-registerstr Xt, [sp, #-imm]!, or a baresub sp, sp, #imm. MSVC gives a separated chunk its own frame setup, so what survives is byte-for-byte what an entry looks like, and the remainder is 643-to-1 against shape.So the two ways forward this item offers are not symmetric. "Find a discriminator" has been measured to the end on shape and on the gap family; what is left is deciding the trade explicitly, which is yours. On the evidence the current default is the right one: it over-reports 78 addresses on three padded system binaries, and every attempt to refuse them either costs more than it saves on those same binaries or reverses sign on packed ones.
If it is worth recording that verdict in the code rather than in an issue, the
USE_PE_ARM64_PDATA_CANDIDATEScomment is where it belongs, and I am happy to write it — the 81.5% / 643-of-644 / 0-and-712 figures are the three that make the case. Say the word.2 — the
bti jrow moved, and is now closed by #331Since this was filed, #300 bundled
elf_cxx_landing_pads_arm64_xored, which carries fivebti jwords, and they do reach_isLikelyInteriorBtiCandidate. So "no bundled fixture contains a singlebti jword" is no longer true."Every bundled AArch64 fixture is bit-identical across that change" still is, and now for a specific reason: all five sit inside exception landing pads, where the shape test refuses them on its own account and #300's LSDA rule refuses them earlier still. The flag decides nothing there, so a BTI-built binary would not have closed this row either — a compiler emits
bti jat landing pads and jump-table cases, and on anything carrying unwind data the landing pads are already refused before this rule is consulted.#331 builds the one arrangement in which the flag decides by itself — a
bti jafter alignment padding, opening an entry-shaped block, in a buffer declaring no landing pads — and pins it withbti c,bti jcand barebtias controls. The mechanism is now regression-testable in-repo; the corpus magnitude still is not, and that PR does not claim otherwise.The ARM64 PE row of item 2 I would strike as already done:
testAArch64PdataExtraction.pydrivesUSE_PE_ARM64_PDATA_INTERIOR_GAPSend to end through a syntheticmachine=0xAA64image, so #312's path is regression-tested even though no file intests/is an ARM64 PE.3 — #330
The AArch64 gap loop now records why it refused an address, using the intel wording wherever the path is the same one. One path is deliberately left silent and the PR says which and why.
r0ny123 commentedon Sep 10, 2026
Item 2, both magnitude rows, measured on current master
#310's
bti jsplit — reproduces, and survives a wider populationThe claim: over 1,308 prologue-sole bookings on 72 built AArch64 ELF cells the split is exact rather than statistical,
bti jaccounting for 803 false positives and no true ones againstbti c's 505 true and none false.Re-run on
e9dfe5f, with the rule off, classifying every recovered function whose entry word is a BTI form rather than only the prologue-sole subset:btibti cbti jbti jc3,346 addresses against the original 1,308, and the separation is still perfect in both directions. That is the part of the claim worth having: a statistical rule leaks when you widen the population by 2.5x, and this does not.
The headline number attached to it has gone stale, and it is worth knowing why
Same 72 cells, flag off → on:
745 false positives removed, 0 true positives lost. The entry says 87.596 to 89.186 … and 2,941 false positives removed.
Not a contradiction: that figure was measured on the tree of the day, and I cannot reconstruct that baseline. What it shows is that most of what this rule used to remove is now removed before it — #300's interior-gap family and the rules around it reach many of the same addresses — so its marginal value today is 745 rather than 2,941, on a baseline whose PPV starts 6.5 points higher.
Recall unchanged reproduces exactly, which is the half the rule was defended on.
#312's row has nothing to reproduce — so I measured it
The PR body says it "closes it against a set that does contain them" and never states a number; neither do its comments, the changelog entry, or the config comment. So this is not an unverified magnitude, it is a missing one. Supplying it, flag off → on:
It loses nothing on either and gains eleven functions on the compiler-truth corpus, for the reason the x64 entry already gives: a booked interior address does not merely add a false positive, it starts an analysis that runs past the end of the routine it sits in and swallows what follows.
Where that leaves item 2
Both mechanisms are now regression-testable in-repo — #331 for the
bti jsplit, andtestAArch64PdataExtraction.pyalready drives the ARM64 PE interior-gap rule end to end through a syntheticmachine=0xAA64image. Neither magnitude is reproducible from anything bundled, and I do not think either needs to be: what the fixtures owe is that the mechanism cannot silently stop working, and that is now covered on both.If the entries are worth correcting rather than leaving as measured-at-the-time, the
USE_AARCH64_BTI_TARGET_TYPEcomment is the one that would benefit — its 803/505 and 2,941 are all from a tree that no longer exists, and the split is the durable part. Happy to write that as a follow-up to #332 if you want it.r0ny123 commentedon Sep 10, 2026
Correction to my last comment, before anyone acts on it.
I wrote that the
USE_AARCH64_BTI_TARGET_TYPEcomment's "803/505 and 2,941 are all from a tree that no longer exists" and offered to rewrite it. The 803/505 half is wrong — those reproduce. I had measured a wider population than the comment describes and then reasoned about the comment as if my number were the comparable one.Re-run with the comment's own methodology, prologue-sole bookings attributed by entry word, on
e9dfe5f:btibti cbti jbti jcWithin 6 and 2 of the published figures, with the exactness intact in both directions. The drift is later rules changing which candidates end up prologue-sole at all, not the split moving.
So the config comment needs no correction and there is no follow-up PR to write for it. What is stale is the changelog entry's
87.596 → 89.186and2,941 false positives removed, which are marginal-value figures against a baseline that has since risen 6.5 points — today the same toggle is worth 745 removed at 94.107 → 94.947, recall unchanged either way.Which is the more useful reading of this whole row: the split is a property of the instruction encoding and does not decay, while an absolute false-positive count is a property of everything else in the engine on the day it was taken. The first belonged in the config comment and is still true there; the second belonged in a release entry and is now history rather than fact. Worth keeping in mind for the depth convention in #323 — a measured claim probably wants to say which of the two kinds it is.
r0ny123 commentedon Sep 10, 2026
Item 1 — the last untried avenue, and it is also negative
Every attempt on this so far has read either instruction shape or the space between adjacent functions. Nothing had read what the unwinder itself stores. Doing that on the .NET corpus, over the 3,331 records seeding actually books:
Two clean results, one of them confirming existing behaviour:
.xdatarecords seededPacked records being never-chunks reproduces independently on the seeded population, so continuing to seed them is right.
And a perfect necessary condition that is not a sufficient one. Every single one of the 305 false positives has
E = 0andEpilogCount = 1:EEpilogCountXCodeWordsRefusing on it costs 670 real functions to remove 305 false ones. Searching every conjunction of up to three of these fields, the best available trade is:
X=0 AND EpilogCount=1 AND CodeWords=4X=0 AND EpilogCount=1 AND CodeWords=2X=0 AND CodeWords=3About two false positives per real function lost, on a population that is 87% real. That is not a discriminator, it is a slightly favourable coin.
So the three families are now all measured to the end: shape (643 of 644 survivors are genuine entry shapes), adjacency (looks like 51-for-2 on the padded three, is 0-for-712 on the packed images), and unwind fields (perfect necessary condition, best sufficient one is 2:1). #332 records the verdict in the config comment; I do not think there is a fourth avenue worth the reader's time, and I would close item 1 on that basis.
Item 2 — the ARM64 PE row, closed properly in #333
Rather than leave that row resting on a synthesised image, #333 bundles a real
0xAA64PE. It is the from-source probe —aarch64-w64-mingw32-clang++ -O2 -g -gdwarf-4 probe.cpp, llvm-mingw 20250430 — so it is redistributable and rebuildable, unlike the system binaries.It is also a control: clang emits one
.pdatarecord per named function and splits none, so the MSVC over-seeding of item 1 does not occur in it, and the eight addresses it refuses are refused on extent evidence alone. They are listed individually rather than counted, so refusing a different eight fails rather than staying green.200K XORed, against 1.1M for the largest fixture already carried.
With that, both rows of item 2 have their mechanism pinned in-repo — #331 for
bti j, #333 for the ARM64 PE — and both magnitudes are measured and posted above. Neither magnitude is reproducible from bundled data and I do not think either needs to be.r0ny123 commentedon Sep 10, 2026
Item 6 — #335
Taking this back after saying I would leave it until you picked the number: the measurements turned it into a yes/no rather than a design task, so it seemed more useful to hand you one.
The diagnosis is right and the described fix is not available. A section naming
MAX_RECORDSdistinct pointers that fail before their table's length field performs 199,999 reads handing back 12.2 GB, spending none of its budget. But charging those toMAX_LSDA_TABLE_BYTEScannot work:read_vais asked forMAX_LSDA_BYTESand returns whatever the section holds, so a real image asks for far more than it decodes —googletest_gcc-x64_O2-staticreads 92.1 MB to decode about 26 KB of tables. The 8 MB budget would be gone within ~128 of its 1,473 reads, and every LSDA after that would read as "declares nothing".Only the failures separate the two populations:
#335 bounds those at 256 MB — 8.6× over the heaviest real image, 48× down on the hostile one. All 447 cells across the six corpora come out bit-identical. 256 MB is a proposal, not a finding; any cap between 29.75 MB and 12.2 GB works and changing the constant moves nothing else.
One detail that cost me a measurement. The failure has to come before the table's length field to reach the gap at all — one that fails after it is already charged. My first hostile section used a too-long length field, which parses, charges 16,383 bytes, and is therefore capped by the existing budget at 512 reads. I measured that, saw 512 rather than 200,000, and briefly concluded the issue overstated the problem. It does not; I had built the wrong shape. The one that reaches it is an unsupported LPStart application mode, which charges nothing.
That is all six items. For the record: 1 measured to exhaustion across three discriminator families and the verdict written into the config comment (#332); 2 both mechanisms pinned in-repo (#331, #333) and both magnitudes measured and posted above; 3 #330; 4 already resolved by #300's benchmark rewrite; 5 #326; 6 #335.
Every one of them is offered rather than assumed, given the note at the top of this issue — close any you would rather take yourself.
test(tests): pin the bti j split that no bundled binary can show (#331)
danielplohmann commentedon Sep 11, 2026
Five of the six are closed. Merged in this order, each squashed onto
db132bb(v4.6.0):3574c00f6eb1b3bti jrow018a69c50a818aa043145Item 1 closes on the verdict, not on a discriminator. Three families measured to the end — shape (643 of 644 survivors are genuine entry shapes), adjacency (51-for-2 on the padded three, 0-for-712 on the packed .NET images), unwind fields (a perfect necessary condition whose best sufficient form is 2:1) — and the trade is now recorded next to the option. That is the right resolution for an item filed as "find a discriminator or decide the trade explicitly".
Item 2 closes on mechanism rather than magnitude, which is what I asked the fixtures for: #331 builds the one arrangement where
USE_AARCH64_BTI_TARGET_TYPEdecides by itself, and #333 bundles a real0xAA64PE where before there was none. Both magnitudes are measured and posted above and neither is reproducible from bundled data; I agree that is where it should rest. Thebti jsplit reproducing within 6 and 2 of the published figures under the comment's own methodology is the part that matters, since that is the durable half.Item 4 struck as resolved by #300.
perf_benchmark.ymlnow times both arms in one job on one runner, interleaved, and #325 is the demonstration: +0.19%, CI [−0.78%, +0.82%], p = 0.72, rendered inconclusive — for a change of exactly the character that got "PR is faster" out of the old gate.Item 6 is the only one open, and #335 carries it. Reviewing that next along with #327 and #329.
Verified locally before merging, on the five stacked onto v4.6.0 master: 2,109 passed, 2 skipped, 2,596 subtests,
ruff checkandruff format --checkclean, andtyreporting 272 diagnostics — identical to master's own baseline, so none of the five adds one. The 15 new tests cost 2.3s between them.danielplohmann commentedon Sep 11, 2026
Status after the keep-a-changelog rollout landed.
d58e96e(#336) and857081f(#337) are both on master, in that order, which closes #323 — all ten points settled, the CI check in place,## [Unreleased]open and empty, and theno-changeloglabel live.That leaves item 6 and the three engine PRs, which are now unblocked in the way the sequencing intended:
7cad9ff; both reviewed and accepted.Each of the three touches
src/smda/and none touchesCHANGELOG.mdyet, so the new check will ask for an entry on the next push. That is the demonstration rather than an obstacle. @r0ny123 — please write the three entries as you offered; each carries a caveat only you can phrase, and per the provenance rule just agreed, #327's -683/-77 and #329's -47 want marking as measured on your corpora and not reproduced here. They are v4.7.0's content either way.The check is reporting but not required in branch protection yet. Letting it run on a few real PRs first before making it a gate.
danielplohmann commentedon Sep 11, 2026
Queue state after this afternoon, since master moved twice under the three open PRs.
Master is now
0a0a4c6— #339 landed, closing #338, the gap-scan resume defect found while verifying #247. #247 is closed too, verified independently against current master.All three of #327, #329 and #335 now conflict. The
Unreleasedentries are written and read well, so nothing is owed there; this is just a rebase.CHANGELOG.mdonlyCHANGELOG.mdonlyCHANGELOG.md,src/smda/intel/FunctionCandidateManager.pynextGapCandidate(_pdataInteriorRefusalEnabledand_failedGapResumeTarget), plus module constants. Keep both; there is no interaction between them.The
CHANGELOG.mdconflict is structural, not bad luck. Every PR now edits the same few lines of oneUnreleasedsubsection, so any two open at once collide, and each merge re-conflicts the rest. That is the cost of the format working as intended — the entry is written while the author remembers the caveat — and it is worth knowing it will happen on every parallel PR from here rather than being surprised by it each time.If it becomes a nuisance rather than a rebase,
CHANGELOG.md merge=unionin a.gitattributesmakes git take both sides instead of conflicting. I have not added it: union merging concatenates in whatever order it likes, which is wrong for a file where entries sit under specific subsections, and it would need checking against GitHub's own merge rather than just a local rebase. Raising it as an option, not a recommendation.Item 6 stays open with #335 until it lands.
danielplohmann commentedon Sep 11, 2026
All six items are closed.
3574c00(#332),f6eb1b3(#326),018a69c(#331),50a818a(#333),a043145(#330)130fa02(#335), merged this afternoon#323 is closed too, and the format it settled is now carrying real content — the
Unreleasedsection holds four entries written by their own authors at merge time rather than reconstructed afterwards, which was the whole argument.Closing. What is left before v4.7.0 is #327 and #329, tracked on their own PRs and on #324 and #328.
docs(docs): track release scope in a milestone named for the tag (#341)