Attributor: Try to propagate concrete denormal-fp-math{-f32}

[arsenm]

Summary

Allow specialization of functions with "dynamic" denormal modes to a
known IEEE or DAZ mode based on callers. This should make it possible
to implement a is-denormal-flushing-enabled test using
llvm.canonicalize and have it be free after LTO.

[jdoerfert]

llvm/include/llvm/Transforms/IPO/Attributor.h

1921

Make it clear this is for string attributes, maybe even just pass the string keys.

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

8987

Assumed should be more optimistic, this is a fix point, we'll never call update(Impl)

[arsenm]

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

8987

There isn't really an optimistic vs. not choice. There's only do we know or not, you can't declare one of the modes better than the other

8987

The isFixpoint is more sophisticated than known == assumed

[arsenm]

Remove assumed, nothing ever changes and stop tracking invalid f32 state, only consider that during manifest

[sameerds]

llvm/include/llvm/Transforms/IPO/Attributor.h

5173

Is it correct to say that an optimistic fix point is when all the "dynamic" components are set to default (ieee)? This attribute is reinventing what a fixed point means. Does this function need to set the optimistic fixed point? Or I would guess this function is actually never called, in which case it should be marked with llvm_unreachable()?

5177

Another theoretical issue with what a fixed point means for this attribute. Is there any sequence of actions where this function is called followed by something that depends on isAtFixpoint()?

[sameerds]

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

9023

This is why I am saying that the optimistic fixed point is to replace dynamic with default. It may be wrong to "assume" default, but that's different from the optimistic fixed point.

[arsenm]

llvm/include/llvm/Transforms/IPO/Attributor.h

5173

No. You cannot say IEEE is more optimistic than preserve-sign or positive-zero. They're just different. The only thing you can infer is known or unknown

[sameerds]

llvm/include/llvm/Transforms/IPO/Attributor.h

5173

I understand what you want it to do. I am trying to understand what the code actually means. The manifest function replaces "dynamic" with "default/ieee". Both the optimistic and pessimistic fixed points leave dynamic alone. What is a fixed point here? When a client calls either of the fixed point functions, what should the interpretation of "dynamic" be? Should it be the same as the manifest method, which means setting it to default/ieee? Clearly, the client intended that no more changes should be possible, but the manifest will change it.

[sameerds]

llvm/include/llvm/Transforms/IPO/Attributor.h

5173

Or to put it in more concrete terms, is it okay that either of the following patterns, if it occurs, can potentially fire the assert?

indicateOptimisticFixpoint();
assert(isAtFixpoint());

and

indicatePessimisticFixpoint();
assert(isAtFixpoint());

[arsenm]

llvm/include/llvm/Transforms/IPO/Attributor.h

5173

I believe isValidState is supposed to protect from this, combined with going to invalid for combinations that don't make sense. Combinations that don't make sense go to invalid and then should be ignored

[sameerds]

llvm/include/llvm/Transforms/IPO/Attributor.h

5173

I am sorry I don't follow that at all. The attribute has a definition for a fixed point. I understand setting nonsensical combinations to invalid state, but the set-fixed-point functions neither set the invalid state, nor some state that satisfies isAtFixPoint(). Then how are the above asserts prevented?

Taking a step back, I am not opposed to the goal being achieved here, but I am not seeing how it fits the apparent design of the Attributor. Should this attribute set a new precedent for what a fixed point means? I would rather defer to others who are more familiar with the original intention of the Attributor.

[arsenm]

Remove dead code

[sameerds]

llvm/include/llvm/Transforms/IPO/Attributor.h

5161

Some of my earlier comments are wrong, because I misunderstood the part about dynamic modes. But here's what I think needs to be consistent with the notion of a fixed point. The update() calls this function to check if it should attempt a refinement in yet another iteration. But the updateImpl() function tries to indicate when a fixed point is reached, which is when it is unable to follow through all the callsites anymore. There's a loss of information about whether future iterations should call updateImpl() again, because indicatePessimisticFixpoint() doesn't change any state.

In that case, maybe the state of this Attribute should really be a single bool called AtFixpoint? Then both optimistic and pessimistic calls set it to true, and return UNCHANGED, while isAtFixpoint() returns the current value of this bool.

Also, the introductory comments in Attributor.h should be updated to say that the Known/Assumed scheme is the most common, but not the only way to represent fixed points.

[sameerds]

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

8989

If all modes are non-dynamic, should this set optimistic fixed point?

9014

If all modes are "not dynamic", should this call optimistic fixpoint?

[arsenm]

Use explicit bool for fixpoint like SetState.

Also I tried adding this to attributor-light which apparently will require more work than just adding the ID to the allowed set

llvm/include/llvm/Transforms/IPO/Attributor.h

5161

In that case, maybe the state of this Attribute should really be a single bool called AtFixpoint?

That's what SetState does, I can just copy that

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

9014

This case seems interesting. The other attributes seem to not do that, but it does appear to fire

[arsenm]

llvm/include/llvm/Transforms/IPO/Attributor.h

5152–5155

It turns out moving this to handle the invalid mode at initialize broke the partially dynamic mode case from a fixed caller (and my test for that was accidentally dead and deleted). At this point I'll fix that separately if it matters

[arsenm]

llvm/include/llvm/Transforms/IPO/Attributor.h

5152–5155

And by if it matters, I mean it doesn't now because the libraries are compiled with full denormal-fp-math=dynamic. We probably should refine that to only the f32, because the f64/f16 flushing probably does not work in practice

[sameerds]

LGTM, with a few nits.

llvm/include/llvm/Transforms/IPO/Attributor.h

5114–5116

The usual way is to just invert the == operator?

6317–6320

Is this just a quirk of how Phab displays the diff? Or the new struct started at the wrong point?

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

8988

Did you mean "callee"?

[arsenm]

llvm/include/llvm/Transforms/IPO/Attributor.h

5114–5116

I will never understand why C++ doesn't do this for you

5152–5155

I looked at this again and the case that regressed is invalid, we just now get worse handling of invalid cases which is not interesting

