Test the 32-bit and 16-bit store paths (MOVE ..., 1 / ..., 0) and take
the shared register-file bit from the store data source (src{4}) with
the same-file invariant documented. Gate the lit directory on the
TMS34010 target being built, and run the no-stack frame test at -O2
with an escaping alloca.
emitGlobalVariable handled only zero-initialized .bss objects and let
initialized globals, string literals and constant/private data fall
through to the generic ELF .data/.rodata/.asciz printer, which GSPA
rejects. Reject every non-null initializer and private/constant data
with a fatal error, and add m1-data/m1-string negative tests.
Validate the IR signature before legalization can split i64/aggregate
parameters into i32 pieces, and reject varargs plus sret/byval/inreg/
nest/returned argument flags. CanLowerReturn no longer returns false
for an unsupported return type (which silently demoted it to sret);
it reports a fatal error instead. Add negative lit tests at -O0/-O2.
GSPA 2.00 has no .section/.type/.size/.ident/.p2align directives, so
use the base MCAsmInfo and switch sections with bare .text/.data/.bss.
Zero-initialized globals become one .bss line (sizes in bits), and a
global address (including the +bit-addend constant-GEP form) selects to
a single MOVI relocation.
M1 has no stack, so the fast register allocator's spill/reload path
cannot work at -O0; use the greedy allocator there while still skipping
the IR pipeline. Add m1-o0.ll and m1-global.ll.
When a global is requested for definition but a definition with the same
mangled name already exists, return it as is instead of creating a fresh
global and erasing the defined one, even if its type differs from the
requested type.
The type can legitimately differ when the initializer folded to a
different (e.g. anonymous) type, as happens with unions. Erasing the
defined global dangles pointers held by callers, e.g. the
`AssociatedData` of entries in `llvm.global_ctors`, leading to a
use-after-free crash during `EmitCtorList`. This also keeps the
deferred-decls "already emitted" check sound, since it queries with
`IsForDefinition`, which must be non-destructive.
Add a header-unit regression test: an inline variable with an
anonymous-union member, constant-initialized but requiring dynamic
destructor registration, must be emitted exactly once when imported from
header units. The folded initializer has an anonymous type that differs
from the declared type; a second emission used to replace (and erase)
the already-defined global, leaving a dangling pointer in
`llvm.global_ctors` (use-after-free, observable as a crash under ASan).
Assisted-By: Meta Muse 1.3
Co-authored-by: Michael Park <mcypark@gmail.com>
(cherry picked from commit 2a6fdac960de3a6bae854474f12e8f1edfcd9a04)
This follows up to https://github.com/llvm/llvm-project/pull/207966 in order to transforms type
constraints with a ForConstraintSubstitution flag.
Assisted-by: Codex
(cherry-picked from 93c463319ebcb57e82f0c87c813a9ead536fb952)
Each execution of an alloca creates a new allocation, distinct from the
allocations of all other executions. They must not be merged, either by
CSE or via isUniformAcrossVFsAndUFs.
Update those to explicitly handle Alloca recipes.
Fixes https://github.com/llvm/llvm-project/issues/229389.
PR: https://github.com/llvm/llvm-project/pull/229929
(cherry picked from commit 95ea23b7d5b06c60c513c575577d5b7d0ed15721)
The OpenBSD Host code used FreeBSD-style sysctl MIBs, which don't
match OpenBSD's interface, so process lookups failed.
- GetOpenBSDProcessArgs: use {CTL_KERN, KERN_PROC_ARGS, pid,
KERN_PROC_ARGV}. OpenBSD returns a NULL-terminated argv array
whose pointers point into the returned buffer, so iterate it
directly.
- GetOpenBSDProcessUserAndGroup, FindProcessesImpl: KERN_PROC
takes a 6-element MIB on OpenBSD, with the kinfo_proc element
size and element count as the last two entries.
(cherry picked from commit b880f44cbad751b0784a5fbbfbdaacea25e167f8)
Fixes#233318
Before this change, we were restoring some callee-saved registers twice
when using save/restore libcalls with shadow call stack (SCS), and the
second restore was happening after the stack was deallocated using the
wrong register and offset calculation, which was causing lots of access
problems.
The problems were:
- We were using the entire list of Callee Saves rather than just the
subset that would have been restored by the libcall. This caused
duplicate restores because of how the CSI subsetting works.
- We were not using the correct offset calculation in
eliminateFrameIndex, which was causing us to calculate the wrong
address for the saves/restores.
Assisted-by: AI
Co-authored-by: Mitch Briles <mitchbriles@gmail.com>
This primarliy applies to the save-restore case, which was using
`__riscv_restore_<N>` incorrectly, entirely circumventing the software
shadow call stack.
This fix keeps the code size improvements of `__riscv_save_<N>` when
there is a shadow call stack, but it avoids the incorrect use of
`__riscv_restore_<N>`, instead emitting the correct sequence inline.
In the future, when there are better versions of `__riscv_save_<N>` and
`__riscv_restore_<N>` which support the shadow call stack variants (both
hardware and software), then we can revisit this approach and use the
correct pairs in all cases.
`TargetLowering::expandABD` expands `abd(a, b)` to `abs(sub(a, b))` when
`willNotOverflowSub` says the sub can't overflow. For `abdu` without
known
non-negative operands, this checks for unsigned overflow, which only
proves
`a >= b (unsigned)`, so `abdu(a, b) == sub(a, b)`. adding abs around it
is wrong, when the
difference is greater than INT_MAX, e.g. `abdu(lshr(x, 1), or(y,
INT_MIN))`.
Keep abs(sub) for the signed check (abds, or abdu with non-negative
operands) and use just sub when abdu and `a >= b`.
Fixes#233087.
(cherry picked from commit f16dbe0ec4b653736148c78bebdefcfe1c88198e)
alignof(std::max_align_t) is 4 on NetBSD/i386, whose <stddef.h> defines
max_align_t as a union of void *, long double, and long long.
Fix#230782
(cherry picked from commit 0b6b6ed806536c1b170101061ff3eeed91c8f061)
The OpenMP spec has a bug: the restriction should read
> If linear-modifier is ref, list items must not be polymorphic variables,
> assumed-shape arrays, or variables with the ALLOCATABLE attribute.
---------
Co-authored-by: Markus Mützel <markus.muetzel@gmx.de>
(cherry picked from commit 53d096bbf31d12fddbbe2508b7f80bab9628430d)
`clang++` defaults to `-stdlib=libc++` on OpenBSD. When building with both
`clang` and `libcxx` included, the freshly built `clang++` uses the system
version of the `libc++` headers. However, this is from the bundled `libc++`
22.1.8, thus inconsistent with the `libc++` being built.
OpenBSD has its own version of addLibCxxIncludePaths which just includes
`/usr/include/c++/v1`.
This patch removes OpenBSD::addLibCxxIncludePaths in favour of the generic
version in `Gnu.cpp`.
(cherry picked from commit 1204f6b4e9d6bef8ec319d121942dca5cbf94a26)
When accumulator recursion elimination rewrites the accumulator
instruction to use the accumulator PHI (and clones it at each return in
`cleanupAndFinalize()`), its operands change, so poison-generating
annotations derived from the original operands may no longer hold. Only
flags were dropped so far (#200624); return attributes like `range()`
and metadata like `!range` were kept.
In the reproducer from the issue, `umax(%r, 1)` carries `range(i8 1,
3)`, and the per-return copy `umax(%accumulator.tr, %k)` kept it
although it can return 0, so `-O2` inferred `range(i8 1, 3)` for the
whole function (miscompiling the Rust code linked in the issue).
This patch uses `dropPoisonGeneratingAnnotations()` instead of
`dropPoisonGeneratingFlags()`.
Fixes#233085
(cherry picked from commit 21c1bcd7059ca56dee6bc377e60a06a3b18a1d69)
`optimizeExtUses` rewrites uses of an extension's source in other blocks
to read `trunc` of the extension, which is only correct where the
extension isn't `poison`. A `zext nneg` can be valid only where it was
originally used, like behind a check that its source isn't negative. If
that check is one of the rewritten uses, it ends up reading `poison`,
and on `x86_64-pc-windows-msvc`, InstSimplify in WinEHPrepare's cleanup
folds it to true and causes a miscompile.
Drop the extension's poison-generating flags once a use has been
rewritten, like #72103 and #90382 did for similar cases in
`CodeGenPrepare`.
Fixes#234098.
(cherry picked from commit 93fccabb4ebc82695475eaaa279ea5fbb2265450)
When an HTTP request fails while it already received some data, the
cached file stream is never committed. Destroying it in that state
raises a fatal error, crashing the program (see #184728).
This PR adds an `abort` method that should be called in this situation
before destroying the stream. For the default implementation, only the
output stream is closed. For the `CacheStream` in `llvm::localCache`,
the temporary file is discarded as well.
The test is based on David's reproducer. Since WinHttp seems to discard
the content-length header, I switched to timing out the response
instead.
Fixes#184728. This is still a bug for the symstore locator in lldb, but
I'll fix that in a followup.
fix: disable test partial-response.test on system-windows
…tion
Currently DECLARE_SIMD emits a "not yet implemented" error in the MLIR
to LLVM IR translation.
DECLARE_SIMD is a hint to the compiler and ignoring it is technically
speaking a conforming implementation (although obviously not desirable).
Do not abort compilation when DECLARE_SIMD is encountered, but emit a
warning that it's currently ignored.
(cherry picked from commit 5ca62fdee645ec253263e41a45fe626c6b66be22)
Fixes: https://github.com/llvm/llvm-project/issues/234108
Split the transform into 2 phases:
1. narrow all users of all IVs
2. replace wide IVs if all users are scalar.
Together with removing the old, wide recipes, this allows us to catch
slightly more cases.
PR: https://github.com/llvm/llvm-project/pull/217765
(cherry picked from commit 932f5d22df7775f7cb65befd62053c0e93448959)
(cherry picked from commit a3ac001f673a87a014ecd6bf7ca11cc8b1cb576d)
I enabled agent clusters in BuildKite since unclustered agents are not
supported anymore. As part of that, I created a new libcxx-builders-arm
queue to replace the existing queue. This patch switches the pipeline
definition so that new jobs start targeting the new queue with clustered
agents.
(cherry picked from commit 01edf187213105e35db8aef724a63f86241b6bd4)
The API endpoint for getting a release does not work for draft releases,
so we need to fetch all the releases instead and manually search for the
one to update.
(cherry picked from commit b91e6c58859e60b5dd22a57aafbbec9764343cce)
Only mark v4i64 and v8i64 [SU]MUL_LOHI as Custom in 64-bit mode. Their
custom lowering unrolls to scalar i64 operations, whose results cannot
be expanded by the type legalizer on 32-bit targets.
Add crash regression coverage for signed division and remainder by
positive and negative constants with AVX2, AVX512F, and AVX512DQ+VL.
Fixes#228656
(cherry picked from commit e3e894a951586e653dd7910cad39804cb30ce9fd)
nuw/nsw/disjoint flags are only true at the original width. G_ANYEXT
leaves the new high bits unconstrained, so they must be dropped.
(cherry picked from commit e775aaa9724f52735285f555db534d12166715e7)
When converting select to min/max intrinsics we have to be careful about
poison-propagation, because min/max propagate unconditionally, while
select does not. Normally, this is not a problem, because the select
arms are also used in the select condition, which propagates
unconditionally.
However, SPF also matches special patterns where this may not be the
case. In particular, for `(X <u C1) ? C1 : UMIN(X, C2) ==> UMAX(UMIN(X,
C2), C1)` style transforms, if the inner min/max has poison-generating
annotations, the result can be more-poisonous.
I'm fixing this in a somewhat hacky way, by dropping the poison
annotations as part of SPF canonicalization. This makes assumptions
about the kind of patterns SPF matches. Originally, I wanted to just
move this code out of SPF into a dedicated InstCombine fold, but this
did not work around because SPF also handles cases with casts in
between, and I did not want to replicate that logic.
For https://github.com/rust-lang/rust/issues/163728.
(cherry picked from commit 4662c4a4f6d119a2daaa0c60430f611f8251f5a3)
Fixes errors such as
ld.lld: error: undefined symbol: compiler_rt.rem_pio2.rem_pio2
>>> referenced by compiler_rt
>>>
/home/alexrp/.cache/zig/o/a0062b09f46a198885da4835be133933/compiler_rt_zcu.o:(tan)
in archive
/home/alexrp/.cache/zig/o/a0062b09f46a198885da4835be133933/libcompiler_rt.a
which would happen because the actual symbol is
`$compiler_rt.rem_pio2.rem_pio2` for O32 or
`.Lcompiler_rt.rem_pio2.rem_pio2` for N64/N32.
(cherry picked from commit f93c537b4d5e128c3bc447a9e290f8c97b274e2d)
As with 85b4fbfecb65cd1f5a06e707e7ec0fc2de562407, this seems to be
another case where the backend was treating private functions
differently for no apparent reason.
This was particularly problematic for building the Zig compiler with
LLVM linked statically because we'd have enough such calls that linking
failed with thousands of these errors:
relocation R_MIPS_CALL16 out of range: 76048 is not in [-32768, 32767]
(cherry picked from commit 22371aefb10a31207de828cff7ef7511e9a552f7)
arti
Yuxuan Chen
Yuxuan Chen
Mishmish Dev
Jeremy Morse
Florian Hahn
Mishmish Dev
Brad Smith
Sam ElliottandMitch Briles
DaKnig
Fangrui Song
Ramkumar Ramachandra
Krzysztof Parzyszek
Tavva Dinesh Reddy
dyslexicsteak
Folkert de Vries
Nerixyz
Louis Dionne
Tobias Hieta
Tom Stellard
Rito Takeuchi
Hongyu
Nikita Popov
Alex Rønne Petersen