[OpenMPOpt][PGO] Set entry count on merged parallel wrapper (#221654)
When OpenMPOpt merges adjacent parallel regions, it creates a new
wrapper (*..omp_par) that calls the original outlined callbacks through
a single __kmpc_fork_call.
Preserve profiling information for the merged wrapper by assigning it
the
largest function_entry_count from the original callbacks. Also preserve
callsite counts for calls to the original callbacks, since SamplePGO may
otherwise treat them as cold once the wrapper itself has profile data.
[flang] Reject MODULE prefix in abstract interface body (#212980)
Issue: Flang accepts a MODULE prefix on a function or subroutine inside
an ABSTRACT INTERFACE. C1547 allows MODULE only on a module subprogram,
or on a nonabstract interface body in a module or submodule.
Fixes #208200
Root cause
- BeginSubprogram() only enforced the module/submodule half of C1547. An
abstract interface inside a module or submodule still has that scope, so
the check passed.
- In PushSubprogramScope(), an abstract interface body takes the
isAbstract() path, sets ABSTRACT, and never looks at hasModulePrefix, so
the prefix was ignored with no diagnostic.
```
if (isAbstract()) {
SetExplicitAttr(*symbol, Attr::ABSTRACT);
} else if (hasModulePrefix) {
[21 lines not shown]
[Flang][HLFIR] Lower PACK(array, .TRUE.) to hlfir.reshape (#220860)
When the PACK mask is the compile-time scalar .TRUE., the result is
equivalent to RESHAPE(array, [SIZE(array)]). Lower all PACK calls to
hlfir.pack, then simplify pack(array, .TRUE.) to hlfir.reshape with an
index-typed SHAPE temporary in SimplifyHLFIRIntrinsics. Variable or
array masks, VECTOR, and non-trivial or polymorphic operands continue to
use the runtime PACK path.
Add regression tests for character and real(k) PACK with scalar .TRUE.
Relanding the patch #213603 after fixing the regression
---------
Co-authored-by: Cursor <cursoragent at cursor.com>
ipmi(4): improve debugging for ioctl(IPMICTL_SEND_COMMAND)
Add a knob to debug ioctl(IPMICTL_SEND_COMMAND). Log the IPMI NetFn and
Cmd fields, followed by a hexdump of the request data. Upon completion,
log the hexdump of the response data.
Reviewed by: adrian, imp, ngie
Sponsored by: Vdura
Differential Revision: https://reviews.freebsd.org/D59514
Add various defaulted postfix operator overloads with restrictions and error checks
Introduce new structures demonstrating defaulted postfix increment and decrement operators with various qualifiers such as `__restrict__`, `volatile`, and `const`. Include error checks for invalid return types and parameter types in defaulted operators. Enhance the handling of placeholder types and clarify the rules around defaulted operators in the context of C++ concepts and templates.
[tsan][go] Relax alignment for 128-bit Go atomic args buffer access (#213123)
The Go 128-bit atomic helpers added by #196833 read and write the
128-bit value through an a128* cast of the u8* args buffer (e.g.
*(a128*)(a + 8)). Clang treats a128* as requiring 16-byte alignment and
emits MOVAPS or MOVDQA on x86_64. The Go runtime only guarantees 8-byte
alignment of the args buffer, so a+8 may not be 16-byte aligned. The
misaligned MOVAPS raises GP and causes a SIGSEGV.
Use an 8-byte-aligned typedef (`using a128_u64 ALIGNED(8) = a128;`) for
args buffer accesses so Clang emits unaligned 128-bit moves (MOVDQU).
The target address of the atomic operation itself (`*(a128**)a`) is
always 16-byte aligned from the Go side.
Refactor defaulted function handling by introducing a helper to define functions with synthesized bodies. Update exception specification computation to utilize this new helper for better code clarity and maintainability.
[NFC][clang][Modules] Add regression test for implicit lambda capture from merged module copies (#222020)
Adds a regression test for
https://github.com/llvm/llvm-project/issues/221548.
When the same header is textually included into the global module
fragments of two different module interface units, and the header
defines an out-of-line member template whose body contains a lambda
capturing a local variable, instantiating that template for a type named
through the second copy must keep the capture. On affected compilers the
reproducer miscompiles (a `static_assert` on the same value fails with
the bogus `unimplemented constexpr lambda feature: captures not
currently allowed` note); on current main it compiles cleanly.
Verification performed locally:
- Reproduced both symptoms from the issue with the system clang 18
(runtime exit value 21 instead of 42; bogus constexpr note), and
confirmed the closure is missing the capture in IR.
- Built current main with assertions: the reproducer passes (constexpr
[15 lines not shown]
[WebKit Checkers] Allow a view into a const CanBorrow object without a Borrow<T> (#229843)
Example:
const Vector<char> vector = copyToVector(x);
use(vector.span());
A const object can never be mutated, so it can never invalidate a view
into
its interior.
This applies to a const-declared object only, not a const reference or
const
pointer -- which might refer to a non-const object.
A const object also makes the values it contains const, so a view into a
CanBorrow object held in a const std::optional qualifies too:
const std::optional<Vector<char>> vector = copyToVector(x);
[17 lines not shown]
[clang][Sema] Reject oversized arrays deduced from initializer lists (#226983)
When an array's size is deduced from its initializer list, Sema skips
the array size check.
On x86_64,
```cpp
typedef char B[1ULL << 60];
B e[16]; // error: array is too large
B d[] = { {0}, {0}, /* ... 16 elements */ }; // accepted, sizeof(d) == 0
```
On i386,
```cpp
struct B { char c[1 << 30]; };
struct B e[5]; // error: array is too large
struct B d[] = { {{0}}, {{0}}, {{0}}, {{0}}, {{0}} }; // accepted, sizeof(d) == 1 GiB
[12 lines not shown]
[Mips] Track ISA mode and distinguish ELF data labels (#228883)
Represent standard MIPS, microMIPS and MIPS16 with a shared ISA mode in
the ELF target streamer. Initialize it from the subtarget, save and
restore it across .set push/pop, and reset it for .set mips0. Disabling
one compressed ISA must not clear the other ISA's active mode. Keep the
assembler's feature bits consistent when switching between them.
Use the mode to mark function and pending instruction labels, propagate
it to aliases, and set the MIPS16 ELF flag for command-line MIPS16 mode.
Clear pending code labels when emitting byte strings or fill directives,
as already done for integer data, so data does not inherit the following
instruction's mode.
Extend the existing label and .ent tests with command-line microMIPS
mode, nested mode changes, initial-mode resets, and data emission.
Assisted-by: OpenAI Codex # Testcases
Return Secret job results to the caller
## Problem
`zfs.resource.encryption.export_key` is a typed job whose result is `Secret[str | None]`, so it returns a `Secret`. The finished-job event sends the raw result to the client and cannot serialize a `Secret`, so the job succeeded but the caller got "Failed to JSON serialize server message" instead of the key.
## Solution
Jobs unwrap a returned `Secret` before storing the result, matching how non-job methods already serialize it. Job listings and debugs still mask the value through the result model.
Unlock zfs resources through typed models
## Problem
Internal callers (failover, boot import, KMIP) started a private dict-based unlock job with its own private models, and results were read with dict indexing. Changing a key from a pipe also rejected valid keys with a leading zero, and change_key accepted keys and passphrases that ZFS would later refuse.
## Solution
- **Unlock**: `zfs.resource.encryption.unlock` gains `start_attachments`, and internal callers start the public job with `ZFSResourceEncryptionUnlockArgsData` and read the returned entry by attribute. `unlock_impl` is now the non-job implementation that takes the model and unwraps secrets once; pool.dataset.unlock calls it directly since it already holds the same job lock.
- **Change key**: the key must be 64 hex characters and a passphrase 8 to 512 characters; a key read from the input pipe is matched as hex text instead of round-tripped through int.
- **Cleanup**: shared `secret_value`/`ancestor_chain` and `is_internal_dataset_name` live in one place each, store_key receives the lowercase ZFS key format while hook payloads are uppercase, and the sync_keys failure is logged with its traceback.
Tidy dataset encryption naming and readability
## Problem
The encryption move left `zfs_resource` wording on the `pool.dataset` side (shared job lock names, the `zr_args` helper, "compatibility wrapper" docstring lines, a `PoolDataset` message raised from zr), and a lot of the moved logic was dense comprehension and `filter`/lambda one-liners that were hard to read.
## Solution
- Job lock names live once in `plugins/zfs/encryption_job_locks.py` with neutral `dataset_encryption_*` names, used by both `pool.dataset` shims and `zfs.resource.encryption`, so both APIs still serialize on the same lock per dataset.
- Shims build zr arguments with the existing `validate_model` instead of a local helper, and their docstrings no longer describe the wrapping.
- zr raises "Dataset {path} does not exist", and the key table model is renamed `EncryptedDatasetModel` (table unchanged).
- Comprehensions, generator expressions, `filter`/`map` lambdas and inline ternaries in the encryption code are plain loops and `if` blocks, with behaviour unchanged.
Move dataset encryption to zfs.resource.encryption
## Problem
Dataset encryption still lived in the `pool.dataset` namespace even though `zfs.resource` is now the dataset API, and zr's own create path had to call back into `pool.dataset.insert_or_update_encrypted_record` to record keys.
## Solution
- **New `zfs.resource.encryption` sub-service** owning lock, unlock, unlock_summary, export_key, export_keys, export_replication_keys, change_key and inherit, with zr conventions (`path`, lowercase enums, `Secret` keys, `ZFS_RESOURCE_*` roles, audit). Public methods delegate to private `*_impl` methods for thread local storage, as the rest of zr does, and everything is synchronous except starting attachment delegates, whose API is async.
- **Private methods moved and renamed** (store_key, delete_keys, stored_keys, sync_keys, encryption_roots, encryption_state, replication_keys, encryption_root_mapping, unlock_impl), together with the `storage_encrypteddataset` model. Every internal caller (failover, pool create/import/export, KMIP, replication, zfs events, zr create) now calls zr directly; no `pool.dataset` alias is left.
- **`pool.dataset` encryption methods are thin shims** keeping their models, roles and pipes. They call the zr `*_impl` methods through the namespace with their own job, so no nested jobs are created, and they share zr's job locks so both APIs serialize on the same dataset. Error messages are unchanged; validation attributes now follow zr names.
- `unlock_impl` has a private Secret-typed accepts model so passphrases handed over by failover stay redacted in job listings.
- Hook names and payloads, including the uppercase key formats failover relies on, are unchanged, and nothing renamed is called across HA controllers.
[flang][Driver] Enable bare -O flag alias when specified with -flto (#228483)
Currently, `O_flag` (`-O` as an alias for `-O1`) in Options.td is not
visible to FlangOption. As a result, invoking flang with a bare `-O`
(without a trailing digit) is treated by the joined `-O` definition as
`-O""`, causing an error when forwarded to the linker.
Add `FlangOption` to `O_flag`'s Visibility so that `flang -O` correctly
aliases to `-O1`.
Assisted-by: IBM Bob
Resolve https://github.com/llvm/llvm-project/issues/227474
[scudo] Validate list endpoints and links before removing a node (#229245)
`DoublyLinkedList::remove()` currently modifies the predecessor's link
before validating the successor's reciprocal link, and checks endpoint
consistency only in debug builds. A corrupted successor can therefore be
rejected after a list write has already occurred, while inconsistent
null links can bypass endpoint checks in release builds.
Check that the list is nonempty, enforce endpoint consistency in release
builds, and validate both reciprocal links before modifying any list
state. The production change is confined to `remove()`. This strengthens
consistency checks; it does not authenticate list membership or protect
against mutually consistent forged interior nodes.
Tests cover all 24 removal orders of four nodes, plus empty-list
removal, both directions of endpoint inconsistency, and corrupted
reciprocal links, using pointer and index links.
Local validation on Linux x86_64 in WSL, Clang 21.1.8:
[23 lines not shown]
[AMDGPU] Require wave ID masks to be constants (#229917)
PR #177713 added some cases to the wave ID recognizer, such
as (ThreadID & Mask) >> log2(WaveSize) but, after it landed, Claude
noticed a bug. `Mask` in those types of expressions was an arbitrary
vale, which could be divergent, meaning that the "uniform" value of
that expression wouldn't actually be uniform.
The quick fix that preserves most of the cases we're worried about in
practice is to restrict these patterns to constant masks.
AI disclosure: Claude found the issue and created the patch, I wrote
this message.
Co-Authored-By: Claude Opus 5 (1M context) <noreply at anthropic.com>
Co-authored-by: Claude Opus 5 (1M context) <noreply at anthropic.com>