6317–6320

I think this is a consequence of diffs based on multiple starting points. On the last rebase a few new AAs showed up and pushed this further down the file

Plus the operator<< here was misplaced to begin with, it should be moved elsewhere

[arsenm]

850ec7bbb18f36535d60b5201b0d7f368408ec23

llvm/include/llvm/ADT/FloatingPointMode.h

struct DenormalMode {
   DenormalModeKind Output = DenormalModeKind::Invalid;
 
   /// Denormal treatment kind for floating point instruction inputs in the
   /// default floating-point environment. If this is not DenormalModeKind::IEEE,
   /// floating-point instructions implicitly treat the input value as 0.
   DenormalModeKind Input = DenormalModeKind::Invalid;
 
   constexpr DenormalMode() = default;
+  constexpr DenormalMode(const DenormalMode &) = default;
   constexpr DenormalMode(DenormalModeKind Out, DenormalModeKind In) :
     Output(Out), Input(In) {}
 
+  DenormalMode &operator=(const DenormalMode &) = default;
 
   static constexpr DenormalMode getInvalid() {
     return DenormalMode(DenormalModeKind::Invalid, DenormalModeKind::Invalid);
   }
 
   /// Return the assumed default mode for a function without denormal-fp-math.
   static constexpr DenormalMode getDefault() {
     return getIEEE();

llvm/include/llvm/Transforms/IPO/Attributor.h

struct Attributor {
   ///                                 argument position, should be ignored.
   void getAttrs(const IRPosition &IRP, ArrayRef<Attribute::AttrKind> AKs,
                 SmallVectorImpl<Attribute> &Attrs,
                 bool IgnoreSubsumingPositions = false);
 
   /// Remove all \p AttrKinds attached to \p IRP.
   ChangeStatus removeAttrs(const IRPosition &IRP,
                            const ArrayRef<Attribute::AttrKind> &AttrKinds);
+  ChangeStatus removeAttrs(const IRPosition &IRP, ArrayRef<StringRef> Attrs);
 
   /// Attach \p DeducedAttrs to \p IRP, if \p ForceReplace is set we do this
   /// even if the same attribute kind was already present.
   ChangeStatus manifestAttrs(const IRPosition &IRP,
                              const ArrayRef<Attribute> &DeducedAttrs,
                              bool ForceReplace = false);
 
 private:
private:
 
   /// Container for potential values
   SetTy Set;
 
   /// Flag for undef value
   bool UndefIsContained;
 };
 
+struct DenormalFPMathState : public AbstractState {
+  struct DenormalState {
+    DenormalMode Mode = DenormalMode::getInvalid();
+    DenormalMode ModeF32 = DenormalMode::getInvalid();
+
+    bool operator==(const DenormalState Other) const {
+      return Mode == Other.Mode && ModeF32 == Other.ModeF32;
+    }
+
+    bool operator!=(const DenormalState Other) const {
+      return Mode != Other.Mode || ModeF32 != Other.ModeF32;
+    }
+
+    bool isValid() const {
+      return Mode.isValid() && ModeF32.isValid();
+    }
+
+    static DenormalMode::DenormalModeKind
+    unionDenormalKind(DenormalMode::DenormalModeKind Callee,
+                      DenormalMode::DenormalModeKind Caller) {
+      if (Caller == Callee)
+        return Caller;
+      if (Callee == DenormalMode::Dynamic)
+        return Caller;
+      if (Caller == DenormalMode::Dynamic)
+        return Callee;
+      return DenormalMode::Invalid;
+    }
+
+    static DenormalMode unionAssumed(DenormalMode Callee, DenormalMode Caller) {
+      return DenormalMode{unionDenormalKind(Callee.Output, Caller.Output),
+                          unionDenormalKind(Callee.Input, Caller.Input)};
+    }
+
+    DenormalState unionWith(DenormalState Caller) const {
+      DenormalState Callee(*this);
+      Callee.Mode = unionAssumed(Callee.Mode, Caller.Mode);
+      Callee.ModeF32 = unionAssumed(Callee.ModeF32, Caller.ModeF32);
+      return Callee;
+    }
+  };
+
+  DenormalState Known;
+
+  /// Explicitly track whether we've hit a fixed point.
+  bool IsAtFixedpoint = false;
+
+  DenormalFPMathState() = default;
+
+  DenormalState getKnown() const { return Known; }
+
+  // There's only really known or unknown, there's no speculatively assumable
+  // state.
+  DenormalState getAssumed() const { return Known; }
+
+  bool isValidState() const override {
+    return Known.isValid();
+  }
+
+  /// Return true if there are no dynamic components to the denormal mode worth
+  /// specializing.
+  bool isModeFixed() const {
+    return Known.Mode.Input != DenormalMode::Dynamic &&
+           Known.Mode.Output != DenormalMode::Dynamic &&
+           Known.ModeF32.Input != DenormalMode::Dynamic &&
+           Known.ModeF32.Output != DenormalMode::Dynamic;
+  }
+
+  bool isAtFixpoint() const override {
+    return IsAtFixedpoint;
+  }
+
+  ChangeStatus indicateFixpoint() {
+    bool Changed = !IsAtFixedpoint;
+    IsAtFixedpoint = true;
+    return Changed ? ChangeStatus::CHANGED : ChangeStatus::UNCHANGED;
+  }
+
+  ChangeStatus indicateOptimisticFixpoint() override {
+    return indicateFixpoint();
+  }
+
+  ChangeStatus indicatePessimisticFixpoint() override {
+    return indicateFixpoint();
+  }
+
+  DenormalFPMathState operator^=(const DenormalFPMathState &Caller) {
+    Known = Known.unionWith(Caller.getKnown());
+    return *this;
+  }
+};
+
 using PotentialConstantIntValuesState = PotentialValuesState<APInt>;
 using PotentialLLVMValuesState =
     PotentialValuesState<std::pair<AA::ValueAndContext, AA::ValueScope>>;
 
 raw_ostream &operator<<(raw_ostream &OS,
                         const PotentialConstantIntValuesState &R);
 raw_ostream &operator<<(raw_ostream &OS, const PotentialLLVMValuesState &R);
 
struct AAPointerInfo : public AbstractAttribute {
   static bool classof(const AbstractAttribute *AA) {
     return (AA->getIdAddr() == &ID);
   }
 
   /// Unique ID (due to the unique address)
   static const char ID;
 };
 
+raw_ostream &operator<<(raw_ostream &, const AAPointerInfo::Access &);
+
 /// An abstract attribute for getting assumption information.
 struct AAAssumptionInfo
     : public StateWrapper<SetState<StringRef>, AbstractAttribute,
                           DenseSet<StringRef>> {
   using Base =
       StateWrapper<SetState<StringRef>, AbstractAttribute, DenseSet<StringRef>>;
 
   AAAssumptionInfo(const IRPosition &IRP, Attributor &A,
struct AAIndirectCallInfo
   virtual bool foreachCallee(function_ref<bool(Function *)> CB) const = 0;
 
   /// See AbstractAttribute::getName()
   const std::string getName() const override { return "AAIndirectCallInfo"; }
 
   /// See AbstractAttribute::getIdAddr()
   const char *getIdAddr() const override { return &ID; }
 
   /// This function should return true if the type of the \p AA is
   /// AAIndirectCallInfo
+  /// This function should return true if the type of the \p AA is
+  /// AADenormalFPMath.
+  static bool classof(const AbstractAttribute *AA) {
+    return (AA->getIdAddr() == &ID);
+  }
+
+  /// Unique ID (due to the unique address)
+  static const char ID;
+};
+
+/// An abstract Attribute for specializing "dynamic" components of
+/// "denormal-fp-math" and "denormal-fp-math-f32" to a known denormal mode.
+struct AADenormalFPMath
+    : public StateWrapper<DenormalFPMathState, AbstractAttribute> {
+  using Base = StateWrapper<DenormalFPMathState, AbstractAttribute>;
+
+  AADenormalFPMath(const IRPosition &IRP, Attributor &A) : Base(IRP) {}
+
+  /// Create an abstract attribute view for the position \p IRP.
+  static AADenormalFPMath &createForPosition(const IRPosition &IRP,
+                                             Attributor &A);
+
+  /// See AbstractAttribute::getName()
+  const std::string getName() const override { return "AADenormalFPMath"; }
+
+  /// See AbstractAttribute::getIdAddr()
+  const char *getIdAddr() const override { return &ID; }
+
+  /// This function should return true if the type of the \p AA is
+  /// AADenormalFPMath.
   static bool classof(const AbstractAttribute *AA) {
     return (AA->getIdAddr() == &ID);
   }
 
   /// Unique ID (due to the unique address)
   static const char ID;
 };
 

llvm/lib/Transforms/IPO/Attributor.cpp

auto RemoveAttrCB = [&](const Attribute::AttrKind &Kind, AttributeSet AttrSet,
     if (!AttrSet.hasAttribute(Kind))
       return false;
     AM.addAttribute(Kind);
     return true;
   };
   return updateAttrMap<Attribute::AttrKind>(IRP, AttrKinds, RemoveAttrCB);
 }
 
+ChangeStatus Attributor::removeAttrs(const IRPosition &IRP,
+                                     ArrayRef<StringRef> Attrs) {
+  auto RemoveAttrCB = [&](StringRef Attr, AttributeSet AttrSet,
+                          AttributeMask &AM, AttrBuilder &) -> bool {
+    if (!AttrSet.hasAttribute(Attr))
+      return false;
+    AM.addAttribute(Attr);
+    return true;
+  };
+
+  return updateAttrMap<StringRef>(IRP, Attrs, RemoveAttrCB);
+}
+
 ChangeStatus Attributor::manifestAttrs(const IRPosition &IRP,
                                        const ArrayRef<Attribute> &Attrs,
                                        bool ForceReplace) {
   LLVMContext &Ctx = IRP.getAnchorValue().getContext();
   auto AddAttrCB = [&](const Attribute &Attr, AttributeSet AttrSet,
                        AttributeMask &, AttrBuilder &AB) {
     return addIfNotExistent(Ctx, Attr, AttrSet, ForceReplace, AB);
   };
if (IsIPOAmendable) {
     getOrCreateAAFor<AAMemoryBehavior>(FPos);
 
     // Every function can be "readnone/argmemonly/inaccessiblememonly/...".
     getOrCreateAAFor<AAMemoryLocation>(FPos);
 
     // Every function can track active assumptions.
     getOrCreateAAFor<AAAssumptionInfo>(FPos);
 
+    // If we're not using a dynamic mode for float, there's nothing worthwhile
+    // to infer. This misses the edge case denormal-fp-math="dynamic" and
+    // denormal-fp-math-f32=something, but that likely has no real world use.
+    DenormalMode Mode = F.getDenormalMode(APFloat::IEEEsingle());
+    if (Mode.Input == DenormalMode::Dynamic ||
+        Mode.Output == DenormalMode::Dynamic)
+      getOrCreateAAFor<AADenormalFPMath>(FPos);
+
     // Return attributes are only appropriate if the return type is non void.
     Type *ReturnType = F.getReturnType();
     if (!ReturnType->isVoidTy()) {
       IRPosition RetPos = IRPosition::returned(F);
       AttributeSet RetAttrs = Attrs.getRetAttrs();
 
       // Every returned value might be dead.
       getOrCreateAAFor<AAIsDead>(RetPos);

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

 PIPE_OPERATOR(AACallEdges)
 PIPE_OPERATOR(AAInterFnReachability)
 PIPE_OPERATOR(AAPointerInfo)
 PIPE_OPERATOR(AAAssumptionInfo)
 PIPE_OPERATOR(AAUnderlyingObjects)
 PIPE_OPERATOR(AAAddressSpace)
 PIPE_OPERATOR(AAIndirectCallInfo)
 PIPE_OPERATOR(AAGlobalValueInfo)
+PIPE_OPERATOR(AADenormalFPMath)
 
 #undef PIPE_OPERATOR
 
 template <>
 ChangeStatus clampStateAndIndicateChange<DerefState>(DerefState &S,
                                                      const DerefState &R) {
   ChangeStatus CS0 =
       clampStateAndIndicateChange(S.DerefBytesState, R.DerefBytesState);
struct AAMemoryLocationCallSite final : AAMemoryLocationImpl {
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override {
     if (isAssumedReadNone())
       STATS_DECLTRACK_CS_ATTR(readnone)
   }
 };
 } // namespace
 
+/// ------------------ denormal-fp-math Attribute -------------------------
+
+namespace {
+struct AADenormalFPMathImpl : public AADenormalFPMath {
+  AADenormalFPMathImpl(const IRPosition &IRP, Attributor &A)
+      : AADenormalFPMath(IRP, A) {}
+
+  const std::string getAsStr(Attributor *A) const override {
+    std::string Str("AADenormalFPMath[");
+    raw_string_ostream OS(Str);
+
+    DenormalState Known = getKnown();
+    if (Known.Mode.isValid())
+      OS << "denormal-fp-math=" << Known.Mode;
+    else
+      OS << "invalid";
+
+    if (Known.ModeF32.isValid())
+      OS << " denormal-fp-math-f32=" << Known.ModeF32;
+    OS << ']';
+    return OS.str();
+  }
+};
+
+struct AADenormalFPMathFunction final : AADenormalFPMathImpl {
+  AADenormalFPMathFunction(const IRPosition &IRP, Attributor &A)
+      : AADenormalFPMathImpl(IRP, A) {}
+
+  void initialize(Attributor &A) override {
+    const Function *F = getAnchorScope();
+    DenormalMode Mode = F->getDenormalModeRaw();
+    DenormalMode ModeF32 = F->getDenormalModeF32Raw();
+
+    // TODO: Handling this here prevents handling the case where a caller has a
+    // fixed denormal-fp-math with dynamic denormal-fp-math-f32, but called from
+    // a function with a fully fixed mode.
+    if (ModeF32 == DenormalMode::getInvalid())
+      ModeF32 = Mode;
+    Known = DenormalState{Mode, ModeF32};
+    if (isModeFixed())
+      indicateFixpoint();
+  }
+
+  ChangeStatus updateImpl(Attributor &A) override {
+    ChangeStatus Change = ChangeStatus::UNCHANGED;
+
+    auto CheckCallSite = [=, &Change, &A](AbstractCallSite CS) {
+      Function *Caller = CS.getInstruction()->getFunction();
+      LLVM_DEBUG(dbgs() << "[AADenormalFPMath] Call " << Caller->getName()
+                        << "->" << getAssociatedFunction()->getName() << '\n');
+
+      const auto *CallerInfo = A.getAAFor<AADenormalFPMath>(
+          *this, IRPosition::function(*Caller), DepClassTy::REQUIRED);
+      if (!CallerInfo)
+        return false;
+
+      Change = Change | clampStateAndIndicateChange(this->getState(),
+                                                    CallerInfo->getState());
+      return true;
+    };
+
+    bool AllCallSitesKnown = true;
+    if (!A.checkForAllCallSites(CheckCallSite, *this, true, AllCallSitesKnown))
+      return indicatePessimisticFixpoint();
+
+    if (Change == ChangeStatus::CHANGED && isModeFixed())
+      indicateFixpoint();
+    return Change;
+  }
+
+  ChangeStatus manifest(Attributor &A) override {
+    LLVMContext &Ctx = getAssociatedFunction()->getContext();
+
+    SmallVector<Attribute, 2> AttrToAdd;
+    SmallVector<StringRef, 2> AttrToRemove;
+    if (Known.Mode == DenormalMode::getDefault()) {
+      AttrToRemove.push_back("denormal-fp-math");
+    } else {
+      AttrToAdd.push_back(
+          Attribute::get(Ctx, "denormal-fp-math", Known.Mode.str()));
+    }
+
+    if (Known.ModeF32 != Known.Mode) {
+      AttrToAdd.push_back(
+          Attribute::get(Ctx, "denormal-fp-math-f32", Known.ModeF32.str()));
+    } else {
+      AttrToRemove.push_back("denormal-fp-math-f32");
+    }
+
+    auto &IRP = getIRPosition();
+
+    // TODO: There should be a combined add and remove API.
+    return A.removeAttrs(IRP, AttrToRemove) |
+           A.manifestAttrs(IRP, AttrToAdd, /*ForceReplace=*/true);
+  }
+
+  void trackStatistics() const override {
+    STATS_DECLTRACK_FN_ATTR(denormal_fp_math)
+  }
+};
+} // namespace
+
 /// ------------------ Value Constant Range Attribute -------------------------
 
 namespace {
 struct AAValueConstantRangeImpl : AAValueConstantRange {
   using StateType = IntegerRangeState;
   AAValueConstantRangeImpl(const IRPosition &IRP, Attributor &A)
       : AAValueConstantRange(IRP, A) {}
 

 const char AACallEdges::ID = 0;
 const char AAInterFnReachability::ID = 0;
 const char AAPointerInfo::ID = 0;
 const char AAAssumptionInfo::ID = 0;
 const char AAUnderlyingObjects::ID = 0;
 const char AAAddressSpace::ID = 0;
 const char AAIndirectCallInfo::ID = 0;
 const char AAGlobalValueInfo::ID = 0;
+const char AADenormalFPMath::ID = 0;
 
 // Macro magic to create the static generator function for attributes that
 // follow the naming scheme.
 
 #define SWITCH_PK_INV(CLASS, PK, POS_NAME)                                     \
   case IRPosition::PK:                                                         \
     llvm_unreachable("Cannot create " #CLASS " for a " POS_NAME " position!");
 

 CREATE_ABSTRACT_ATTRIBUTE_FOR_ONE_POSITION(IRP_FLOAT, Floating,
                                            AAGlobalValueInfo)
 
 CREATE_FUNCTION_ONLY_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAHeapToStack)
 CREATE_FUNCTION_ONLY_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAUndefinedBehavior)
 CREATE_FUNCTION_ONLY_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANonConvergent)
 CREATE_FUNCTION_ONLY_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAIntraFnReachability)
 CREATE_FUNCTION_ONLY_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAInterFnReachability)
+CREATE_FUNCTION_ONLY_ABSTRACT_ATTRIBUTE_FOR_POSITION(AADenormalFPMath)
 
 CREATE_NON_RET_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAMemoryBehavior)
 
 #undef CREATE_FUNCTION_ONLY_ABSTRACT_ATTRIBUTE_FOR_POSITION
 #undef CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION
 #undef CREATE_NON_RET_ABSTRACT_ATTRIBUTE_FOR_POSITION
 #undef CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION
 #undef CREATE_ALL_ABSTRACT_ATTRIBUTE_FOR_POSITION
 #undef CREATE_ABSTRACT_ATTRIBUTE_FOR_ONE_POSITION
 #undef SWITCH_PK_CREATE
 #undef SWITCH_PK_INV

llvm/test/Transforms/Attributor/denormal-fp-math.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-attributes --check-globals --version 2
 ; RUN: opt -S -passes=attributor < %s | FileCheck %s
 
 ; Keep the attribute checks clean by disabling inference of anything else.
 declare void @call_of_mystery()
 
 ; Should infer to ieee,ieee/default
 define internal void @leaf_dynamic_dynamic_from_ieee_ieee() #0 {
-; CHECK-LABEL: define internal void @leaf_dynamic_dynamic_from_ieee_ieee
-; CHECK-SAME: () #[[ATTR0:[0-9]+]] {
+; CHECK-LABEL: define internal void @leaf_dynamic_dynamic_from_ieee_ieee() {
 ; CHECK-NEXT:    call void @call_of_mystery()
 ; CHECK-NEXT:    ret void
 ;
   call void @call_of_mystery()
   ret void
 }
 
 ; Should infer to ieee,ieee/default
 define internal void @leaf_recursive_dynamic_dynamic_from_ieee_ieee() #0 {
-; CHECK-LABEL: define internal void @leaf_recursive_dynamic_dynamic_from_ieee_ieee
-; CHECK-SAME: () #[[ATTR0]] {
+; CHECK-LABEL: define internal void @leaf_recursive_dynamic_dynamic_from_ieee_ieee() {
 ; CHECK-NEXT:    call void @call_of_mystery()
 ; CHECK-NEXT:    call void @leaf_recursive_dynamic_dynamic_from_ieee_ieee()
 ; CHECK-NEXT:    ret void
 ;
   call void @call_of_mystery()
   call void @leaf_recursive_dynamic_dynamic_from_ieee_ieee()
   ret void
 }
 
 ; Should strip denormal-fp-math for default ieee
 define internal void @leaf_f64_ieee_f64_ieee__f32_dynamic_f32_dynamic__dynamic_dynamic_from_ieee_ieee() #1 {
-; CHECK-LABEL: define internal void @leaf_f64_ieee_f64_ieee__f32_dynamic_f32_dynamic__dynamic_dynamic_from_ieee_ieee
-; CHECK-SAME: () #[[ATTR1:[0-9]+]] {
+; CHECK-LABEL: define internal void @leaf_f64_ieee_f64_ieee__f32_dynamic_f32_dynamic__dynamic_dynamic_from_ieee_ieee() {
 ; CHECK-NEXT:    call void @call_of_mystery()
 ; CHECK-NEXT:    ret void
 ;
   call void @call_of_mystery()
   ret void
 }
 
 ; Should infer to preserve-sign,preserve-sign
 define internal void @leaf_dynamic_dynamic_from_daz_daz() #0 {
 ; CHECK-LABEL: define internal void @leaf_dynamic_dynamic_from_daz_daz
-; CHECK-SAME: () #[[ATTR0]] {
+; CHECK-SAME: () #[[ATTR0:[0-9]+]] {
 ; CHECK-NEXT:    call void @call_of_mystery()
 ; CHECK-NEXT:    ret void
 ;
   call void @call_of_mystery()
   ret void
 }
 
