[EarlyIfConversion] Extend data dependent analysis across multiple blocks (#180623)
This extends the new data dependent analysis for branches to cover loads
which feed conditions which are not within the same Machine Basic Block.
To still try to catch loads which are "close in program time" we
limit on the number of instructions between the branch and the
load. We also bail out if we detect a function call or loop between the two
instructions.
Stop treating an empty catalog as a valid catalog
## Problem
`get_trains()` returns an empty mapping when `catalog.json` is missing or unparseable, nothing prevents that from being cached for 25 hours, and the cache-hit test only asked whether the entry was `not None` — so an empty dict was served back as a legitimate hit. Every reader then reads "no catalog data" as "nothing to update": apps report `upgrade_available=false` with a null `latest_version`, `upgrade_summary` refuses to upgrade any app, Discover shows nothing, and the sync job reports SUCCESS while deleting `CatalogSyncFailed`, `CatalogNotHealthy` and `AppUpdate` — a false all-clear that nothing re-derives. The cache lives on tmpfs, so a poisoned entry survives a middlewared restart and only clears on reboot. The missing-`catalog.json` case logged nothing at all.
The cache key encoded only the catalog label, while the catalog location flips between the apps dataset and a tmpfs path depending on whether that dataset is mounted. `catalog.sync` and `catalog.apps` resolve the location independently, so a mount-state change between them lets a read be served data that was written for the other location.
## Solution
- **Never cache a non-answer.** `catalog.apps` only writes the cache when it actually parsed trains, and an empty entry it finds on the way in is popped so an already-affected system recovers without a reboot.
- **Fail the sync loudly.** Reading no trains at all now raises inside `sync()`, so the existing handler raises `CatalogSyncFailedAlert` and the job fails instead of publishing "no apps" as a healthy catalog. `catalog.synced` stays false, which finally makes it mean what it says.
- **Only clear the health alert on evidence.** `CatalogNotHealthy` was deleted before the trains were read, so a broken catalog dismissed the alert describing its own breakage. The delete now happens beside the create, after a successful read of every train.
- **Don't delete the update alert on no evidence.** `update_app_upgrade_alert` abstains when no catalog data is available, rather than reading "every app reports no upgrade" as proof that nothing needs updating. `upgrade_summary` says the catalog data is unavailable instead of claiming no upgrade exists.
- **Key the cache by location** so data written against one location is never served for the other.
- **Bound the git operations.** The clone/pull/reset/checkout/status calls had no timeout, so a wedged `git` held the repository lock and blocked every later sync.
Also removes the unused `image_updates_available` parameter from `upgrade_available_for_app()`. It was never passed by either call site, and the equivalent override in `list_apps()` is the one that actually runs. The two are not interchangeable: an ix-app is a catalog app, so the version comparison inside the helper answers first and would hide a pending image update. The new tests pin that behaviour so the parameter is not "fixed" by wiring it up.
java/apache-commons-lang: set expiration date
Expire together with its only consumer in the ports tree editors/openoffice-4.
This port was already deprecated. Superseded by port java/apache-commons-lang3.
Approved by: no maintainer
devel/p5-Cache-FastMmap: update 1.62 -> 1.63
Changelog: https://metacpan.org/dist/Cache-FastMmap/changes
Add a patch to unbreak the tests under FreeBSD
(use "fstats -p PID" to count file descriptors instead of counting /proc/PID/fd)
[mlir][SCF] Skip dynamic peeling for non-index loops (#217909)
`scf-for-loop-peeling` constructs an `affine.apply` on its dynamic path
to compute the split bound. However, `affine.apply` requires `index`
operands, while `scf.for` also permits signless integer induction
variables and bounds.
Skip the dynamic peeling path when the loop induction variable is not
`index`. The existing constant-bounds path remains unchanged, so
constant integer loops can still be peeled.
Add a regression test for a loop with dynamic `i32` bounds, verifying
that the pass leaves it unchanged rather than producing invalid IR.
Fixes #216631.
Co-authored-by: Purnima Shrivastava <purnimashrivastava05@.com>
[mlir][scf] Do not read non-constant loop bounds when unrolling (#217392)
`loopUnrollByFactor` asserts `expected constant loop bound`
(`SCF/Utils/Utils.cpp`) when the loop bounds are not constant.
`getStaticTripCount` takes the constant path whenever
`constantTripCount` answers, but `constantTripCount` answers on three
shapes where the bounds themselves are **not** constant:
- `lb == ub` (same `Value`), giving 0 iterations,
- `lb == 0` and `ub == step`, giving 1 iteration,
- `ub` a constant offset from a non-constant `lb`, via
`computeUbMinusLb` under `nsw`.
In all three the code then reads the bounds as constants and asserts.
The fix takes the constant path only when `lb`, `ub` and `step` are all
constant, and otherwise falls through to the dynamic path that already
handles them. The other two callers of `getStaticTripCount` in that file
use only the count, never the bounds, so the defect is confined to this
[4 lines not shown]
[CIR] Emit lifetime markers for automatic variables (#206695)
### summary
This is a follow up of : #199599
Per the consensus from the PR #199599, this implements lifetime-marker
emission in ClangIR that closely follows classic CodeGen.
Emit lifetime markers (cir.lifetime.start/end) for automatic variables
in ClangIR.
- Gated by shouldEmitLifetimeMarkers (optimized builds or
ASan-use-after-scope/
HWASan/MSan/MemtagStack), like classic CodeGen.
- start at the decl; end as a NormalEHLifetimeMarker cleanup (after the
destructor);
both target the underlying alloca. Wired through the EH stack so they
don't force
[6 lines not shown]
