[TableGen] Combine FactorNodes and FactorScope. NFC
These were separated in 31db7afacf4dae051fcd0da22e440813663b61f3
due to the complexity of the rebindable unique_ptr. With the
switch to MatcherList, the code is not as complicated.
Reapply "[TableGen] Introduce MatcherList to manage a linked list of Matchers. NFC (#177875)"
With fixes to the slice_after functions to avoid dereferencing the
before_begin() iterator. Deferencing the iterator casts a pointer
to the BeforeBegin object to Matcher*, but the BeforeBegin object
is not a Matcher. This caused a failure when built with gcc.
Original commit message:
The previous memory management involved passing around references to the
std::unique_ptr next pointer in each Matcher. Scopes and
SwitchOpcode/SwitchType did not use std::unique_ptr internally, but
would sometimes need to have the pointers to their children moved to
temporary std::unique_ptrs that may be modified and then put back into
the Scope/Switch. Other code used manual deletion.
This patch introduces a MatcherList object that encapsulates list
management and ownership. The interface is based on std::forward_list
using the libcxx implementation for reference.
[15 lines not shown]
[ELF,PPC64] Inline toAddr16Rel and TLS remapping into the main relocate switch
Delete the toAddr16Rel helper and the GOT_TLS-to-GOT16 remapping switch,
inlining their val adjustments as fallthrough cases in the main switch.
This reduces relocate() from 4 switches on type to 2 (TLS relaxation
pre-switch with early returns, and the unified write switch).
catch up with hyperfb:
- track writes to SBA/DBA/BAboth
- use BINC writes to draw anti-aliased characters instead of direct fb access
- some magic number reduction
[ADT] Fix RadixTree singular iterator use in findOrCreate (#181510)
The root node's Key is initialized with default-constructed (singular)
iterators. When findOrCreate calls llvm::mismatch(Key, Curr->Key) on the
first loop iteration where Curr is the root, these singular iterators
are passed to std::mismatch. _GLIBCXX_DEBUG correctly rejects them as
not forming a valid iterator range.
Skip the mismatch when Curr is the root node since its key is
conceptually empty, making the mismatch a no-op.
Fixes a test failure in ADTTests/RadixTreeTypeTest introduced by
5fda2a5d9c1a ("[NFC][ADT] Add RadixTree (#164524)").
[LV] Fix strict weak ordering violation in handleUncountableEarlyExits sort (#181462)
The sort comparator used VPDT.dominates() which returns true for
dominates(A, A), violating the irreflexivity requirement of strict weak
ordering. With _GLIBCXX_DEBUG enabled (LLVM_ENABLE_EXPENSIVE_CHECKS=ON),
std::sort validates this property and aborts:
Error: comparison doesn't meet irreflexive requirements, assert(!(a <
a)).
Use properlyDominates() instead, which correctly returns false for equal
inputs while preserving the intended dominance-based ordering.
This fixes a crash introduced by ede1a9626b89 ("[LV] Vectorize early
exit loops with multiple exits.").
[clang-tidy] Fix false positive for generic lambda parameters in readability-non-const-parameter (#179051)
Fixes #177354
### Summary
The `readability-non-const-parameter` check produces false positives on
generic lambda parameters, not fully resolved by #177345.
### Problem
Generic lambdas with explicit template parameters create dependent
contexts that cannot be analyzed at parse time:
```cpp
auto lambda = []<typename T>(int *p) {
T x(*p); // No longer warns
};
```
[RFC][IR] Remove `Constant::isZeroValue`
`Constant::isZeroValue` currently behaves same as `Constant::isNullValue` for
all types except floating-point, where it additionally returns true for negative
zero (`-0.0`). However, in practice, almost all callers operate on
integer/pointer types where the two are equivalent, and the few FP-relevant
callers have no meaningful dependence on the `-0.0` behavior.
This PR removes `isZeroValue` to eliminate the confusing API surface. All
callers are changed to `isNullValue` with no test failures.
`isZeroValue` will be reintroduced in a future change with clearer semantics:
when null pointers may have non-zero bit patterns, `isZeroValue` will check for
bitwise-all-zeros, while `isNullValue` will check for the semantic null (which
may be non-zero).