 ; Should strip denormal-fp-math for default ieee, and have denormal-fp-math-f32=preserve-sign,preserve-sign
 define internal void @leaf_f64_ieee_f64_ieee__f32_dynamic_f32_dynamic__dynamic_dynamic_from_daz_daz() #1 {
 ; CHECK-LABEL: define internal void @leaf_f64_ieee_f64_ieee__f32_dynamic_f32_dynamic__dynamic_dynamic_from_daz_daz
-; CHECK-SAME: () #[[ATTR1]] {
+; CHECK-SAME: () #[[ATTR1:[0-9]+]] {
 ; CHECK-NEXT:    call void @call_of_mystery()
 ; CHECK-NEXT:    ret void
 ;
   call void @call_of_mystery()
   ret void
 }
 
 ; Leave this alone, must stay dynamic,dynamic
 define internal void @leaf_dynamic_dynamic_from_daz_daz_and_ieee_ieee() #0 {
 ; CHECK-LABEL: define internal void @leaf_dynamic_dynamic_from_daz_daz_and_ieee_ieee
-; CHECK-SAME: () #[[ATTR0]] {
+; CHECK-SAME: () #[[ATTR2:[0-9]+]] {
 ; CHECK-NEXT:    call void @call_of_mystery()
 ; CHECK-NEXT:    ret void
 ;
   call void @call_of_mystery()
   ret void
 }
 
 ; Leave this alone, should only have denormal-fp-math-f32=ieee,ieee
 define internal void @leaf_f64_ieee_f64_ieee__f32_dynamic_f32_dynamic__dynamic_dynamic_from_daz_daz_and_ieee_ieee() #1 {
 ; CHECK-LABEL: define internal void @leaf_f64_ieee_f64_ieee__f32_dynamic_f32_dynamic__dynamic_dynamic_from_daz_daz_and_ieee_ieee
 ; CHECK-SAME: () #[[ATTR1]] {
 ; CHECK-NEXT:    call void @call_of_mystery()
 ; CHECK-NEXT:    ret void
 ;
   call void @call_of_mystery()
   ret void
 }
 
 ; Leave as dynamic,dynamic
 define void @externally_visible_dynamic_dynamic_from_ieee_ieee() #0 {
 ; CHECK-LABEL: define void @externally_visible_dynamic_dynamic_from_ieee_ieee
