[libc++] Move _LIBCPP_GET_C_LOCALE to the locale base API (#222924)
How to retrieve the C locale is fundamentally a property of the
underlying libc, so it should really be part of the locale base API.
[libc++] Fix performance regression in std::num_put (#223334)
`__pad_and_output` calls `std::copy` and `std::fill_n` unconditionally,
even though the calls are quite likely to do nothing. Adding conditions
also allows the compiler to do jump-threading.
Fixes #178685
unittests: Compute DataLayout from the triple, not the TargetMachine
Eventually createDataLayout should be removed, so migrate these uses.
Co-authored-by: Claude (Claude-Opus-4.8) <noreply at anthropic.com>
[NVPTX] Add support for f32x2 mixed-precision add/sub (#221957)
This change adds support for mixed precision addition and
subtraction of `f16x2` and `bf16x2` with `f32x2`, where the
following upconverting patterns:
```
%e = fpext <2 x half> %h to <2 x float>
%res = fp-operation(%e, ...)
...
%e = fpext <2 x bfloat> %b to <2 x float>
%res = fp-operation(%e, ...)
where the fp-operation can be any of:
- fadd
- fsub
- llvm.nvvm.fadd.v2f32
```
are lowered to `add/sub.{rnd}.f32x2.{f16x2/bf16x2}.f32x2`, and the
following downconverting pattern:
[22 lines not shown]
[DAGCombiner] Narrow the integer source of sint_to_fp
Truncate the source of a `sint_to_fp` when it is known to fit in a narrower
type the target can convert from directly.
For example:
```
sitofp (sext i32 %x to i64) to float
```
On AMDGPU this becomes a single `v_cvt_f32_i32` instead of the generic
i64 to f32 expansion.
Note: X86 marks i16 sint_to_fp as Custom, but SSE only supports conversion from
i32, so the custom lowering sign-extends i16 back to i32. Mark i16 as
undesirable to avoid a redundant movswl.
[CIR] Reject language address spaces in DirectToLLVM pointer conversion
Reject unlowered language address spaces in pointer types when bypassing TargetLowering. Guard pointer-producing lowerings, including generated patterns, so failed conversions report legalization failures instead of silently selecting address space zero or constructing invalid LLVM operations.
Assisted-by: Codex / GPT-6
[ORC] Move Mangler functions into header. (#224209)
Move Mangler functions into Mangler.h so that they can be used from
OrcTargetProcess without introducing a dependence on OrcJIT.
This is a temporary fix to enable use of SymbolNameSpec in
OrcTargetProcess (see https://github.com/llvm/llvm-project/pull/224188).
Future work will reorganize these libraries and should allow this code
to sink back down into a .cpp file.
[CIR] Propagate initializer type adjustment failures
Reject initializers whose active members have no LLVM representation, including when an enclosing union's storage type is convertible. Propagate recursive adjustment failures before querying data layout or constructing LLVM operations.
Assisted-by: Codex / GPT-6
[CIR] Propagate type conversion failures in DirectToLLVM
Propagate failed type and constant conversions through DirectToLLVM so unsupported types produce legalization failures instead of invalid LLVM operations or a void function result.
Assisted-by: Codex / GPT-6
ig4(4): fix attach of ACPI-enumerated LPSS controllers
Intel LPSS I2C controllers enumerated through ACPI rather than PCI never
attach on Haswell and Broadwell, so every device behind those buses is
lost. On a Dell XPS 13 9343 that hides the I2C HID touchpad and leaves
only the PS/2 fallback, which the firmware does not restore after S3.
Three causes, all on the ACPI path:
Firmware may leave an LPSS function in D3, where its registers read as
all-ones and set_controller() fails with "controller error during
attach-1". Run _PS0 before mapping them. The PCI path does not need
this, which is why the gap went unnoticed.
INT33C2, INT33C3, INT3432 and INT3433 are Lynx Point-LP and Wildcat
Point-LP, which ig4_pci.c already classifies as IG4_HASWELL; the ACPI
path called everything but APMC0D0F an Atom SoC.
The functional clock stays gated until bit 0 of IG4_REG_CLK_PARMS is
[12 lines not shown]
[SCEV] Look thru more expressions in isKnownMultipleOf (#219951)
Generalize the existing logic to look through AddRecs to look through
Add, Mul, and MinMax expressions in isKnownMultipleOf, noting that this
simply increases precision of added predicates, allowing us to add more
fine-grained predicates. It also fixes an underlying bug in the case the
AddRec wraps. The patch has no optimization impact at the moment, and
only serves to have higher precision in its sole user,
DependenceAnalysis.
Proof: https://alive2.llvm.org/ce/z/JLCqGJ
Rebase zfs.resource onto GenericCRUDService and a service part
## Problem
When zfs.resource became a CRUD service it was put on a plain `CRUDService`, because `GenericCRUDService` was read as machinery for datastore-backed services. It isn't: `CRUDServicePart` only annotates `_datastore`, and a part whose data doesn't live in the datastore omits it and overrides `query`/`get_instance` instead — which is exactly what `boot.environment` does over the same ZFS-backed, string-keyed shape. What we ended up with was a service carrying its own `get_instance` that called back into its own namespace by string, three `@overload` stubs (and three `# type: ignore` codes) that no in-process caller needed, and a `datastore_primary_key_type` override that nothing in the tree reads.
Separately, `processes` shipped with `check_annotations=True` and a `-> list[dict[str, Any]]` return annotation while its result model declares `list[PoolProcess]`. That check runs when the decorator is applied, so it raises while the class body is being evaluated — on import. `main.py` imports this module, so middlewared could not start. Nothing caught it: no unit test imported the module, and none of the static checks ever create the class.
## Solution
**Base class and config.** `GenericCRUDService[ZFSResourceEntry, str]` with `generic = True`, and the dead `datastore_primary_key_type` override dropped — the PK type comes from `ZFSResourceEntry.id`. That is visible in `core.get_services()["zfs.resource"]["config"]`: `datastore_primary_key_type` now reads `"integer"` (the framework always materialises the key) and `generic` reads `true`. No API method changes shape.
**New `plugins/zfs/resource_part.py`.** `ZFSResourceServicePart` owns `query` and `get_instance`. The sync walk still runs on an IO thread and still delegates into `resource_query.query`, so the threading and the module layout are unchanged.
**`query` and `get_instance` stay hand-declared on the service.** `query` because the inherited one gets wrapped with the stock `QueryArgs`, whose `extra` is a free dict — that would drop the field-by-field schema of `extra` from the docs and from `core.get_methods`, stop rejecting typos, and lose the `Private` guard on `exclude_internal_paths` at the API boundary. `get_instance` because the metaclass injects the concrete `E`/`PK` into whichever module declares `query`; with `query` declared here, the inherited `get_instance` would go looking for them in `crud_service`'s own globals and class creation would fail. `apps`, `apps_images` and `ix_volumes` pair the two overrides for the same reason. The part re-applies the `Private` guard on `extra` explicitly, since the generated args model types it as a plain dict.
**Rows are filtered as dicts and converted afterwards**, rather than built into entry models before `filter_list`. Handing `filter_list` the model changes `select` on the wire: the projected row is built with `model_construct`, which skips validation, so a field the caller didn't select comes back as its default instead of being absent, and a renaming select drops the value outright. Converting after the filter keeps the select behaviour this service already has.
**`processes` builds `PoolProcess` in `resource_processes.processes` and annotates through**, so the annotation agrees with the result model and the module imports again. The rows already carry all four fields, so the wire output is unchanged; what goes away is the `serialize_result` fallback that would otherwise log a warning and emit raw dicts. `PoolProcess` had to be added to the pool API module's `__all__` to be importable from `middlewared.api.current`. A new unit test imports the service module, which is what makes this whole class of failure visible — without it, a `check_annotations` mismatch is only reachable at middlewared startup.
[llvm] Updates case folding rules to Unicode 18 (#223716)
This PR updates other Unicode tables started by
https://github.com/llvm/llvm-project/pull/198255
Co-authored-by: Claude Sonnet 4.6 <noreply at anthropic.com>
[LLD][ELF] Reduce memory and file size of overlay thunk tests (#222565)
Add AT(address) to linker script to force generation of a program header
for each address. Without AT we get a single large program header that
takes up a large amount of memory and causes a large file to be
generated. This may prevent the test from running on a 32-bit machine
without a lot of memory. See comment on #200415
Also removed a superfluous --print-map from
aarch64-thunk-bit-overlay-reuse.s. This was used when constructing the
test but it is not needed.
ice: Add a failure injection facility
Add compile-time optional, non-sleeping fail points around every VF
creation resource boundary, before VF VSI reconstruction, and in the
GET_STATS validation path.
Provide an ICE-wide wrapper and device selector so other driver
subsystems can add scoped points without duplicating the failpoint
plumbing. Keep the current SR-IOV points and VF selector in an iov
child namespace.
Compile the facility only with options DRIVER_FAILPOINTS. This shared
option avoids a separate kernel option for every driver that provides
test-only injection hooks. Ordinary kernels contain no ICE failpoint
objects or sysctl nodes. Require an exact PF device name and
optionally a VF index before any point can fire. This prevents a stale
test setting from affecting another PF.
The hooks exposed two reset-lifetime defects while validating the
[13 lines not shown]
[Flang][Driver]Implemented the support for option -f[no-]optimize-sibling-calls in Flang (#216650)
Added support for -foptimize-sibling-calls and
-fno-optimize-sibling-calls in Flang.
- Sibling call optimization is on by default and the driver pass the
option `-f[no-]optimize-sibling-calls` to flang -fc1.
- When `-fno-optimize-sibling-calls` flag is passed, it sets boolen
`DisableTailCalls` and this results in adding the LLVM IR attribute
`"disable-tail-calls"="true"` which disables sibling call optimization.
[AMDGPU] Set Format/FormatModifier directly instead of per-flag bits, NFC.
Remove the now-redundant individual InstSI format flag fields (SOP1/2/C/K/P,
VOP1/2/C/VOP3/VINTRP/VOPD3/LDSDIR, the memory formats, Spill, and DPP/SDWA) and
have instruction classes set the Format / FormatModifier enum fields directly.
The enum fields are packed into TSFlags exactly as before, so this is NFC (the
full instruction table is byte-identical).
Real instructions copy Format/FormatModifier from their pseudo in the base real
classes (kept next to the existing TSFlags copy), so the Format field is now
correct on real instructions too.
Two derived helper bits (IsVOP3Encoding, VOPD3) are computed from Format for the
getVOPe32/getVOPe64 relation maps and the VOPDPairs searchable table; they are
not part of TSFlags.
Co-Authored-By: Claude <noreply at anthropic.com>
[AMDGPU] Decouple isVOP3P/isVINTERP from isVOP3 (#223448)
VOP3P and VINTERP instructions also set the VOP3 TSFlags bit, so isVOP3()
returned true for them. This overloaded isVOP3() to mean both "the VOP3
encoding" and "uses VOP3-style operand rules" (modifiers, constant bus,
literal legality).
Make VOP3P and VINTERP their own instruction-format enum values so
isVOP3() is strict (Format == VOP3). Callers that need "any VOP3-family
operand encoding" now use isVOP3Like() (VOP3 | VOP3P | VINTERP), added as
a SIInstrInfo wrapper. Redundant "isVOP3() && !isVOP3P()" tests are
simplified to isVOP3().
Resolves llvm/llvm-project#223448.
Co-Authored-By: Claude <noreply at anthropic.com>
ice: Make VF VLAN requests idempotent
VF drivers replay their VLAN filters after a reset and may retry a
request whose reply was lost. The PF tracked only a count and sent
every requested ID back to the switch. After PF reset replay had
already restored the filters, duplicate VID 0 failed with
ICE_ERR_ALREADY_EXISTS and NACKed the entire VF batch.
Track exact VLAN membership for each VF. Compact requests to unique
IDs whose membership changes, enforce the configured limit against
those IDs, and update membership after each hardware operation so
partial failures cannot undercount filters. Treat already-present
adds and already-absent deletes as successful reconciliation and
suppress their misleading low-level error dump.
Validated on an E810-XXV with a host-attached iavf VF. A three-filter
limit was filled with VIDs 0, 1, and 4094. PF and CORE resets replayed
all three without a duplicate warning or ADD_VLAN NACK, and DTrace
confirmed a three-VID replay reached the PF. A fourth unique VID was
[8 lines not shown]
[AMDGPU] Pack instruction format and modifier TSFlags bits into enums, NFC.
The instruction-format bits in TSFlags are mutually exclusive, so
collapse them into a single 5-bit Format enum and likewise FormatModifier
enum for DPP/SDWA. This frees 18 TSFlags bits.
For now Format is derived from individual TableGen bitfields to minimize
the patch, but next commit will remove those.
All raw format-bit tests already go through the SIInstrFlags predicates,
so no call sites change.
Co-Authored-By: Claude <noreply at anthropic.com>
This branch should build components from related branches on Jenkins too.
NOTE: THIS CHANGE AND ANY OTHERS IN Jenkinsfile SHOULD NOT GET PUSHED
INTO `master` WHEN IT IS READY FOR BEING ACTUALLY COMMITTED!
ice: Fix SR-IOV VF resource cleanup
ice_iov_uninit() freed each VF interrupt-map array without returning the
reserved indices to the device interrupt resource manager. Repeated VF
create and destroy cycles therefore exhausted the PF interrupt map even
though no VFs remained.
Return the interrupt allocation before freeing its map. Also split
software-only VSI release from hardware teardown so failures before
ice_initialize_vsi() do not issue invalid RSS, scheduler, and Free VSI
commands for an object firmware has never seen.
Keep a VF disabled until all of its resources and hardware state have
been created successfully. Clear the enabled state before teardown and
after any failed add so asynchronous mailbox processing cannot use a
partial or freed VSI. Consume VFLR status for inactive VF slots without
trying to reset a nonexistent VSI.
Track whether firmware currently owns each VSI and clear that ownership
[14 lines not shown]
