288 changes: 77 additions & 211 deletions llvm/lib/Transforms/IPO/AttributorAttributes.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -383,7 +383,7 @@ getMinimalBaseOfPointer(Attributor &A, const AbstractAttribute &QueryingAA,
/// Clamp the information known for all returned values of a function
/// (identified by \p QueryingAA) into \p S.
template <typename AAType, typename StateType = typename AAType::StateType,
Attribute::AttrKind IRAttributeKind = Attribute::None,
Attribute::AttrKind IRAttributeKind = AAType::IRAttributeKind,
bool RecurseForSelectAndPHI = true>
static void clampReturnedValueStates(
Attributor &A, const AAType &QueryingAA, StateType &S,
Expand All @@ -406,7 +406,7 @@ static void clampReturnedValueStates(
auto CheckReturnValue = [&](Value &RV) -> bool {
const IRPosition &RVPos = IRPosition::value(RV, CBContext);
// If possible, use the hasAssumedIRAttr interface.
if (IRAttributeKind != Attribute::None) {
if (Attribute::isEnumAttrKind(IRAttributeKind)) {
bool IsKnown;
return AA::hasAssumedIRAttr<IRAttributeKind>(
A, &QueryingAA, RVPos, DepClassTy::REQUIRED, IsKnown);
Expand Down Expand Up @@ -440,7 +440,7 @@ namespace {
template <typename AAType, typename BaseType,
typename StateType = typename BaseType::StateType,
bool PropagateCallBaseContext = false,
Attribute::AttrKind IRAttributeKind = Attribute::None,
Attribute::AttrKind IRAttributeKind = AAType::IRAttributeKind,
bool RecurseForSelectAndPHI = true>
struct AAReturnedFromReturnedValues : public BaseType {
AAReturnedFromReturnedValues(const IRPosition &IRP, Attributor &A)
Expand All @@ -461,7 +461,7 @@ struct AAReturnedFromReturnedValues : public BaseType {
/// Clamp the information known at all call sites for a given argument
/// (identified by \p QueryingAA) into \p S.
template <typename AAType, typename StateType = typename AAType::StateType,
Attribute::AttrKind IRAttributeKind = Attribute::None>
Attribute::AttrKind IRAttributeKind = AAType::IRAttributeKind>
static void clampCallSiteArgumentStates(Attributor &A, const AAType &QueryingAA,
StateType &S) {
LLVM_DEBUG(dbgs() << "[Attributor] Clamp call site argument states for "
Expand All @@ -486,7 +486,7 @@ static void clampCallSiteArgumentStates(Attributor &A, const AAType &QueryingAA,
return false;

// If possible, use the hasAssumedIRAttr interface.
if (IRAttributeKind != Attribute::None) {
if (Attribute::isEnumAttrKind(IRAttributeKind)) {
bool IsKnown;
return AA::hasAssumedIRAttr<IRAttributeKind>(
A, &QueryingAA, ACSArgPos, DepClassTy::REQUIRED, IsKnown);
Expand Down Expand Up @@ -520,7 +520,7 @@ static void clampCallSiteArgumentStates(Attributor &A, const AAType &QueryingAA,
/// context.
template <typename AAType, typename BaseType,
typename StateType = typename AAType::StateType,
Attribute::AttrKind IRAttributeKind = Attribute::None>
Attribute::AttrKind IRAttributeKind = AAType::IRAttributeKind>
bool getArgumentStateFromCallBaseContext(Attributor &A,
BaseType &QueryingAttribute,
IRPosition &Pos, StateType &State) {
Expand All @@ -535,7 +535,7 @@ bool getArgumentStateFromCallBaseContext(Attributor &A,
const IRPosition CBArgPos = IRPosition::callsite_argument(*CBContext, ArgNo);

// If possible, use the hasAssumedIRAttr interface.
if (IRAttributeKind != Attribute::None) {
if (Attribute::isEnumAttrKind(IRAttributeKind)) {
bool IsKnown;
return AA::hasAssumedIRAttr<IRAttributeKind>(
A, &QueryingAttribute, CBArgPos, DepClassTy::REQUIRED, IsKnown);
Expand All @@ -561,7 +561,7 @@ bool getArgumentStateFromCallBaseContext(Attributor &A,
template <typename AAType, typename BaseType,
typename StateType = typename AAType::StateType,
bool BridgeCallBaseContext = false,
Attribute::AttrKind IRAttributeKind = Attribute::None>
Attribute::AttrKind IRAttributeKind = AAType::IRAttributeKind>
struct AAArgumentFromCallSiteArguments : public BaseType {
AAArgumentFromCallSiteArguments(const IRPosition &IRP, Attributor &A)
: BaseType(IRP, A) {}
Expand Down Expand Up @@ -591,34 +591,38 @@ struct AAArgumentFromCallSiteArguments : public BaseType {
template <typename AAType, typename BaseType,
typename StateType = typename BaseType::StateType,
bool IntroduceCallBaseContext = false,
Attribute::AttrKind IRAttributeKind = Attribute::None>
struct AACallSiteReturnedFromReturned : public BaseType {
AACallSiteReturnedFromReturned(const IRPosition &IRP, Attributor &A)
: BaseType(IRP, A) {}
Attribute::AttrKind IRAttributeKind = AAType::IRAttributeKind>
struct AACalleeToCallSite : public BaseType {
AACalleeToCallSite(const IRPosition &IRP, Attributor &A) : BaseType(IRP, A) {}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
assert(this->getIRPosition().getPositionKind() ==
IRPosition::IRP_CALL_SITE_RETURNED &&
"Can only wrap function returned positions for call site returned "
"positions!");
auto IRPKind = this->getIRPosition().getPositionKind();
assert((IRPKind == IRPosition::IRP_CALL_SITE_RETURNED ||
IRPKind == IRPosition::IRP_CALL_SITE) &&
"Can only wrap function returned positions for call site "
"returned positions!");
auto &S = this->getState();

const Function *AssociatedFunction =
this->getIRPosition().getAssociatedFunction();
if (!AssociatedFunction)
return S.indicatePessimisticFixpoint();

CallBase &CBContext = cast<CallBase>(this->getAnchorValue());
CallBase &CB = cast<CallBase>(this->getAnchorValue());
if (IntroduceCallBaseContext)
LLVM_DEBUG(dbgs() << "[Attributor] Introducing call base context:"
<< CBContext << "\n");
LLVM_DEBUG(dbgs() << "[Attributor] Introducing call base context:" << CB
<< "\n");

IRPosition FnPos = IRPosition::returned(
*AssociatedFunction, IntroduceCallBaseContext ? &CBContext : nullptr);
IRPosition FnPos =
IRPKind == llvm::IRPosition::IRP_CALL_SITE_RETURNED
? IRPosition::returned(*AssociatedFunction,
IntroduceCallBaseContext ? &CB : nullptr)
: IRPosition::function(*AssociatedFunction,
IntroduceCallBaseContext ? &CB : nullptr);

// If possible, use the hasAssumedIRAttr interface.
if (IRAttributeKind != Attribute::None) {
if (Attribute::isEnumAttrKind(IRAttributeKind)) {
bool IsKnown;
if (!AA::hasAssumedIRAttr<IRAttributeKind>(A, this, FnPos,
DepClassTy::REQUIRED, IsKnown))
Expand Down Expand Up @@ -2097,24 +2101,10 @@ struct AANoUnwindFunction final : public AANoUnwindImpl {
};

/// NoUnwind attribute deduction for a call sites.
struct AANoUnwindCallSite final : AANoUnwindImpl {
struct AANoUnwindCallSite final
: AACalleeToCallSite<AANoUnwind, AANoUnwindImpl> {
AANoUnwindCallSite(const IRPosition &IRP, Attributor &A)
: AANoUnwindImpl(IRP, A) {}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
// TODO: Once we have call site specific value information we can provide
// call site specific liveness information and then it makes
// sense to specialize attributes for call sites arguments instead of
// redirecting requests to the callee argument.
Function *F = getAssociatedFunction();
const IRPosition &FnPos = IRPosition::function(*F);
bool IsKnownNoUnwind;
if (AA::hasAssumedIRAttr<Attribute::NoUnwind>(
A, this, FnPos, DepClassTy::REQUIRED, IsKnownNoUnwind))
return ChangeStatus::UNCHANGED;
return indicatePessimisticFixpoint();
}
: AACalleeToCallSite<AANoUnwind, AANoUnwindImpl>(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_CS_ATTR(nounwind); }
Expand Down Expand Up @@ -2244,24 +2234,9 @@ struct AANoSyncFunction final : public AANoSyncImpl {
};

/// NoSync attribute deduction for a call sites.
struct AANoSyncCallSite final : AANoSyncImpl {
struct AANoSyncCallSite final : AACalleeToCallSite<AANoSync, AANoSyncImpl> {
AANoSyncCallSite(const IRPosition &IRP, Attributor &A)
: AANoSyncImpl(IRP, A) {}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
// TODO: Once we have call site specific value information we can provide
// call site specific liveness information and then it makes
// sense to specialize attributes for call sites arguments instead of
// redirecting requests to the callee argument.
Function *F = getAssociatedFunction();
const IRPosition &FnPos = IRPosition::function(*F);
bool IsKnownNoSycn;
if (AA::hasAssumedIRAttr<Attribute::NoSync>(
A, this, FnPos, DepClassTy::REQUIRED, IsKnownNoSycn))
return ChangeStatus::UNCHANGED;
return indicatePessimisticFixpoint();
}
: AACalleeToCallSite<AANoSync, AANoSyncImpl>(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_CS_ATTR(nosync); }
Expand Down Expand Up @@ -2313,24 +2288,9 @@ struct AANoFreeFunction final : public AANoFreeImpl {
};

/// NoFree attribute deduction for a call sites.
struct AANoFreeCallSite final : AANoFreeImpl {
struct AANoFreeCallSite final : AACalleeToCallSite<AANoFree, AANoFreeImpl> {
AANoFreeCallSite(const IRPosition &IRP, Attributor &A)
: AANoFreeImpl(IRP, A) {}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
// TODO: Once we have call site specific value information we can provide
// call site specific liveness information and then it makes
// sense to specialize attributes for call sites arguments instead of
// redirecting requests to the callee argument.
Function *F = getAssociatedFunction();
const IRPosition &FnPos = IRPosition::function(*F);
bool IsKnown;
if (AA::hasAssumedIRAttr<Attribute::NoFree>(A, this, FnPos,
DepClassTy::REQUIRED, IsKnown))
return ChangeStatus::UNCHANGED;
return indicatePessimisticFixpoint();
}
: AACalleeToCallSite<AANoFree, AANoFreeImpl>(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_CS_ATTR(nofree); }
Expand Down Expand Up @@ -2704,13 +2664,9 @@ struct AANonNullReturned final

/// NonNull attribute for function argument.
struct AANonNullArgument final
: AAArgumentFromCallSiteArguments<AANonNull, AANonNullImpl,
AANonNull::StateType, false,
AANonNull::IRAttributeKind> {
: AAArgumentFromCallSiteArguments<AANonNull, AANonNullImpl> {
AANonNullArgument(const IRPosition &IRP, Attributor &A)
: AAArgumentFromCallSiteArguments<AANonNull, AANonNullImpl,
AANonNull::StateType, false,
AANonNull::IRAttributeKind>(IRP, A) {}
: AAArgumentFromCallSiteArguments<AANonNull, AANonNullImpl>(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_ARG_ATTR(nonnull) }
Expand All @@ -2726,13 +2682,9 @@ struct AANonNullCallSiteArgument final : AANonNullFloating {

/// NonNull attribute for a call site return position.
struct AANonNullCallSiteReturned final
: AACallSiteReturnedFromReturned<AANonNull, AANonNullImpl,
AANonNull::StateType, false,
AANonNull::IRAttributeKind> {
: AACalleeToCallSite<AANonNull, AANonNullImpl> {
AANonNullCallSiteReturned(const IRPosition &IRP, Attributor &A)
: AACallSiteReturnedFromReturned<AANonNull, AANonNullImpl,
AANonNull::StateType, false,
AANonNull::IRAttributeKind>(IRP, A) {}
: AACalleeToCallSite<AANonNull, AANonNullImpl>(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_CSRET_ATTR(nonnull) }
Expand Down Expand Up @@ -2884,24 +2836,10 @@ struct AANoRecurseFunction final : AANoRecurseImpl {
};

/// NoRecurse attribute deduction for a call sites.
struct AANoRecurseCallSite final : AANoRecurseImpl {
struct AANoRecurseCallSite final
: AACalleeToCallSite<AANoRecurse, AANoRecurseImpl> {
AANoRecurseCallSite(const IRPosition &IRP, Attributor &A)
: AANoRecurseImpl(IRP, A) {}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
// TODO: Once we have call site specific value information we can provide
// call site specific liveness information and then it makes
// sense to specialize attributes for call sites arguments instead of
// redirecting requests to the callee argument.
Function *F = getAssociatedFunction();
const IRPosition &FnPos = IRPosition::function(*F);
bool IsKnownNoRecurse;
if (!AA::hasAssumedIRAttr<Attribute::NoRecurse>(
A, this, FnPos, DepClassTy::REQUIRED, IsKnownNoRecurse))
return indicatePessimisticFixpoint();
return ChangeStatus::UNCHANGED;
}
: AACalleeToCallSite<AANoRecurse, AANoRecurseImpl>(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_CS_ATTR(norecurse); }
Expand Down Expand Up @@ -3409,26 +3347,17 @@ struct AAWillReturnFunction final : AAWillReturnImpl {
};

/// WillReturn attribute deduction for a call sites.
struct AAWillReturnCallSite final : AAWillReturnImpl {
struct AAWillReturnCallSite final
: AACalleeToCallSite<AAWillReturn, AAWillReturnImpl> {
AAWillReturnCallSite(const IRPosition &IRP, Attributor &A)
: AAWillReturnImpl(IRP, A) {}
: AACalleeToCallSite<AAWillReturn, AAWillReturnImpl>(IRP, A) {}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
if (isImpliedByMustprogressAndReadonly(A, /* KnownOnly */ false))
return ChangeStatus::UNCHANGED;

// TODO: Once we have call site specific value information we can provide
// call site specific liveness information and then it makes
// sense to specialize attributes for call sites arguments instead of
// redirecting requests to the callee argument.
Function *F = getAssociatedFunction();
const IRPosition &FnPos = IRPosition::function(*F);
bool IsKnown;
if (AA::hasAssumedIRAttr<Attribute::WillReturn>(
A, this, FnPos, DepClassTy::REQUIRED, IsKnown))
return ChangeStatus::UNCHANGED;
return indicatePessimisticFixpoint();
return AACalleeToCallSite::updateImpl(A);
}

/// See AbstractAttribute::trackStatistics()
Expand Down Expand Up @@ -3851,12 +3780,8 @@ struct AANoAliasFloating final : AANoAliasImpl {

/// NoAlias attribute for an argument.
struct AANoAliasArgument final
: AAArgumentFromCallSiteArguments<AANoAlias, AANoAliasImpl,
AANoAlias::StateType, false,
Attribute::NoAlias> {
using Base = AAArgumentFromCallSiteArguments<AANoAlias, AANoAliasImpl,
AANoAlias::StateType, false,
Attribute::NoAlias>;
: AAArgumentFromCallSiteArguments<AANoAlias, AANoAliasImpl> {
using Base = AAArgumentFromCallSiteArguments<AANoAlias, AANoAliasImpl>;
AANoAliasArgument(const IRPosition &IRP, Attributor &A) : Base(IRP, A) {}

/// See AbstractAttribute::update(...).
Expand Down Expand Up @@ -4124,24 +4049,10 @@ struct AANoAliasReturned final : AANoAliasImpl {
};

/// NoAlias attribute deduction for a call site return value.
struct AANoAliasCallSiteReturned final : AANoAliasImpl {
struct AANoAliasCallSiteReturned final
: AACalleeToCallSite<AANoAlias, AANoAliasImpl> {
AANoAliasCallSiteReturned(const IRPosition &IRP, Attributor &A)
: AANoAliasImpl(IRP, A) {}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
// TODO: Once we have call site specific value information we can provide
// call site specific liveness information and then it makes
// sense to specialize attributes for call sites arguments instead of
// redirecting requests to the callee argument.
Function *F = getAssociatedFunction();
const IRPosition &FnPos = IRPosition::returned(*F);
bool IsKnownNoAlias;
if (!AA::hasAssumedIRAttr<Attribute::NoAlias>(
A, this, FnPos, DepClassTy::REQUIRED, IsKnownNoAlias))
return indicatePessimisticFixpoint();
return ChangeStatus::UNCHANGED;
}
: AACalleeToCallSite<AANoAlias, AANoAliasImpl>(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_CSRET_ATTR(noalias); }
Expand Down Expand Up @@ -5230,9 +5141,8 @@ struct AADereferenceableCallSiteArgument final : AADereferenceableFloating {

/// Dereferenceable attribute deduction for a call site return value.
struct AADereferenceableCallSiteReturned final
: AACallSiteReturnedFromReturned<AADereferenceable, AADereferenceableImpl> {
using Base =
AACallSiteReturnedFromReturned<AADereferenceable, AADereferenceableImpl>;
: AACalleeToCallSite<AADereferenceable, AADereferenceableImpl> {
using Base = AACalleeToCallSite<AADereferenceable, AADereferenceableImpl>;
AADereferenceableCallSiteReturned(const IRPosition &IRP, Attributor &A)
: Base(IRP, A) {}

Expand Down Expand Up @@ -5527,8 +5437,8 @@ struct AAAlignCallSiteArgument final : AAAlignFloating {

/// Align attribute deduction for a call site return value.
struct AAAlignCallSiteReturned final
: AACallSiteReturnedFromReturned<AAAlign, AAAlignImpl> {
using Base = AACallSiteReturnedFromReturned<AAAlign, AAAlignImpl>;
: AACalleeToCallSite<AAAlign, AAAlignImpl> {
using Base = AACalleeToCallSite<AAAlign, AAAlignImpl>;
AAAlignCallSiteReturned(const IRPosition &IRP, Attributor &A)
: Base(IRP, A) {}

Expand Down Expand Up @@ -5576,24 +5486,10 @@ struct AANoReturnFunction final : AANoReturnImpl {
};

/// NoReturn attribute deduction for a call sites.
struct AANoReturnCallSite final : AANoReturnImpl {
struct AANoReturnCallSite final
: AACalleeToCallSite<AANoReturn, AANoReturnImpl> {
AANoReturnCallSite(const IRPosition &IRP, Attributor &A)
: AANoReturnImpl(IRP, A) {}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
// TODO: Once we have call site specific value information we can provide
// call site specific liveness information and then it makes
// sense to specialize attributes for call sites arguments instead of
// redirecting requests to the callee argument.
Function *F = getAssociatedFunction();
const IRPosition &FnPos = IRPosition::function(*F);
bool IsKnownNoReturn;
if (!AA::hasAssumedIRAttr<Attribute::NoReturn>(
A, this, FnPos, DepClassTy::REQUIRED, IsKnownNoReturn))
return indicatePessimisticFixpoint();
return ChangeStatus::UNCHANGED;
}
: AACalleeToCallSite<AANoReturn, AANoReturnImpl>(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_CS_ATTR(noreturn); }
Expand Down Expand Up @@ -8130,24 +8026,10 @@ struct AAMemoryBehaviorFunction final : public AAMemoryBehaviorImpl {
};

/// AAMemoryBehavior attribute for call sites.
struct AAMemoryBehaviorCallSite final : AAMemoryBehaviorImpl {
struct AAMemoryBehaviorCallSite final
: AACalleeToCallSite<AAMemoryBehavior, AAMemoryBehaviorImpl> {
AAMemoryBehaviorCallSite(const IRPosition &IRP, Attributor &A)
: AAMemoryBehaviorImpl(IRP, A) {}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
// TODO: Once we have call site specific value information we can provide
// call site specific liveness liveness information and then it makes
// sense to specialize attributes for call sites arguments instead of
// redirecting requests to the callee argument.
Function *F = getAssociatedFunction();
const IRPosition &FnPos = IRPosition::function(*F);
auto *FnAA =
A.getAAFor<AAMemoryBehavior>(*this, FnPos, DepClassTy::REQUIRED);
if (!FnAA)
return indicatePessimisticFixpoint();
return clampStateAndIndicateChange(getState(), FnAA->getState());
}
: AACalleeToCallSite<AAMemoryBehavior, AAMemoryBehaviorImpl>(IRP, A) {}

/// See AbstractAttribute::manifest(...).
ChangeStatus manifest(Attributor &A) override {
Expand Down Expand Up @@ -9660,17 +9542,13 @@ struct AAValueConstantRangeCallSite : AAValueConstantRangeFunction {
};

struct AAValueConstantRangeCallSiteReturned
: AACallSiteReturnedFromReturned<AAValueConstantRange,
AAValueConstantRangeImpl,
AAValueConstantRangeImpl::StateType,
/* IntroduceCallBaseContext */ true> {
: AACalleeToCallSite<AAValueConstantRange, AAValueConstantRangeImpl,
AAValueConstantRangeImpl::StateType,
/* IntroduceCallBaseContext */ true> {
AAValueConstantRangeCallSiteReturned(const IRPosition &IRP, Attributor &A)
: AACallSiteReturnedFromReturned<AAValueConstantRange,
AAValueConstantRangeImpl,
AAValueConstantRangeImpl::StateType,
/* IntroduceCallBaseContext */ true>(IRP,
A) {
}
: AACalleeToCallSite<AAValueConstantRange, AAValueConstantRangeImpl,
AAValueConstantRangeImpl::StateType,
/* IntroduceCallBaseContext */ true>(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
Expand Down Expand Up @@ -10189,12 +10067,12 @@ struct AAPotentialConstantValuesCallSite : AAPotentialConstantValuesFunction {
};

struct AAPotentialConstantValuesCallSiteReturned
: AACallSiteReturnedFromReturned<AAPotentialConstantValues,
AAPotentialConstantValuesImpl> {
: AACalleeToCallSite<AAPotentialConstantValues,
AAPotentialConstantValuesImpl> {
AAPotentialConstantValuesCallSiteReturned(const IRPosition &IRP,
Attributor &A)
: AACallSiteReturnedFromReturned<AAPotentialConstantValues,
AAPotentialConstantValuesImpl>(IRP, A) {}
: AACalleeToCallSite<AAPotentialConstantValues,
AAPotentialConstantValuesImpl>(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
Expand Down Expand Up @@ -10382,26 +10260,18 @@ struct AANoUndefFloating : public AANoUndefImpl {
};

struct AANoUndefReturned final
: AAReturnedFromReturnedValues<AANoUndef, AANoUndefImpl,
AANoUndef::StateType, false,
Attribute::NoUndef> {
: AAReturnedFromReturnedValues<AANoUndef, AANoUndefImpl> {
AANoUndefReturned(const IRPosition &IRP, Attributor &A)
: AAReturnedFromReturnedValues<AANoUndef, AANoUndefImpl,
AANoUndef::StateType, false,
Attribute::NoUndef>(IRP, A) {}
: AAReturnedFromReturnedValues<AANoUndef, AANoUndefImpl>(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_FNRET_ATTR(noundef) }
};

struct AANoUndefArgument final
: AAArgumentFromCallSiteArguments<AANoUndef, AANoUndefImpl,
AANoUndef::StateType, false,
Attribute::NoUndef> {
: AAArgumentFromCallSiteArguments<AANoUndef, AANoUndefImpl> {
AANoUndefArgument(const IRPosition &IRP, Attributor &A)
: AAArgumentFromCallSiteArguments<AANoUndef, AANoUndefImpl,
AANoUndef::StateType, false,
Attribute::NoUndef>(IRP, A) {}
: AAArgumentFromCallSiteArguments<AANoUndef, AANoUndefImpl>(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_ARG_ATTR(noundef) }
Expand All @@ -10416,13 +10286,9 @@ struct AANoUndefCallSiteArgument final : AANoUndefFloating {
};

struct AANoUndefCallSiteReturned final
: AACallSiteReturnedFromReturned<AANoUndef, AANoUndefImpl,
AANoUndef::StateType, false,
Attribute::NoUndef> {
: AACalleeToCallSite<AANoUndef, AANoUndefImpl> {
AANoUndefCallSiteReturned(const IRPosition &IRP, Attributor &A)
: AACallSiteReturnedFromReturned<AANoUndef, AANoUndefImpl,
AANoUndef::StateType, false,
Attribute::NoUndef>(IRP, A) {}
: AACalleeToCallSite<AANoUndef, AANoUndefImpl>(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_CSRET_ATTR(noundef) }
Expand Down Expand Up @@ -10572,9 +10438,9 @@ struct AANoFPClassCallSiteArgument final : AANoFPClassFloating {
};

struct AANoFPClassCallSiteReturned final
: AACallSiteReturnedFromReturned<AANoFPClass, AANoFPClassImpl> {
: AACalleeToCallSite<AANoFPClass, AANoFPClassImpl> {
AANoFPClassCallSiteReturned(const IRPosition &IRP, Attributor &A)
: AACallSiteReturnedFromReturned<AANoFPClass, AANoFPClassImpl>(IRP, A) {}
: AACalleeToCallSite<AANoFPClass, AANoFPClassImpl>(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
Expand Down