-; CHECK-SAME: () #[[ATTR0]] {
+; CHECK-SAME: () #[[ATTR2]] {
 ; CHECK-NEXT:    call void @call_of_mystery()
 ; CHECK-NEXT:    ret void
 ;
   call void @call_of_mystery()
   ret void
 }
 
 ; Should infer to positive-zero,positive-zero
 define internal void @leaf_dynamic_dynamic_from_dapz_dapz() #0 {
 ; CHECK-LABEL: define internal void @leaf_dynamic_dynamic_from_dapz_dapz
-; CHECK-SAME: () #[[ATTR0]] {
+; CHECK-SAME: () #[[ATTR3:[0-9]+]] {
 ; CHECK-NEXT:    call void @call_of_mystery()
 ; CHECK-NEXT:    ret void
 ;
   call void @call_of_mystery()
   ret void
 }
 
 ; ieee,ieee entry point
 define void @func_ieee_ieee() #2 {
-; CHECK-LABEL: define void @func_ieee_ieee
-; CHECK-SAME: () #[[ATTR2:[0-9]+]] {
+; CHECK-LABEL: define void @func_ieee_ieee() {
 ; CHECK-NEXT:    call void @leaf_dynamic_dynamic_from_ieee_ieee()
 ; CHECK-NEXT:    call void @leaf_f64_ieee_f64_ieee__f32_dynamic_f32_dynamic__dynamic_dynamic_from_ieee_ieee()
 ; CHECK-NEXT:    call void @leaf_dynamic_dynamic_from_daz_daz_and_ieee_ieee()
 ; CHECK-NEXT:    call void @leaf_f64_ieee_f64_ieee__f32_dynamic_f32_dynamic__dynamic_dynamic_from_daz_daz_and_ieee_ieee()
 ; CHECK-NEXT:    call void @externally_visible_dynamic_dynamic_from_ieee_ieee()
 ; CHECK-NEXT:    call void @leaf_dynamic_ieee_from_ieee_ieee()
 ; CHECK-NEXT:    call void @leaf_ieee_dynamic_from_ieee_ieee()
 ; CHECK-NEXT:    call void @leaf_recursive_dynamic_dynamic_from_ieee_ieee()
;
   call void @leaf_ieee_dynamic_from_ieee_ieee()
   call void @leaf_recursive_dynamic_dynamic_from_ieee_ieee()
   ret void
 }
 
 ; preserve-sign,preserve-sign entry point
 define void @func_daz_daz() #3 {
 ; CHECK-LABEL: define void @func_daz_daz
