remove_if that its predicate is adaptable. We don't actually need this,
we can write a generic adapter for any predicate.
This lets us remove some very wrong std::function usages. We should
never be using std::function for predicates to algorithms. This incurs
an *indirect* call overhead for every evaluation of the predicate, and
makes it very hard to inline through.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@202742
91177308-0d34-0410-b5e6-
96231b3b80d8
set_type &set_;
public:
- typedef typename UnaryPredicate::argument_type argument_type;
-
TestAndEraseFromSet(UnaryPredicate P, set_type &set_) : P(P), set_(set_) {}
- bool operator()(argument_type Arg) {
+ template <typename ArgumentT>
+ bool operator()(const ArgumentT &Arg) {
if (P(Arg)) {
set_.erase(Arg);
return true;
// If the call might load from any of our allocas, then any store above
// the call is live.
- std::function<bool(Value *)> Pred = [&](Value *I) {
+ DeadStackObjects.remove_if([&](Value *I) {
// See if the call site touches the value.
AliasAnalysis::ModRefResult A =
AA->getModRefInfo(CS, I, getPointerSize(I, *AA));
return A == AliasAnalysis::ModRef || A == AliasAnalysis::Ref;
- };
- DeadStackObjects.remove_if(Pred);
+ });
// If all of the allocas were clobbered by the call then we're not going
// to find anything else to process.
// Remove the deleted allocas from various lists so that we don't try to
// continue processing them.
if (!DeletedAllocas.empty()) {
- std::function<bool(AllocaInst *)> IsInSet = [&](AllocaInst *AI) {
+ auto IsInSet = [&](AllocaInst *AI) {
return DeletedAllocas.count(AI);
};
Worklist.remove_if(IsInSet);