[libc++] Switch the enable_warnings Lit parameter to enable_werror (#214113)
Our enable_warnings=False parameter in the test suite was basically not
working as intended. Instead of disabling warnings, it would disable all
warning-related flags, including flags that are required for the test
suite to pass (e.g. -Wno-user-defined-literals). As a result, it
couldn't be turned off.
Remove enable_warnings and introduce enable_werror instead. That way, we
can disable -Werror in the test suite but the warnings (and -Wno-foo)
are always used, which is necessary for the test suite to function.
Note that the ability to run the test suite without -Werror is necessary
in order to test against other implementations, including older versions
of libc++ itself.
[SSAF] Close unsafe-buffer reachability over override families
An unsafe pointer reaching one override's parameter is equally unsafe in every
sibling and base override of that method, because the call site picks the
target dynamically. Without closing over the families, reachability depended
on which override the extractor happened to see the flow through, so a fix
suggested for the base could be contradicted by a derived override.
Mirroring is level-preserving: families relate slot entities, so a reachable
EPL propagates only to the same pointer level on its family members.
The closure runs after the pointer-flow DFS has converged and does not feed
its own output back in, so a flow edge out of a newly discovered EPL is still
missed. FamilyClosureDoesNotRerunDFS pins that gap.
§4 of rdar://179151603
[SSAF] Serialize virtual method summaries and families
Per-TU summaries and whole-program results cross process boundaries, and the
JSON layer refuses to write a summary kind it has no format for. Register both
sides so --ssaf-extract-summaries=VirtualMethod becomes usable and the family
result survives a round trip.
Deserialization tolerates a missing override list, since a root virtual method
legitimately has none.
§3 of rdar://179151603
[SSAF] Group virtual method slots into override families
A virtual call site can dispatch to any override, so the parameter and return
slots that occupy the same vtable slot across an override chain are
indistinguishable to a caller. Whole-program consumers therefore have to treat
them as one unit or they will reason about a slot that a call never actually
reaches.
Compute those units up front, keyed per slot, so consumers only need a map
lookup rather than their own traversal of the override relation. Overloads
occupy distinct vtable slots and stay in distinct families.
The family representative is the smallest EntityId in the class, which keeps
the result stable across runs.
§2 of rdar://179151603
[SSAF] Extract the virtual method override relation per TU
A virtual call may dispatch to any override of its callee, so a whole-program
analysis cannot reason about a method's parameters and return value in
isolation. It needs to know which method overrides which, and which slots
that relates. Collect this per TU, so a later pass can join the related
slots into families.
JSON serialization lands separately, so the summary is not writable via
--ssaf-extract-summaries yet.
§1 of rdar://179151603
tmp - Test that three-level chain records only direct override edges
`overridden_methods()` is not transitive. This means that it describes
the directly overridden methods - which is usually a single method
(unless it overrides the same function from multiple parents).
This test case demonstrates that A::f overrides B::f which overrides C::f.
And that it's not that A::f overrides C::f without overriding B::f first.
Assisted-By: claude
Services: Kea DHCPv6: improve kea_prefix_watcher.py accuracy via both interface and mac address key(#10685)
Resolve the lease subnet-id to its configured interface and key Hostwatch or
NDP lookups by interface and MAC.
Hostwatch or NDP may report the same MAC on multiple interfaces, for example
on a bridge and its member. Previously the last matching MAC entry could
select the wrong interface and cause route installation to fail.
The link-local address and scope still come from Hostwatch or NDP. Multiple
LLAs for the same interface/MAC remain last-match-wins, as any observed LLA for
an interface/MAC key should be an eligible next hop target.
[lldb][Windows] Fix value API tests (#214237)
This removes the XFAILs for the value API tests.
- For `lldb/test/API/python_api/value/TestValueAPI.py`, we need to pass
`/debug:symtab` to the linker to get a symbol table. Symbols are
"hidden" by default. PDB works around this in the publics stream. For
DWARF, we need `/debug:symtab`. An alternative is to use `/debug:dwarf`
which also enables this.
- For
`lldb/test/API/python_api/value/change_values/TestChangeValueAPI.py`
there were two issues. First, the stdout wasn't available when we
stopped at a breakpoint. Adding a `fflush(stdout)` fixes this.
Secondly, the breakpoint was created where the inputs to `printf` were
already evaluated. I added another assignment where we set the
breakpoint.
The added `fflush` might also help with this being flakey on Linux
(#26026).
Closes #25146
[LLVM][CodeGen][AArch64] Increase opportunities to fold shift-of-extend into sshll/ushll. (#213989)
Add PreprocessISelDAG logic to undo mul-of-shl to shl-of-mul
canonicalisation when either operand is sign/zero extended because the
extension can be folded into the shift.
Reconcile license derived config when the license changes
This commit adds changes to converge every subsystem whose configuration is derived from the license once that license changes. `truenas.license.upload` regenerated exactly one etc group and then fired `system.post_license_update` detached. That was survivable while gates asked `is_enterprise`, which expanded to `is_ha_capable OR (licence AND model AND not freenas)` -- on appliance hardware the first limb was already true before any license was installed, so those gates did not change their answer when one arrived and never re-rendering them cost nothing. Now that they are feature key checks they do change their answer, and ten etc groups were left silently stale until something unrelated regenerated them or the box rebooted. The plainest case is sudoers, where sudo command auditing simply did not turn on when an appliance was licensed.
Each affected subsystem now registers a LicenseReconcileDelegate from its own setup, naming the etc groups it owns and what should happen once they have been re-rendered, and a runner walks them on the hook. Doing this per plugin rather than centrally in etc matters because the right action genuinely differs between them: the block target delegates render without touching a live target and skip entirely when their service is stopped, keepalived reloads rather than restarts because its restart advertises priority 0 and forces a MASTER to BACKUP transition, and ctdb keeps the restart it has always had. Registration refuses a duplicate name or a group another delegate already claims, so two plugins cannot quietly both own one.
The upload now blocks on the hook rather than firing it detached, so it returns only once config has converged. The runner declines to do anything at all when the license reads as absent, because an unreachable license daemon is indistinguishable from an unlicensed system and re-rendering ten groups toward unlicensed over a transient socket failure would be far worse than leaving them alone -- one of them deletes its config file outright, and that file decides whether ctdb starts. failover.status is dropped from its cache ahead of the pass since half the groups read it while rendering, and truesearch moves off the blocking path because it waits on a service job.
A guard test maps direct license reads in etc_files and utils back to the group that owns them and fails when no delegate claims it. It can only see direct reads, so it is paired with an inventory carrying a written reason per group for the ones that reach the license indirectly through a ctx method.
[SelectionDAG] Fold constant PARTIAL_REDUCE_SMLA/UMLA/SUMLA nodes (#210351)
This PR implements constant folding for `ISD::PARTIAL_REDUCE_SMLA`,
`ISD::PARTIAL_REDUCE_UMLA`, and `ISD::PARTIAL_REDUCE_SUMLA` when their
operands are constant `BUILD_VECTOR`s. The fold computes the partial
reduction using `APInt` arithmetic and returns a folded `BUILD_VECTOR`.
Input constants are truncated to their logical element width before
being sign- or zero-extended as required by each opcode. Input lane `I`
is accumulated into result lane `I % NumAccElts`, matching
`TargetLowering::expandPartialReduceMLA`. The reduction order is
deliberately unspecified, so this mapping is a valid refinement.
Poison is propagated only to the affected result lanes. Folding is
skipped for undef and opaque constants. Unsupported operand forms return
early because partial-reduce nodes have no scalar form and must not fall
through to generic per-element folding. After type legalization, when
the accumulator element type is not a legal scalar type, the folded
constants are created in the promoted legal type (matching the generic
[13 lines not shown]
[clang-tidy][docs] Normalize fuchsia check documentation links (#214697)
Use stable fuchsia.dev URLs without `?hl=en` and add the missing
reference on `fuchsia-temporary-objects`.
Fixes #62334