-; CHECK-SAME: () #[[ATTR3:[0-9]+]] {
+; CHECK-SAME: () #[[ATTR0]] {
 ; CHECK-NEXT:    call void @leaf_dynamic_dynamic_from_daz_daz()
 ; CHECK-NEXT:    call void @leaf_dynamic_dynamic_from_daz_daz_and_ieee_ieee()
 ; CHECK-NEXT:    call void @leaf_f64_ieee_f64_ieee__f32_dynamic_f32_dynamic__dynamic_dynamic_from_daz_daz_and_ieee_ieee()
 ; CHECK-NEXT:    call void @leaf_f64_dynamic_f64_dynamic__f32_daz_f32_daz_from__daz_daz()
 ; CHECK-NEXT:    call void @leaf_f64_ieee_f64_ieee__f32_dynamic_f32_dynamic__dynamic_dynamic_from_daz_daz()
 ; CHECK-NEXT:    ret void
 ;
   call void @leaf_dynamic_dynamic_from_daz_daz()
   call void @leaf_dynamic_dynamic_from_daz_daz_and_ieee_ieee()
   call void @leaf_f64_ieee_f64_ieee__f32_dynamic_f32_dynamic__dynamic_dynamic_from_daz_daz_and_ieee_ieee()
   call void @leaf_f64_dynamic_f64_dynamic__f32_daz_f32_daz_from__daz_daz()
   call void @leaf_f64_ieee_f64_ieee__f32_dynamic_f32_dynamic__dynamic_dynamic_from_daz_daz()
   ret void
 }
 
 ; positive-zero,positive-zero entry point
 define void @func_dapz_dapz() #4 {
 ; CHECK-LABEL: define void @func_dapz_dapz
