devel/codemark: Update to 0.7.30
Declare the missing libzstd dependency: the zstd-sys crate picks up the
system zstd via pkg-config and links against it, but the port relied on
archivers/zstd and pkgconf being pulled in transitively by other build
dependencies.
[InstCombine] Evaluate zext nneg as sext where possible (#212230)
We can convert zext nneg to sext, and doing so when evaluating an
expression in a wider type means any negative constant operands are
sign-extended instead of zero-extended, meaning the high bits of the
result will be correct without needing to mask them.
Alive2 proofs:
Evaluating nsw arithmetic at higher precision means the sign of the
result can't change: https://alive2.llvm.org/ce/z/xX9eq3
Sign-extending an operand of a bitwise operations doesn't matter with
nneg: https://alive2.llvm.org/ce/z/4QNsEg
Operand can be sign-extended without nsw if we have a zext of a zext:
https://alive2.llvm.org/ce/z/K_UXnU
zext_nneg_of_sext: https://alive2.llvm.org/ce/z/9U6BRG
zext_nneg_of_sext_large_positive: https://alive2.llvm.org/ce/z/Q9mFKu
buf: Avoid calling bufdomain() on newly initialized bufs
bufinit() inserts newly initialized bufs into the QUEUE_EMPTY queue, at
which point they haven't yet been assigned a domain. Thus, bufdomain()
returns &bdomain[-1], which trips the array-bounds sanitizer.
This is harmless since we don't use the result in that case, but let's
avoid the invalid access to begin with. This is sufficient to let an
amd64 kernel boot to a login prompt with -fsanitize=array-bounds
configured.
Reported by: Andrew Griffiths <andrew at calif.io>
Reviewed by: rlibby, kib
MFC after: 1 week
Differential Revision: https://reviews.freebsd.org/D59381
[X86][AVX-512] Fold `zext(and(bitcast(mask), C))` --> `and(anyext(bitcast(mask)), zext(C))` (#220251)
resolves #120389
Note: I have used AI for the tablegen implementation (using my DAG
implementation as reference) since I'm not very familiar with tablegen
yet.
[CodeGen] Don't misinterpret a UINT64_MAX-sized stack object as dead (#220172)
Fixes #214750
A static alloca of `0xFFFFFFFFFFFFFFFF` bytes — what clang emits for
`__builtin_alloca(-1)`, which is valid C — crashed with `Assertion
'!isDeadObjectIndex(ObjectIdx) && "Getting frame offset for a dead
object?"' failed`. MachineFrameInfo encoded dead stack objects in-band
as `Size == ~0ULL`, so this object was considered dead from the moment
it was created: PEI skipped it when assigning frame offsets, but the
frame-index reference was still in the function, and eliminateFrameIndex
asserted when resolving it. No pass ever marked the object dead — the
size itself collided with the sentinel. Not actually a recent regression
despite the label; it reproduces back to 20.x, and GlobalISel had the
identical latent bug since it also feeds the raw alloca size into
`CreateStackObject`.
Deadness is now a separate `isDead` flag on `StackObject` instead of
borrowing a size value, so no size can flip an object's liveness.
[10 lines not shown]
[X86] Select i8 ANDN via i32 promotion (#205050)
Added selection support so BMI ANDN can be used for i8 integer operands
by widening through the available 32-bit instruction form and keeping
the low byte result.
I also updated the affected X86 CodeGen checks and added direct coverage
for the i8 case.
Fixes #204985
[VPlan] Extend cse to eliminate redundant widened loads (#212543)
The generic cse() skips memory-reading recipes, so duplicate widened
loads are never eliminated. Extend cse() to also CSE redundant
VPWiden(EVL)LoadRecipes.
Within a VPBasicBlock, loads are matched against earlier ones with the
same address, mask, scalar type and alignment; the candidate list is cleared
on any memory-writing recipe (a conservative aliasing barrier), so load CSE
stays within a single block. This covers consecutive, masked and gather loads.
py-pikepdf: updated to 10.12.0
v10.12.0
Packaging and licensing
- Binary wheels now redistribute the licenses of the compiled third-party
libraries they bundle, along with an attribution manifest mapping each
component to its license. {issue}`736`
- The new `third-party-licenses/` directory documents every vendored binary:
qpdf and libjpeg-turbo on all platforms; OpenSSL and zlib (both statically
linked into `qpdf30.dll`) plus the Microsoft Visual C++ runtime on Windows;
the GnuTLS/Nettle/GMP stack on macOS; and the GCC runtime libraries on
musllinux. It also records what is deliberately *not* bundled -- notably
that Linux wheels use qpdf's built-in crypto and link no TLS library at all.
- These files are declared via PEP 639 `project.license-files`, so they ship
in `pikepdf-<version>.dist-info/licenses/` and are enumerated in the wheel's
`License-File` metadata. `License-Expression` remains `MPL-2.0`: pikepdf's
own license is unchanged, and the bundled libraries are separate works
[70 lines not shown]
py-nanobind: added version 3.0.1
nanobind is a small binding library that exposes C++ types in Python and vice
versa. It is reminiscent of Boost.Python and pybind11 and uses near-identical
syntax. In contrast to these existing tools, nanobind is more efficient:
bindings compile in a shorter amount of time, produce smaller binaries, and
have better runtime performance.
[AArch64] Lower rmw sub to FNEG+LDFADD when LSFE present (#220568)
This patch enables `atomicrmw sub` nodes to be lowered into
FNEG+LD(B)FADD instructions when LSFE is present and we are not in
strictfp environment.
Additionally, this patch fixes a bug which allowed atomicrmw with fp128
to be considered legal when LSFE present.
[CIR] Use the modern enum case classes
The `I32EnumAttrCase` family carries an `Attr` half, and an `IntegerAttr`
predicate with it, that a CIR enum has no use for now that the enums derive
from `EnumInfo`. Upstream says of those forms that they "are not needed when
using the newer `EnumCase` form".
Rename all 198 of them to `I32EnumCase`, `I32BitEnumCaseNone`,
`I32BitEnumCaseBit` and `BitEnumCaseGroup`. The group class drops its width
prefix because the modern spelling takes the width from its cases.
NFC, mechanical.
[CIR] Drop the redundant suffix from the inline kind mnemonic
inline_kind was the one CIR enum attribute mnemonic still repeating what its
C++ enum class name says. The attribute now spells
`#cir.inline<always_inline>`. The operation argument keeps the name
inline_kind, since that is the accessor name, so the printed form reads
`inline_kind = #cir.inline<always_inline>`.
The enum's summary also becomes "inline kind" rather than the camelCase
"inlineKind", which is what generated docs show now that CIR_InlineKindAttr
no longer overrides it.
25 CHECK lines change across four test files. Nine are in an
aarch64-registered-target test, unsupported in an X86-only build, but the
substitution matches the two CIR tests that do run.
[CIR] Derive lowering attr names from cppClassName, not the def name
CIRLoweringEmitter built its CXX_ABI_ALWAYS_LEGAL_ATTRS entries with
GetOpCppClassName, which splits the TableGen def name at the first
underscore. That works only while every def is named CIR_<CppClassName>Attr.
When one is not, the emitter writes an `isa<>` for a class that does not
exist, and the failure lands as a compile error in generated code.
Attributes carry the authoritative name in cppClassName, which
GenerateAttrToValueVisitor was already reading. Factor that out as
GetAttrCppClassRef and use it for both attribute paths. GetOpCppClassName
stays for operations.
NFC, and checkable. No CIR attribute overrides cppClassName, so the generated
CIRLowering.inc is byte-identical.
[CIR] Drop dead ceremony around the CIR enum attributes
Five things that no longer earn their place in the CIR enum attribute
machinery.
CIR_CleanupKindAttr carried three. Its cppClassName restated the default
AttrDef already derives. Its skipDefaultBuilders plus hand-written
AttrBuilder existed only to default $value to CleanupKind::All, which no
caller relies on, so the generated builders stayed suppressed for nothing.
And its summary and description restated the name, overriding the enum's own
"cleanup kind" that EnumAttr would otherwise inherit. The isNormal, isEH and
isNormalAndEH helpers stay.
CIR_TLSModelAttr's summary restated its name the same way, so only that goes.
CIR_DefaultValuedEnumParameter has never had a user.
NFC.
[CIR] Migrate the FPClassTest bit enum and unquote its flags
cir.is_fp_class printed its flags inconsistently. Single-bit values came out
bare, as in `fcSNan`, while group values and combinations came out quoted, as
in `"fcInf"` and `"fcSNan|fcNegInf"`. That comes from I32BitEnumAttr setting
printBitEnumQuoted, which EnumAttr.td keeps only for backwards compatibility.
Clearing the bit and using the `enum` directive selects the separator-aware
parser and printer, so every value now spells unquoted:
cir.is_fp_class %x, fcSNan|fcNegInf : (!cir.float) -> !cir.bool
The enum also drops its specialized IntegerAttr for a CIR_EnumAttr wrapper,
giving it the standalone spelling `#cir.fp_class<fcSNan|fcNegInf>`. This
changes operation syntax, so it updates 37 CHECK lines.
[CIR] Migrate GlobalLinkageKind, CallingConv and SideEffect off IntegerAttr
GlobalLinkageKind, CallingConv and SideEffect generated IntegerAttr
subclasses with no dialect spelling of their own. Each now sets
genSpecializedAttr = 0 and gains a CIR_EnumAttr wrapper, and cir.global wraps
$linkage in `enum()`. GlobalLinkageKind spells `#cir.linkage<internal>`,
dropping both the `global_` prefix and the `_kind` suffix.
cir.func and cir.call print all three by hand, but they stream
stringifyGlobalLinkageKind(getLinkage()) and friends, which take the enum
rather than the attribute, so those sites are unchanged.
Operation syntax is unchanged.
