[flang][semantics] Reject DATA-style initializer on EXTERNAL/INTRINSIC (#222256)
An `entity-decl` carrying a legacy `/initialization/` (an extension) was silently
accepted, and the initializer dropped, when the name had already been
declared `EXTERNAL` or `INTRINSIC`:
```fortran
subroutine s
external foo
integer foo /1/ ! accepted, no initialization emitted
end subroutine
```
`DataChecker::Leave(const parser::EntityDecl &)` passed the value list to
`AccumulateDataInitializations` without checking the symbol's class, so the
initialization never reached the emitted code and no diagnostic was produced.
Reversing the two statements already errors, so the behaviour was also
order-dependent. For an intrinsic name that is not an unrestricted specific
function (`sum`), the accumulated value instead tripped
[9 lines not shown]
[orc-rt] Mark LockedAccess's constructor as noexcept. (#230311)
The ORC runtime does not use exceptions for errors internally, so mark
this noexcept. In practice the mutex and lock types we use (STL mutexes
and locks) don't throw unless corrupted or misconfigured. If we ever
want to support locks whose acquisition can legitimately fail we'll need
an alternative Error-based representation of failure.
[AMDGPU] Use vector memory types for 64/128-bit cooperative atomics (#229501)
The 16x8B and 8x16B cooperative atomic intrinsics had integer memory
types (`i64`/`i128`) that didn't match their vector values, which broke
value tracking on the loaded value and could crash the compiler. This
patch uses the value type as the memory type and updates the selection
patterns to match. Codegen for existing cooperative atomics is
unchanged.
*/*: remove stale ports that are not built
These GhostBSD-only ports were not listed in SUBDIR, so poudriere never
built them, and nothing depends on them. Most were removed from
FreeBSD years ago and survived merges here.
Add MOVED entries for the ones that did not already have one.
Don't let the ThreadPlanSingleStepTimeout interrupt an already stopped process (#227898)
When the ThreadPlanSingleThreadTimeout timeout fires, first check
whether the process is stopped before sending the interrupt.
This is a simpler way to address the problem that was identified in:
https://github.com/llvm/llvm-project/pull/224272
The problem solved there is that if the stop processing is still going
on when the timer fires, we send the interrupt request event which gets
enqueued and then handled after the stop event processing has restarted
the inferior to continue the thread plan work.
That patch involved trying to figure out, when you receive the event,
whether it was stale or not. It was harder to reason about - and not all
the way right, though that probably could be fixed.
But when you get a stop event, we first set the private state to stopped
[6 lines not shown]
RuntimeLibcalls: Require system library members to be libraries
Every SystemRuntimeLibrary now lists only LibcallLibrary and LibraryRef
members, so the inline path that expanded unhomed RuntimeLibcallImpl members
directly into the system's block, including its SystemAvailableImpls
bitset, is dead. Remove it, and error on any member that is not a
library. The generated RuntimeLibcalls.inc is unchanged.
Co-authored-by: Claude Opus 5.5 <noreply at anthropic.com>
*/*: remove obsolete ports
These ports came over from TrueOS and PC-BSD and have not been
maintained since 2017-2022. Nothing in the tree depends on them, and
the ones still listed in SUBDIR were being built for nothing.
[Analysis] Don't treat code after analyzer_noreturn calls as unreachable (#229577)
Since #150952, the CFG treats calls to functions attributed
'analyzer_noreturn' like calls to 'noreturn' functions, so
-Wunreachable-code reported the code following such a call as never
executed even though the call can return.
Record in CFGBlock whether a noreturn block ends in a real 'noreturn'
call or an 'analyzer_noreturn' call. The CFG keeps the code after an
'analyzer_noreturn' call as the alternate successor of the exit edge and
the reachability scan used by -Wunreachable-code follows it. All other
clients still treat the two kinds identically.
rdar://188741139
[SLP]Fix crash on fused alternate node with reuse shuffles
Size the vector type by the unique scalars, same as the opcode mask;
the reuse-shuffle vectorization factor made them mismatch.
Reviewers:
Pull Request: https://github.com/llvm/llvm-project/pull/230303
[CIR] Pass x87 long double vectors on x86_64
Vectors of x87 long double now go through x86_64 calling-convention
lowering instead of hitting NYI. The ABI library sizes their elements at
128 bits like clang does, so the signatures match classic codegen.
Unions are still moved as a value of their storage type, and a long
double stores only 10 of its 16 bytes. So a union holding an x87 value
next to another member stays NYI unless it's a plain long double and the
other members fit in those 10 bytes. That also stops a silent miscompile
of unions like `union { long double ld; char c[16]; }`.
Assisted-by: Cursor / Claude Opus 5.5
[lldb] Set the default clang module cache path in TypeSystemClang (#229817)
`ModuleListProperties` calls
`clang::driver::Driver::getDefaultModuleCachePath`, so `lldbCore` links
`clangDriver`, which drags in `clangAST` and most of LLVM via static
initializers. lldb-server only links `lldbCore` and links everything
else regardless.
Set the default from `TypeSystemClang::Initialize` instead. Every tool
that uses the clang module cache registers TypeSystemClang.
[CodeGen] Force compiler to generate default destructor for class (#229944)
The LazyMachineBlockFrequencyInfoPass has global visibility so in order
for it to be linkable with MSVC, we need to explicitly tell the compiler
to emit its definition.
RuntimeLibcalls: Organize functions into libraries
Associate runtime functions with the library which provides them. Add
shared LibcallLibrary defs, like compiler-rt, libm and libc, along with
OS and target specific variants, and replace each target's hand-listed
SystemRuntimeLibrary body with references to them. The resulting libcall
sets are unchanged.
Targets which differ from the shared libraries opt out of individual
functions, e.g. AVR has no sin, cos or sincos, x86 has no fp128 sincosl,
and PPC replaces some f128 compiler-rt helpers. Libraries which should
not merge with the generic variants are Isolated, like arm64ec's
compiler-rt and SPIRV's libc.
Co-authored-by: Claude Opus <noreply at anthropic.com>
[CIR] Destroy coroutine body locals before the implicit co_return (#229743)
When a coroutine body flows off its end, CIRGen calls the promise's
`return_void()` while the local variables of the body are still alive,
and destroys them afterwards.
Flowing off the end of the function-body is equivalent to a `co_return`
with no operand. Control only flows off the end of the function-body
when it leaves the body's block, and leaving the block destroys the
block's automatic variables.
This patch wraps the body in a `RunCleanupsScope`, so the body's
cleanups are popped when the body ends, before the fall-through handler
is emitted. The body's `cir.cleanup.scope` now ends with a `cir.yield`,
and `return_void()` and `cir.co_return` follow it.
---------
Co-authored-by: Claude Opus 5.5 <noreply at anthropic.com>
[lldb] Intern SB API strings in the system pool (#229901)
Intern strings returned by SB classes that do not belong to a debugger
in the system pool. Rename StringPool::GetSystem to GetSystemPool and
add StringPoolRef::InternNonEmpty for getters that map an empty string
to nullptr. SBEnvironmentTest now initializes the SB API, as the system
pool is only valid between Initialize and Terminate.
Bail out of zil_create() when the pool suspends
zil_create() waits with txg_wait_synced(), a void wrapper around a
plain wait that cannot report a suspend. When the pool suspends while
it waits, the fsync() that got there does not return until the pool
resumes.
The rest of the commit path already handles this. zil_commit_flags()
and zil_commit_writer_stall() wait with TXG_WAIT_SUSPEND, call
zil_crash() on ESHUTDOWN and hand EIO back to the waiters.
zil_create() and zil_commit_activate_saxattr_feature() were left on the
old wait, so a suspend caught in either one still hangs.
Use the suspend-aware wait in all three places and return the failure.
zil_process_commit_list() already has a NULL-lwb path that signals the
nolwb waiters with the error, and its comment already says an ESHUTDOWN
there means zil_crash() was called, so the failure lands somewhere that
expects it.
[11 lines not shown]
Bail out of the objset upgrade when the pool suspends
The two objset upgrade callbacks end with txg_wait_synced(), a void
wrapper around a plain wait that cannot report a suspend. When the
pool suspends during that wait, the upgrade taskq thread stays blocked
until the pool resumes. So does dmu_objset_disown(), which calls
dmu_objset_upgrade_stop(). That waits for a running upgrade task to
finish and then waits for a txg itself.
Give all three waits TXG_WAIT_SUSPEND. The callbacks return EAGAIN,
which dmu_objset_upgrade_task_cb() records in os_upgrade_status.
zfs_ioc_userspace_upgrade() and zfs_ioc_id_quota_upgrade() return that
status, and libzfs reports EAGAIN as a suspended pool.
dmu_objset_upgrade_stop() ignores the result, as it ignored the old
wait.
On master, fstests generic/753 in the eio group hangs with the pool
suspended and z_upgrade blocked here:
[10 lines not shown]
Do not wait forever in spa_vdev_state_exit() on a suspended pool
spa_vdev_state_exit() waits for the txg to sync whenever it is given a
vdev, so that zpool(8) commands are synchronous. If the pool suspends
during that wait, the txg never syncs and the command never returns.
A pool that is already suspended does not get that far.
ZFS_IOC_VDEV_SET_STATE refuses it with EAGAIN before vdev_online()
runs, and zfs_ioc_clear() passes NULL instead of the vdev when
spa_suspended() is true. The hang needs the pool to suspend after
those checks. That happens when the state change's own sync fails,
and when a zpool clear races a new suspend, which generic/753 in the
eio group caught on an encrypted mirror:
zpool D 357s txg_wait_synced <- spa_vdev_state_exit
<- zfs_ioc_clear
txg_sync D 359s
pool SUSPENDED
[24 lines not shown]
Stop DMU_TX_NOWAIT callers spinning on a suspended pool
On a suspended pool, dmu_tx_assign() gives a DMU_TX_WAIT caller EIO
under failmode=continue and blocks it under failmode=wait. A
DMU_TX_NOWAIT caller gets ERESTART in both modes, and every such caller
answers it the same way:
if (error == ERESTART) {
waited = B_TRUE;
dmu_tx_wait(tx);
dmu_tx_abort(tx);
goto top;
}
dmu_tx_assign() sets tx_break_on_suspend for any caller without
DMU_TX_SUSPEND, so this dmu_tx_wait() waits with TXG_WAIT_SUSPEND and
returns as soon as it sees the suspended pool. It returns void, so the
caller retries at once, and the thread spins in the kernel until the
pool resumes. dmu_tx_assign() guards its own retry against this by
[26 lines not shown]
[DAG] Handle widened step vectors in expandGetActiveLaneMask
On AVX512 getLegalMaskAndStepVector will need to widen the step vector type. Handle this in expandGetActiveLaneMask, so we don't crash on AVX512 which widens e.g. v8i1 -> v16i1. We don't actually use Mask, it's just a dummy poison value to work out what type the final mask result should be.