-; CHECK-SAME: () #[[ATTR4:[0-9]+]] {
+; CHECK-SAME: () #[[ATTR3]] {
 ; CHECK-NEXT:    call void @leaf_dynamic_dynamic_from_dapz_dapz()
 ; CHECK-NEXT:    ret void
 ;
   call void @leaf_dynamic_dynamic_from_dapz_dapz()
   ret void
 }
 
 ; Could be fully preserve-sign,preserve-sign, but this isn't a
 ; realistic case and we don't bother trying to handle it.
 define internal void @leaf_f64_dynamic_f64_dynamic__f32_daz_f32_daz_from__daz_daz() #5 {
 ; CHECK-LABEL: define internal void @leaf_f64_dynamic_f64_dynamic__f32_daz_f32_daz_from__daz_daz
-; CHECK-SAME: () #[[ATTR5:[0-9]+]] {
+; CHECK-SAME: () #[[ATTR4:[0-9]+]] {
 ; CHECK-NEXT:    call void @call_of_mystery()
 ; CHECK-NEXT:    ret void
 ;
   call void @call_of_mystery()
   ret void
 }
 
 ; -> ieee,ieee
 define internal void @leaf_dynamic_ieee_from_ieee_ieee() #6 {
-; CHECK-LABEL: define internal void @leaf_dynamic_ieee_from_ieee_ieee
-; CHECK-SAME: () #[[ATTR6:[0-9]+]] {
+; CHECK-LABEL: define internal void @leaf_dynamic_ieee_from_ieee_ieee() {
 ; CHECK-NEXT:    call void @call_of_mystery()
 ; CHECK-NEXT:    ret void
 ;
   call void @call_of_mystery()
   ret void
 }
 
 ; -> ieee,ieee
 define internal void @leaf_ieee_dynamic_from_ieee_ieee() #7 {
