[BoundsSafety][NFC] Hold LateParsedTypeAttrInfo in declarator late-attribute lists (#239050)
Make DeclSpec, Declarator and DeclaratorChunk hold a SmallVector of
LateParsedTypeAttrInfo * instead of a LateParsedAttrList.
LateParsedAttrList has inline storage for two pointers plus flags, which
makes DeclaratorChunk larger. That may have caused the compile-time
regression in #238909. The new list has no inline storage.
Sema also only has the definition of LateParsedTypeAttrInfo, not of
LateParsedAttribute. Holding the former lets Sema build the type
directly, without a callback into the parser.
No functional change: nothing populates or reads these lists yet.
Assisted-by: Sonnet 5.5
[CMake] Apply LLVM warning policy per target instead of via CMAKE_<LANG>_FLAGS
HandleLLVMOptions.cmake appends LLVM's warning, suppression and `-Werror`
options to `CMAKE_C_FLAGS` and `CMAKE_CXX_FLAGS`. Those are language-wide, so
every target in the build tree inherits LLVM's diagnostic policy, including
unrelated projects embedded next to LLVM (`LLVM_EXTERNAL_PROJECTS`,
`add_subdirectory`) and third-party code, even if they only link an LLVM
library. LLVM's policy prefers, for example, exhaustive enum switches without
`default` and enables `-Wcovered-switch-default` accordingly; a project with
a different style should not have that imposed on it just because it shares a
build tree.
The policy is now collected in `LLVM_WARNING_OPTIONS_C/CXX` lists and attached
as `PRIVATE` compile options by `llvm_update_compile_flags()`, so it applies to
targets made with `llvm_add_library`, `add_llvm_executable`, tablegen tools,
plugins and unit tests, but is not exported and does not reach consumers.
`llvm_apply_warning_options(<target>)` lets other LLVM-owned targets opt in.
Subprojects that adjust the policy should use `llvm_add_warning_options()`
rather than append to `CMAKE_<LANG>_FLAGS`, which now precedes LLVM's options
[25 lines not shown]
[libc] Major docs refresh (#241609)
This was made as an attempt to write down as much of what I know about
LLVM-libc as possible. The process involved using an LLM agent to
interview me about what wasn't clear from the codebase and then write
docs based on my answers. After that were several rounds of revisions
where I tweaked phrasing and corrected more issues. The final documents
are an accurate reflection of my understanding of the state of
LLVM-libc.
Assisted-by: Automated tooling, human reviewed.
[Offload][AMDGPU] Set SDMA for AMDGPU (#241577)
Following https://github.com/llvm/llvm-project/pull/239816, apply the
SDMA value that we current used downstream. It will make the
configuration more consistent between upstream/downstream.
RuntimeLibcalls: Drop errno effects on targets without math errno
Teach the triple about targets which never support writing errno from
math functions. This is distinct from clang's -fno-math-errno default,
which is also enabled on some targets whose libm can set errno, such
as NetBSD. In the future we could add a no-math-errno module flag, but
that would exacerbate an existing bug where linking a -fno-math-errno
TU into a -fmath-errno TU will implicitly take the first linked
module's setting.
To do this make math errno a separate libcall property instead of
directly encoding it in the memory effects. This is necessary because
of non-math errno users.
Co-authored-by: Claude Opus 5.5 <noreply at anthropic.com>
RuntimeLibcalls: Mark noreturn and pure helper libcalls (#241627)
Mark the functions which never return as noreturn. Add some nounwind
and cold, mostly following inferLibFuncAttributes. Mark
misc. functions as pure.
Co-authored-by: Claude Opus 5.5 <noreply at anthropic.com>
[X86][APX] Test the relocation of an NF add
test_regclass_not_updated_by_regalloc_2 only produced an NDD/NF add
with a GOT operand because the allocator happened to give the add a
destination different from its source. With SlotIndexes compaction it
picks the same register, so the add is compressed to the legacy form
and the CODE_6 TODO lost its test.
Add a function whose add keeps its source live, so it stays NDD and
becomes NF under any allocation.
[X86] Enable SlotIndexes compaction by default
Compacting SlotIndexes before greedy allocation drops the entries of
erased instructions, so live range sizes and instruction distances
reflect the code being allocated rather than how much was erased
before it. AMDGPU has done this since #235806; do the same for X86.
Codegen changes only through allocation: no new crashes, verifier
errors or allocation failures in the lit suites, including
EXPENSIVE_CHECKS, and a stage-2 build of LLVM, clang and lld with
-verify-machineinstrs passes its own tests. On llvm-test-suite at -O3,
spills drop 0.3% and .text 0.06%, with compile time unchanged.
Most test updates are regenerated checks. misched-matmul now inserts
20 spills instead of 24. live-debug-vars-stale-slotindexes.mir gets
one more use of %27 so that accumulate_fit still reaches the stale
index path it was written for.
[AArch64] Avoid folding SRA/SRL into ALU when it can be folded with SHL/AND (#234737)
For the following function
```
int f(int a, int b) {
b -= (a<<26)>>29;
return b;
}
```
LLVM currently generates
```
f:
lsl w8, w0, #26
sub w0, w1, w8, asr #29
ret
```
However, if we don't fold the `asr` into the `sub`, the `asr` can be
folded with the `lsl` instead, and we can avoid generating the
[10 lines not shown]
[clang] fixup -Wunused-private-field (#244427)
-Wunused-private-field will soon be able to flag fields in instantiated
class templates. Land this in preparation.
Link: #237374
Link: #244396
RegisterCoalescer: Drop unused value numbers after joining
Erasing a pruned IMPLICIT_DEF marks its value number unused but leaves
it in NewVNInfo, and LiveRange::join only skipped null entries, so the
joined range kept a dead value number. Skip unused entries in join and
size valnos to the number actually kept. pruneSubRegValues similarly
only marked the pruned subrange value unused, so remove it instead.
The resulting live intervals now will have the same value numbers as a
fresh LiveIntervals computation.
Co-authored-by: Claude Opus 5.5 <noreply at anthropic.com>
RuntimeLibcalls: Add attributes to fenv libcalls
Treat the fp environment as inaccessible memory.
Co-authored-by: Claude Opus 5.5 <noreply at anthropic.com>
[TTI] Return zero when query getRegUsageForType() with invalid type. (#243811)
This patch makes `getRegUsageForType()` returns 0 when the type is
invalid.
With this changes, we can remove the type legalization check for
scalable vector (`isElementTypeLegalForScalableVector()`) in the
VPlan-based register model. This allows `i1` scalable vector for RISC-V
can be calculated.
The reason that we don't want to accept `i1` in the
`isElementTypeLegalForScalableVector()` in RISC-V is because this
function also being used to decide if the loop can be scalable
vectorized and RISC-V don't support scalable `i1` vector load/store.
This patch partially fixes
https://github.com/llvm/llvm-project/issues/243706.
The register spill count is close to the generated assembly.
Pruned the test case with AI assistance.
[libc] Fix strtof128_test and GPU shared str_to_float build failures (#244436)
Fix two post-merge buildbot failures after #243955:
1. Define the fallback `float128` alias in `strtof128_test.cpp` when
`LIBC_TYPES_HAS_NATIVE_FLOAT128` is not set (e.g. Clang < 18.1 on
x86_64).
2. Avoid pulling `FPUtil/float128.h` (and transitively `FEnvImpl.h`)
into `str_to_float.h` by turning `ClingerConsts<fputil::Float128>` into
a dependent partial specialization, and undefine
`LIBC_MATH_USE_SYSTEM_FENV` on `LIBC_TARGET_ARCH_IS_GPU` in `FEnvImpl.h`
since GPU targets do not provide system `<fenv.h>` functions.
Also clean up direct includes and sync CMake and Bazel dependencies.
Assisted-by: Gemini
RuntimeLibcalls: Add attributes to libc libcalls
Annotate C library functions with the attributes InferFunctionAttrs
gives. This isn't fully captured in the DeclareRuntimeLibcalls testing
because not all of these functions are yet associated with a library.
Co-authored-by: Claude Opus 5.5 <noreply at anthropic.com>
RuntimeLibcalls: Add attributes to target memory helper libcalls
Annotate the various target specific memcpy-like functions with known
alignments.
Co-authored-by: Claude Opus 5.5 <noreply at anthropic.com>
RuntimeLibcalls: Mark noreturn and pure helper libcalls
Mark the functions which never return as noreturn. Add some nounwind
and cold, mostly following inferLibFuncAttributes. Mark
misc. functions as pure.
Co-authored-by: Claude Opus 5.5 <noreply at anthropic.com>
RuntimeLibcalls: Add attributes inferLibFuncAttributes gives libcalls (#241618)
Remove more differences with the attributes the InferFunctionAttrs
pass would add to the declared libcalls.
Co-authored-by: Claude Opus 5.5 <noreply at anthropic.com>
[lldb] Don't crash on a PE image read from memory that llvm::object rejects (#241902)
ObjectFilePECOFF::CreateMemoryInstance builds an object file from the
512 bytes lldb reads at a module's header address. ParseHeader can parse
the headers and section table from that, but
llvm::object::COFFObjectFile often can't; the export table and other
data directories point past the end of the buffer. CreateInstance
rejects a file whose binary can't be created, but CreateMemoryInstance
keeps the object, and m_binary stays null.
ParseSymtab, GetSectionDataSize and GetTlsIndexAddress dereference
m_binary without checking it. Loading such a module makes lldb look for
its symbol file, which parses the symbol table and crashes in
AppendFromExportTable. Check the binary there, as GetUUID and
ParseDependentModules already do.
Meta hit this with a Linux core of a .NET process. .NET assemblies are
PE files, the process maps them as plain files, and the core saved the
first page of one of them. Creating a module from that memory with
[3 lines not shown]
[dsymutil] Undo prefix mapping before resolving paths for ODR uniquing (#242437)
The classic linker resolves the declaration file of a type with
realpath() to tell apart types with the same name, line and size. For
paths remapped by compilation caching, which don't exist on disk,
realpath() fails and only the file name is left, so different types
declared in headers with the same name in different directories were
merged. Undo the prefix mapping from compilation-prefix-map.json first.
[dsymutil] Support compilation-prefix-map.json from compilation caching (#242436)
Compilation caching can prefix map the paths that the compiler sees, so
that cache keys don't depend on where the build happens, for example
/path/to/project becomes /^src. The build system records the mapping in
a compilation-prefix-map.json file in a parent directory of the object
files, as a JSON object from each remapped prefix to the original one.
dsymutil didn't support it, so it used the remapped paths from the
debug info as is: it failed to copy the Swift interfaces that the debug
info refers to, didn't recognize interfaces from the SDK or the
toolchain that it should skip, and wrote the remapped paths into the
dSYM.
Load the compilation-prefix-map.json closest to each object file, and
use it to find Swift interfaces and Clang modules, and to restore the
original paths in the path attributes and line tables of the linked
debug info. Clang modules use the map of the object file that refers to
them. -object-prefix-map still only applies to looking up Clang
[5 lines not shown]
[Support] Add vfs::findFileInParentDirectories() (#242492)
Several tools look for a file in a directory and its parent
directories, for example clang-format for .clang-format and clang-tidy
for .clang-tidy, and each has its own loop for that. Add a function for
it, which dsymutil will use to find the compilation-prefix-map.json
files that compilation caching writes.
[Support] Add PrefixMapper (#242491)
Add a utility for remapping path prefixes, along with MappedPrefix for
parsing "old=new" mappings. Mappings are matched on whole path
components and respect the configured path style, so Windows paths are
matched case- and separator-insensitively.
This will be used by dsymutil to undo the path prefix mapping applied
by compilation caching.