-; CHECK-LABEL: define internal void @leaf_ieee_dynamic_from_ieee_ieee
-; CHECK-SAME: () #[[ATTR7:[0-9]+]] {
+; CHECK-LABEL: define internal void @leaf_ieee_dynamic_from_ieee_ieee() {
 ; CHECK-NEXT:    call void @call_of_mystery()
 ; CHECK-NEXT:    ret void
 ;
   call void @call_of_mystery()
   ret void
 }
 
 ; Specialize the f64 mode to ieee,ieee but leave f32 as dynamic,dynamic
 define internal void @leaf_dynamic_dynamic_from_f64_ieee_f32_dynamic() #0 {
 ; CHECK-LABEL: define internal void @leaf_dynamic_dynamic_from_f64_ieee_f32_dynamic
-; CHECK-SAME: () #[[ATTR0]] {
+; CHECK-SAME: () #[[ATTR1]] {
 ; CHECK-NEXT:    call void @call_of_mystery()
 ; CHECK-NEXT:    ret void
 ;
   call void @call_of_mystery()
   ret void
 }
 
 define void @func_f64_ieee_f64_ieee__f32_dynamic_f32_dynamic() #1 {
 ; CHECK-LABEL: define void @func_f64_ieee_f64_ieee__f32_dynamic_f32_dynamic
 ; CHECK-SAME: () #[[ATTR1]] {
 ; CHECK-NEXT:    call void @leaf_dynamic_dynamic_from_f64_ieee_f32_dynamic()
 ; CHECK-NEXT:    ret void
 ;
   call void @leaf_dynamic_dynamic_from_f64_ieee_f32_dynamic()
   ret void
 }
 
 ; -> preserve-sign,ieee.
 define internal void @leaf_daz_dynamic_from_dynamic_ieee() #8 {
 ; CHECK-LABEL: define internal void @leaf_daz_dynamic_from_dynamic_ieee
-; CHECK-SAME: () #[[ATTR8:[0-9]+]] {
+; CHECK-SAME: () #[[ATTR5:[0-9]+]] {
 ; CHECK-NEXT:    call void @call_of_mystery()
 ; CHECK-NEXT:    ret void
 ;
   call void @call_of_mystery()
   ret void
 }
 
 define void @dynamic_ieee() #6 {
 ; CHECK-LABEL: define void @dynamic_ieee
-; CHECK-SAME: () #[[ATTR6]] {
+; CHECK-SAME: () #[[ATTR6:[0-9]+]] {
 ; CHECK-NEXT:    call void @leaf_daz_dynamic_from_dynamic_ieee()
 ; CHECK-NEXT:    ret void
 ;
   call void @leaf_daz_dynamic_from_dynamic_ieee()
   ret void
 }
 
 ; Leave unchanged as ieee,ieeee

 ;
   call void @call_of_mystery()
   ret void
 }
 
 ; Leave unchanged as preserve-sign,preserve-sign
 define internal void @leaf_daz_daz_from_dynamic() #3 {
 ; CHECK-LABEL: define internal void @leaf_daz_daz_from_dynamic
-; CHECK-SAME: () #[[ATTR3]] {
+; CHECK-SAME: () #[[ATTR0]] {
 ; CHECK-NEXT:    call void @call_of_mystery()
 ; CHECK-NEXT:    ret void
 ;
   call void @call_of_mystery()
   ret void
 }
 
 define void @dynamic_dynamic() #0 {
 ; CHECK-LABEL: define void @dynamic_dynamic
-; CHECK-SAME: () #[[ATTR0]] {
+; CHECK-SAME: () #[[ATTR2]] {
 ; CHECK-NEXT:    call void @leaf_ieee_ieee_from_dynamic()
 ; CHECK-NEXT:    call void @leaf_daz_daz_from_dynamic()
 ; CHECK-NEXT:    call void @leaf_dynamic_from_dynamic()
 ; CHECK-NEXT:    ret void
 ;
   call void @leaf_ieee_ieee_from_dynamic()
   call void @leaf_daz_daz_from_dynamic()
   call void @leaf_dynamic_from_dynamic()
   ret void
 }
 
 define internal void @leaf_ieee_f64_daz_f32() #9 {
 ; CHECK-LABEL: define internal void @leaf_ieee_f64_daz_f32
-; CHECK-SAME: () #[[ATTR9:[0-9]+]] {
+; CHECK-SAME: () #[[ATTR7:[0-9]+]] {
 ; CHECK-NEXT:    call void @call_of_mystery()
 ; CHECK-NEXT:    ret void
 ;
   call void @call_of_mystery()
   ret void
 }
 
 define internal void @leaf_ieee_f64_daz_f32_from_ieee_f64_dynamic_f32() #10 {
 ; CHECK-LABEL: define internal void @leaf_ieee_f64_daz_f32_from_ieee_f64_dynamic_f32
-; CHECK-SAME: () #[[ATTR10:[0-9]+]] {
+; CHECK-SAME: () #[[ATTR8:[0-9]+]] {
 ; CHECK-NEXT:    call void @call_of_mystery()
 ; CHECK-NEXT:    ret void
 ;
   call void @call_of_mystery()
   ret void
 }
 
 define void @ieee_f64_dynamic_f32() #1 {
 ; CHECK-LABEL: define void @ieee_f64_dynamic_f32
 ; CHECK-SAME: () #[[ATTR1]] {
 ; CHECK-NEXT:    call void @leaf_ieee_f64_daz_f32()
 ; CHECK-NEXT:    call void @leaf_ieee_f64_daz_f32_from_ieee_f64_dynamic_f32()
 ; CHECK-NEXT:    ret void
 ;
   call void @leaf_ieee_f64_daz_f32()
   call void @leaf_ieee_f64_daz_f32_from_ieee_f64_dynamic_f32()
   ret void
 }
 
 ; => "preserve-sign,positive-zero" + "denormal-fp-math-f32"="ieee,positive-zero"
 define internal void @leaf_daz_dynamic_dynamic_dapz_from_daz_dapz_ieee_dapz() #11 {
 ; CHECK-LABEL: define internal void @leaf_daz_dynamic_dynamic_dapz_from_daz_dapz_ieee_dapz
-; CHECK-SAME: () #[[ATTR11:[0-9]+]] {
+; CHECK-SAME: () #[[ATTR9:[0-9]+]] {
 ; CHECK-NEXT:    call void @call_of_mystery()
 ; CHECK-NEXT:    ret void
 ;
   call void @call_of_mystery()
   ret void
 }
 
 define void @daz_dapz_ieee_dapz() #12 {
 ; CHECK-LABEL: define void @daz_dapz_ieee_dapz
-; CHECK-SAME: () #[[ATTR12:[0-9]+]] {
+; CHECK-SAME: () #[[ATTR9]] {
 ; CHECK-NEXT:    call void @leaf_daz_dynamic_dynamic_dapz_from_daz_dapz_ieee_dapz()
 ; CHECK-NEXT:    ret void
 ;
   call void @leaf_daz_dynamic_dynamic_dapz_from_daz_dapz_ieee_dapz()
   ret void
 }
 
 attributes #0 = { "denormal-fp-math"="dynamic,dynamic" }
 attributes #1 = { "denormal-fp-math-f32"="dynamic,dynamic" }
 attributes #2 = { "denormal-fp-math"="ieee,ieee" }
 attributes #3 = { "denormal-fp-math"="preserve-sign,preserve-sign" }
 attributes #4 = { "denormal-fp-math"="positive-zero,positive-zero" }
 attributes #5 = { "denormal-fp-math"="dynamic,dynamic" "denormal-fp-math-f32"="preserve-sign,preserve-sign" }
 attributes #6 = { "denormal-fp-math"="dynamic,ieee" }
 attributes #7 = { "denormal-fp-math"="ieee,dynamic" }
 attributes #8 = { "denormal-fp-math"="preserve-sign,dynamic" }
 attributes #9 = { "denormal-fp-math-f32"="preserve-sign,preserve-sign" }
 attributes #10 = { "denormal-fp-math"="preserve-sign,preserve-sign" "denormal-fp-math-f32"="ieee,ieee" }
 attributes #11 = { "denormal-fp-math"="preserve-sign,dynamic" "denormal-fp-math-f32"="dynamic,positive-zero" }
 attributes #12 = { "denormal-fp-math"="preserve-sign,positive-zero" "denormal-fp-math-f32"="ieee,positive-zero" }
 ;.
-; CHECK: attributes #[[ATTR0]] = { "denormal-fp-math"="dynamic,dynamic" }
+; CHECK: attributes #[[ATTR0]] = { "denormal-fp-math"="preserve-sign,preserve-sign" }
 ; CHECK: attributes #[[ATTR1]] = { "denormal-fp-math-f32"="dynamic,dynamic" }
-; CHECK: attributes #[[ATTR2]] = { "denormal-fp-math"="ieee,ieee" }
-; CHECK: attributes #[[ATTR3]] = { "denormal-fp-math"="preserve-sign,preserve-sign" }
-; CHECK: attributes #[[ATTR4]] = { "denormal-fp-math"="positive-zero,positive-zero" }
-; CHECK: attributes #[[ATTR5]] = { "denormal-fp-math"="dynamic,dynamic" "denormal-fp-math-f32"="preserve-sign,preserve-sign" }
+; CHECK: attributes #[[ATTR2]] = { "denormal-fp-math"="dynamic,dynamic" }
+; CHECK: attributes #[[ATTR3]] = { "denormal-fp-math"="positive-zero,positive-zero" }
+; CHECK: attributes #[[ATTR4]] = { "denormal-fp-math"="dynamic,dynamic" "denormal-fp-math-f32"="preserve-sign,preserve-sign" }
+; CHECK: attributes #[[ATTR5]] = { "denormal-fp-math"="preserve-sign,ieee" }
 ; CHECK: attributes #[[ATTR6]] = { "denormal-fp-math"="dynamic,ieee" }
-; CHECK: attributes #[[ATTR7]] = { "denormal-fp-math"="ieee,dynamic" }
-; CHECK: attributes #[[ATTR8]] = { "denormal-fp-math"="preserve-sign,dynamic" }
-; CHECK: attributes #[[ATTR9]] = { "denormal-fp-math-f32"="preserve-sign,preserve-sign" }
-; CHECK: attributes #[[ATTR10]] = { "denormal-fp-math"="preserve-sign,preserve-sign" "denormal-fp-math-f32"="ieee,ieee" }
-; CHECK: attributes #[[ATTR11]] = { "denormal-fp-math"="preserve-sign,dynamic" "denormal-fp-math-f32"="dynamic,positive-zero" }
-; CHECK: attributes #[[ATTR12]] = { "denormal-fp-math"="preserve-sign,positive-zero" "denormal-fp-math-f32"="ieee,positive-zero" }
+; CHECK: attributes #[[ATTR7]] = { "denormal-fp-math-f32"="preserve-sign,preserve-sign" }
+; CHECK: attributes #[[ATTR8]] = { "denormal-fp-math"="preserve-sign,preserve-sign" "denormal-fp-math-f32"="ieee,ieee" }
+; CHECK: attributes #[[ATTR9]] = { "denormal-fp-math"="preserve-sign,positive-zero" "denormal-fp-math-f32"="ieee,positive-zero" }
 ;.