[Attributor] ValueSimplify Abstract Attribute

[uenoku]

Summary

This patch introduces initial AAValueSimplify which simplifies a value in a context.

example

• (for function returned) If all the return values are the same and constant, then we can replace callsite returned with the constant.
• If an internal function takes the same value(constant) as an argument in the callsite, then we can replace the argument with that constant.

[uenoku]

First prototype of value simplify attribute is here. I'll add additional test later.

[jdoerfert]

I like it! First comments inlined.

llvm/lib/Transforms/IPO/Attributor.cpp

2390 ↗

(On Diff #217945)

I guess you need to track dependences here somewhere.

2447 ↗

(On Diff #217945)

Why unchanged? Don't we have to indicate *any* change in the state? (Same below)

2457 ↗

(On Diff #217945)

The associated function needs to have an exact definition as well.

2477 ↗

(On Diff #217945)

There is a version that omits the ReturnInst vector if you don't need it.

2496 ↗

(On Diff #217945)

GenericValueTraversal time ;)

2500 ↗

(On Diff #217945)

I know I started this habit but I now think it is a bad idea to shortcut the classes with using. For one, we don't have nice statistics. Also, the class can derive from the other one and it won't be much more code.

3281 ↗

(On Diff #217945)

I think we want this to exists for *all* position kinds.

Think of an indirect call that takes a function pointer. We see a function pointer phi, which resolves to different functions, which we cannot simplify further but we should be able to handle it.

[uenoku]

Address comment and refactor.

[uenoku]

llvm/lib/Transforms/IPO/Attributor.cpp

2517 ↗

(On Diff #218093)

GenericValueTraversal time ;)

About genericValueTraversal, I couldn't come up with generalized way to handle simplification for each instruction. ex)

%call = tail call i32 %fun() ; -> simplified to 1 
%tmp = add i32 %call, 1 ; -> this should be simplified to 2
%tmp2 = mul i32 %tmp, %tmp ;-> this should be simplified to 4

Do you have any idea?

[jdoerfert]

llvm/lib/Transforms/IPO/Attributor.cpp

2517 ↗

(On Diff #218093)

So, you want to reuse the logic in llvm/lib/Analysis/InstructionSimplify.cpp with the assumptions but we can do that later.

[jdoerfert]

llvm/lib/Transforms/IPO/Attributor.cpp

2373 ↗

(On Diff #218093)

Can we add more description for the parameters here and maybe rename ExistNone to something more descriptive wrt. what that means.

2413 ↗

(On Diff #218093)

Why check for arguments and why check for users? Just replace all users of V with C or do I miss sth?

2431 ↗

(On Diff #218093)

No need for this check, I think. we always have an associated function for arguments and even if the definition is not exact, we can use information from the call sites to improve this definition.

2465 ↗

(On Diff #218093)

AA...Returned always has an associated function.

2447 ↗

(On Diff #217945)

I'm unsure about this. Even if None was not observed we could still lose the information if it was assumed, right? I would prefer to be careful also wrt. to future extensions that could break some invariant here.

2496 ↗

(On Diff #217945)

I think the AAValueSimplifyImpl::manifest should be fine here once the attribute specialization is gone. You can test it with some phi tests for example.

[uenoku]

Address comment

[uenoku]

llvm/lib/Transforms/IPO/Attributor.cpp

2447 ↗

(On Diff #217945)

I'm unsure about this. Even if None was not observed we could still lose the information if it was assumed, right?

I agree. I erased them.

[jdoerfert]

llvm/lib/Transforms/IPO/Attributor.cpp

2374 ↗

(On Diff #218262)

The names below are too confusing, rename one as "existing.." or sth.

2397 ↗

(On Diff #218262)

Deal with undef as well and at some point with bitcasts and stuff.

2420 ↗

(On Diff #218262)

Add a FIXME for a typecast or add the typecast (+ test).

2436 ↗

(On Diff #218262)

No need for this check, I think. ...

2530 ↗

(On Diff #218262)

genericValueTraversal above should deal with select and phi, correct? Do we have tests?

[jdoerfert]

llvm/lib/Transforms/IPO/Attributor.cpp

2514 ↗

(On Diff #218262)

I am unsure. There are more values in the worklist of the genericValueTraversal which we need to visit and which could change things, right?

[uenoku]

llvm/lib/Transforms/IPO/Attributor.cpp

2514 ↗

(On Diff #218262)

As I look at genericValueTraversal , Stripped is false if associated value is a leaf (then there is no value in the worklist) so I thought it is more convinient to regard this value as simplifed. Is this wrong?

[jdoerfert]

llvm/lib/Transforms/IPO/Attributor.cpp

2514 ↗

(On Diff #218262)

You are right. Forget my comment.

[uenoku]

Address comment. Add simple test for phi and select.

[uenoku]

llvm/lib/Transforms/IPO/Attributor.cpp

2530 ↗

(On Diff #218262)

Add test in @test-select-phi in value-simplify.ll.

[jdoerfert]

llvm/lib/Transforms/IPO/Attributor.cpp

2649 ↗

(On Diff #218477)

remove the above three lines.

2670 ↗

(On Diff #218477)

Add short documentation here please.

llvm/test/Transforms/FunctionAttrs/value-simplify.ll

97 ↗

(On Diff #218477)

Could you make it (or add)
%phi-same = phi i32 [ 1, %if-true ], [ %select-same, %if-false ]

[uenoku]

Address comment and add test for undef.

[jdoerfert]

We should make sure we track statistics properly, e.g., only if the simplified value is different from the original value we track sth.
This would be automatic if simplified value = original value will imply an "invalid state".

llvm/test/Transforms/FunctionAttrs/value-simplify.ll

117 ↗

(On Diff #218592)

This should arguably be

`; CHECK: tail call void @use(i32 %phi-not-same)`

The pessimistic fixpoint should probably not revert to nullptr and cause a cascading failure but instead just go back to the original value.

[uenoku]

llvm/test/Transforms/FunctionAttrs/value-simplify.ll

117 ↗

(On Diff #218592)

This should arguably be

; CHECK: tail call void @use(i32 %phi-not-same)

In genericTraversal, %phi-not-same is decomposed to i32 0, 1 so I think it is not currect.

The pessimistic fixpoint should probably not revert to nullptr and cause a cascading failure but instead just go back to the original value.

It looks good.

[jdoerfert]

llvm/test/Transforms/FunctionAttrs/value-simplify.ll

117 ↗

(On Diff #218592)

so %phi-not-same is not simplified, right?
But %select-not-same-undef is something or undef and then we should simplify it to "something". That would probably happen just fine if we do not use nullptr as pessimistic value but the original value itself. That is, the worst thing you can simplify an instruction to is itself.

[uenoku]

Change to return the original value when in the pessimistic state.

[jdoerfert]

In D66967#1659664, @uenoku wrote:

Change to return the original value when in the pessimistic state.

Did this change the test?

[uenoku]

llvm/test/Transforms/FunctionAttrs/value-simplify.ll

117 ↗

(On Diff #218592)

so %phi-not-same is not simplified, right?

Yes

But %select-not-same-undef is something or undef and then we should simplify it to "something".

In the simplification of %select-not-same-undef, traversed values are 0, 1, undef and we don't look at %phi-not-same variable itself.

Anyway, I changed to return original value in the pessimistic state and simplified value(always not equals to original value ) in the optimistic state.

[uenoku]

In D66967#1659666, @jdoerfert wrote:

In D66967#1659664, @uenoku wrote:

Change to return the original value when in the pessimistic state.

Did this change the test?

No. I think it is ok.

[jdoerfert]

llvm/test/Transforms/FunctionAttrs/value-simplify.ll

117 ↗

(On Diff #218592)

In the simplification of %select-not-same-undef, traversed values are 0, 1, undef and we don't look at %phi-not-same variable itself.

But the possible values for %select-not-same-undef should be [%phi-not-same, undef]. which we can simplify to %phi-not-same.

[uenoku]

llvm/test/Transforms/FunctionAttrs/value-simplify.ll

117 ↗

(On Diff #218592)

If so we need to change GenericValueTraversal a bit.

[jdoerfert]

llvm/test/Transforms/FunctionAttrs/value-simplify.ll

117 ↗

(On Diff #218592)

Why? What if the VisitValueCB would never return false?

[uenoku]

llvm/test/Transforms/FunctionAttrs/value-simplify.ll

117 ↗

(On Diff #218592)

I think GenericValueTraversal is working in following way:

worklist : [%select-not-same-undef]
worklist : [%phi-not-same, undef]
worklist : [i32 1, i32 0, undef]
VisitValueCB(1) ; Simplified Value None -> i32 1
VisitValueCB(0) ; Simplified Value i32 1 -> %select-not-same-undef (revert to orignal)

Then we never call VisitValueCB(%phi-not-same).
If we want to simplify the value to %phi-not-same, we have to change to traverse not leaves but nodes (only direct children).

worklist : [%phi-not-same, undef]
VisitValueCB(%phi-not-same) ; Simplified Value None -> %phi-not-same
VisitValueCB(undef) ; Simplified Value doesn't change

[jdoerfert]

LGTM.

llvm/test/Transforms/FunctionAttrs/value-simplify.ll

117 ↗

(On Diff #218592)

I get it now.

We could *not* use the GenericValueTraversal as we actually want to look at selects and phis here. Or we need to track more state and extend GenericValueTraversal. Let's postpone this for a follow up.

[uenoku]

Minor update.

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

struct AANoCapture
 
   /// Create an abstract attribute view for the position \p IRP.
   static AANoCapture &createForPosition(const IRPosition &IRP, Attributor &A);
 
   /// Unique ID (due to the unique address)
   static const char ID;
 };
 
+/// An abstract interface for value simplify abstract attribute.
+struct AAValueSimplify : public StateWrapper<BooleanState, AbstractAttribute>,
+                         public IRPosition {
+  AAValueSimplify(const IRPosition &IRP) : IRPosition(IRP) {}
+
+  /// Return an IR position, see struct IRPosition.
+  ///
+  ///{
+  IRPosition &getIRPosition() { return *this; }
+  const IRPosition &getIRPosition() const { return *this; }
+  ///}
+
+  /// Return an assumed simplified value if a single candidate is found. If
+  /// there cannot be one, return original value. If it is not clear yet, return the
+  /// Optional::NoneType.
+  virtual Optional<Value *> getAssumedSimplifiedValue(Attributor &A) const;
+
+  /// Create an abstract attribute view for the position \p IRP.
+  static AAValueSimplify &createForPosition(const IRPosition &IRP,
+                                            Attributor &A);
+
+  /// Unique ID (due to the unique address)
+  static const char ID;
+};
+
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_IPO_FUNCTIONATTRS_H

llvm/trunk/lib/Transforms/IPO/Attributor.cpp

do {
 
     // Look through phi nodes, visit all live operands.
     if (auto *PHI = dyn_cast<PHINode>(V)) {
       assert(LivenessAA &&
              "Expected liveness in the presence of instructions!");
       for (unsigned u = 0, e = PHI->getNumIncomingValues(); u < e; u++) {
         const BasicBlock *IncomingBB = PHI->getIncomingBlock(u);
         if (LivenessAA->isAssumedDead(IncomingBB->getTerminator())) {
-          AnyDead =true;
+          AnyDead = true;
           continue;
         }
         Worklist.push_back(PHI->getIncomingValue(u));
       }
       continue;
     }
 
     // Once a leaf is reached we inform the user through the callback.
struct AANoCaptureCallSiteReturned final : AANoCaptureImpl {
   AANoCaptureCallSiteReturned(const IRPosition &IRP) : AANoCaptureImpl(IRP) {}
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override {
     STATS_DECLTRACK_CSRET_ATTR(nocapture)
   }
 };
 
+/// ------------------ Value Simplify Attribute ----------------------------
+struct AAValueSimplifyImpl : AAValueSimplify {
+  AAValueSimplifyImpl(const IRPosition &IRP) : AAValueSimplify(IRP) {}
+
+  /// See AbstractAttribute::getAsStr().
+  const std::string getAsStr() const override {
+    return getAssumed() ? (getKnown() ? "simplified" : "maybe-simple")
+                        : "not-simple";
+  }
+
+  /// See AbstractAttribute::trackStatistics()
+  void trackStatistics() const override {}
+
+  /// See AAValueSimplify::getAssumedSimplifiedValue()
+  Optional<Value *> getAssumedSimplifiedValue(Attributor &A) const override {
+    if (!getAssumed())
+      return const_cast<Value *>(&getAssociatedValue());
+    return SimplifiedAssociatedValue;
+  }
+  void initialize(Attributor &A) override {}
+
+  /// Helper function for querying AAValueSimplify and updating candicate.
+  /// \param QueryingValue Value trying to unify with SimplifiedValue
+  /// \param AccumulatedSimplifiedValue Current simplification result.
+  static bool checkAndUpdate(Attributor &A, const AbstractAttribute &QueryingAA,
+                             Value &QueryingValue,
+                             Optional<Value *> &AccumulatedSimplifiedValue) {
+    // FIXME: Add a typecast support.
+
+    auto &ValueSimpifyAA = A.getAAFor<AAValueSimplify>(
+        QueryingAA, IRPosition::value(QueryingValue));
+
+    Optional<Value *> QueryingValueSimplified =
+        ValueSimpifyAA.getAssumedSimplifiedValue(A);
+
+    if (!QueryingValueSimplified.hasValue())
+      return true;
+
+    if (!QueryingValueSimplified.getValue())
+      return false;
+
+    Value &QueryingValueSimplifiedUnwrapped =
+        *QueryingValueSimplified.getValue();
+
+    if (isa<UndefValue>(QueryingValueSimplifiedUnwrapped))
+      return true;
+
+    if (AccumulatedSimplifiedValue.hasValue())
+      return AccumulatedSimplifiedValue == QueryingValueSimplified;
+
+    LLVM_DEBUG(dbgs() << "[Attributor][ValueSimplify] " << QueryingValue
+                      << " is assumed to be "
+                      << QueryingValueSimplifiedUnwrapped << "\n");
+
+    AccumulatedSimplifiedValue = QueryingValueSimplified;
+    return true;
+  }
+
+  /// See AbstractAttribute::manifest(...).
+  ChangeStatus manifest(Attributor &A) override {
+    ChangeStatus Changed = ChangeStatus::UNCHANGED;
+
+    if (!SimplifiedAssociatedValue.hasValue() ||
+        !SimplifiedAssociatedValue.getValue())
+      return Changed;
+
+    if (auto *C = dyn_cast<Constant>(SimplifiedAssociatedValue.getValue())) {
+      // We can replace the AssociatedValue with the constant.
+      Value &V = getAssociatedValue();
+      if (!V.user_empty() && &V != C && V.getType() == C->getType()) {
+        LLVM_DEBUG(dbgs() << "[Attributor][ValueSimplify] " << V << " -> " << *C
+                          << "\n");
+        V.replaceAllUsesWith(C);
+        Changed = ChangeStatus::CHANGED;
+      }
+    }
+
+    return Changed | AAValueSimplify::manifest(A);
+  }
+
+protected:
+  // An assumed simplified value. Initially, it is set to Optional::None, which
+  // means that the value is not clear under current assumption. If in the
+  // pessimistic state, getAssumedSimplifiedValue doesn't return this value but
+  // returns orignal associated value.
+  Optional<Value *> SimplifiedAssociatedValue;
+};
+
+struct AAValueSimplifyArgument final : AAValueSimplifyImpl {
+  AAValueSimplifyArgument(const IRPosition &IRP) : AAValueSimplifyImpl(IRP) {}
+
+  /// See AbstractAttribute::updateImpl(...).
+  ChangeStatus updateImpl(Attributor &A) override {
+    bool HasValueBefore = SimplifiedAssociatedValue.hasValue();
+
+    auto PredForCallSite = [&](CallSite CS) {
+      return checkAndUpdate(A, *this, *CS.getArgOperand(getArgNo()),
+                            SimplifiedAssociatedValue);
+    };
+
+    if (!A.checkForAllCallSites(PredForCallSite, *this, true))
+      return indicatePessimisticFixpoint();
+
+    // If a candicate was found in this update, return CHANGED.
+    return HasValueBefore == SimplifiedAssociatedValue.hasValue()
+               ? ChangeStatus::UNCHANGED
+               : ChangeStatus ::CHANGED;
+  }
+
+  /// See AbstractAttribute::trackStatistics()
+  void trackStatistics() const override {
+    STATS_DECLTRACK_ARG_ATTR(value_simplify)
+  }
+};
+
+struct AAValueSimplifyReturned : AAValueSimplifyImpl {
+  AAValueSimplifyReturned(const IRPosition &IRP) : AAValueSimplifyImpl(IRP) {}
+
+  /// See AbstractAttribute::updateImpl(...).
+  ChangeStatus updateImpl(Attributor &A) override {
+    bool HasValueBefore = SimplifiedAssociatedValue.hasValue();
+
+    auto PredForReturned = [&](Value &V) {
+      return checkAndUpdate(A, *this, V, SimplifiedAssociatedValue);
+    };
+
+    if (!A.checkForAllReturnedValues(PredForReturned, *this))
+      return indicatePessimisticFixpoint();
+
+    // If a candicate was found in this update, return CHANGED.
+    return HasValueBefore == SimplifiedAssociatedValue.hasValue()
+               ? ChangeStatus::UNCHANGED
+               : ChangeStatus ::CHANGED;
+  }
+  /// See AbstractAttribute::trackStatistics()
+  void trackStatistics() const override {
+    STATS_DECLTRACK_FNRET_ATTR(value_simplify)
+  }
+};
+
+struct AAValueSimplifyFloating : AAValueSimplifyImpl {
+  AAValueSimplifyFloating(const IRPosition &IRP) : AAValueSimplifyImpl(IRP) {}
+
+  /// See AbstractAttribute::initialize(...).
+  void initialize(Attributor &A) override {
+    Value &V = getAnchorValue();
+
+    // TODO: add other stuffs
+    if (isa<Constant>(V) || isa<UndefValue>(V))
+      indicatePessimisticFixpoint();
+  }
+
+  /// See AbstractAttribute::updateImpl(...).
+  ChangeStatus updateImpl(Attributor &A) override {
+    bool HasValueBefore = SimplifiedAssociatedValue.hasValue();
+
+    auto VisitValueCB = [&](Value &V, BooleanState, bool Stripped) -> bool {
+      auto &AA = A.getAAFor<AAValueSimplify>(*this, IRPosition::value(V));
+      if (!Stripped && this == &AA) {
+        // TODO: Look the instruction and check recursively.
+        LLVM_DEBUG(
+            dbgs() << "[Attributor][ValueSimplify] Can't be stripped more : "
+                   << V << "\n");
+        indicatePessimisticFixpoint();
+        return false;
+      }
+      return checkAndUpdate(A, *this, V, SimplifiedAssociatedValue);
+    };
+
+    if (!genericValueTraversal<AAValueSimplify, BooleanState>(
+            A, getIRPosition(), *this, static_cast<BooleanState &>(*this),
+            VisitValueCB))
+      return indicatePessimisticFixpoint();
+
+    // If a candicate was found in this update, return CHANGED.
+
+    return HasValueBefore == SimplifiedAssociatedValue.hasValue()
+               ? ChangeStatus::UNCHANGED
+               : ChangeStatus ::CHANGED;
+  }
+
+  /// See AbstractAttribute::trackStatistics()
+  void trackStatistics() const override {
+    STATS_DECLTRACK_FLOATING_ATTR(value_simplify)
+  }
+};
+
+struct AAValueSimplifyFunction : AAValueSimplifyImpl {
+  AAValueSimplifyFunction(const IRPosition &IRP) : AAValueSimplifyImpl(IRP) {}
+
+  /// See AbstractAttribute::initialize(...).
+  void initialize(Attributor &A) override {
+    SimplifiedAssociatedValue = &getAnchorValue();
+    indicateOptimisticFixpoint();
+  }
+  /// See AbstractAttribute::initialize(...).
+  ChangeStatus updateImpl(Attributor &A) override {
+    llvm_unreachable(
+        "AAValueSimplify(Function|CallSite)::updateImpl will not be called");
+  }
+  /// See AbstractAttribute::trackStatistics()
+  void trackStatistics() const override {
+    STATS_DECLTRACK_FN_ATTR(value_simplify)
+  }
+};
+
+struct AAValueSimplifyCallSite : AAValueSimplifyFunction {
+  AAValueSimplifyCallSite(const IRPosition &IRP)
+      : AAValueSimplifyFunction(IRP) {}
+  /// See AbstractAttribute::trackStatistics()
+  void trackStatistics() const override {
+    STATS_DECLTRACK_CS_ATTR(value_simplify)
+  }
+};
+
+struct AAValueSimplifyCallSiteReturned : AAValueSimplifyReturned {
+  AAValueSimplifyCallSiteReturned(const IRPosition &IRP)
+      : AAValueSimplifyReturned(IRP) {}
+
+  void trackStatistics() const override {
+    STATS_DECLTRACK_CSRET_ATTR(value_simplify)
+  }
+};
+struct AAValueSimplifyCallSiteArgument : AAValueSimplifyFloating {
+  AAValueSimplifyCallSiteArgument(const IRPosition &IRP)
+      : AAValueSimplifyFloating(IRP) {}
+
+  void trackStatistics() const override {
+    STATS_DECLTRACK_CSARG_ATTR(value_simplify)
+  }
+};
+
 /// ----------------------------------------------------------------------------
 ///                               Attributor
 /// ----------------------------------------------------------------------------
 
 bool Attributor::isAssumedDead(const AbstractAttribute &AA,
                                const AAIsDead *LivenessAA) {
   const Instruction *CtxI = AA.getIRPosition().getCtxI();
   if (!CtxI)
void Attributor::identifyDefaultAbstractAttributes(Function &F) {
 
   // Return attributes are only appropriate if the return type is non void.
   Type *ReturnType = F.getReturnType();
   if (!ReturnType->isVoidTy()) {
     // Argument attribute "returned" --- Create only one per function even
     // though it is an argument attribute.
     getOrCreateAAFor<AAReturnedValues>(FPos);
 
-    if (ReturnType->isPointerTy()) {
-      IRPosition RetPos = IRPosition::returned(F);
 
+    // Every function might be simplified.
+    getOrCreateAAFor<AAValueSimplify>(RetPos);
+
+    if (ReturnType->isPointerTy()) {
+
       // Every function with pointer return type might be marked align.
       getOrCreateAAFor<AAAlign>(RetPos);
 
       // Every function with pointer return type might be marked nonnull.
       getOrCreateAAFor<AANonNull>(RetPos);
 
       // Every function with pointer return type might be marked noalias.
       getOrCreateAAFor<AANoAlias>(RetPos);
 
       // Every function with pointer return type might be marked
       // dereferenceable.
       getOrCreateAAFor<AADereferenceable>(RetPos);
     }
   }
 
   for (Argument &Arg : F.args()) {
-    if (Arg.getType()->isPointerTy()) {
-      IRPosition ArgPos = IRPosition::argument(Arg);
+
+    // Every argument might be simplified.
+    getOrCreateAAFor<AAValueSimplify>(ArgPos);
+
+    if (Arg.getType()->isPointerTy()) {
       // Every argument with pointer type might be marked nonnull.
       getOrCreateAAFor<AANonNull>(ArgPos);
 
       // Every argument with pointer type might be marked noalias.
       getOrCreateAAFor<AANoAlias>(ArgPos);
 
       // Every argument with pointer type might be marked dereferenceable.
       getOrCreateAAFor<AADereferenceable>(ArgPos);
for (Instruction &I : instructions(&F)) {
     if (IsInterestingOpcode)
       InstOpcodeMap[I.getOpcode()].push_back(&I);
     if (I.mayReadOrWriteMemory())
       ReadOrWriteInsts.push_back(&I);
 
     CallSite CS(&I);
     if (CS && CS.getCalledFunction()) {
       for (int i = 0, e = CS.getCalledFunction()->arg_size(); i < e; i++) {
+
+        IRPosition CSArgPos = IRPosition::callsite_argument(CS, i);
+
+        // Call site argument might be simplified.
+        getOrCreateAAFor<AAValueSimplify>(CSArgPos);
+
         if (!CS.getArgument(i)->getType()->isPointerTy())
           continue;
-        IRPosition CSArgPos = IRPosition::callsite_argument(CS, i);
 
         // Call site argument attribute "non-null".
         getOrCreateAAFor<AANonNull>(CSArgPos);
 
         // Call site argument attribute "no-alias".
         getOrCreateAAFor<AANoAlias>(CSArgPos);
 
         // Call site argument attribute "dereferenceable".

 const char AANoRecurse::ID = 0;
 const char AAWillReturn::ID = 0;
 const char AANoAlias::ID = 0;
 const char AANoReturn::ID = 0;
 const char AAIsDead::ID = 0;
 const char AADereferenceable::ID = 0;
 const char AAAlign::ID = 0;
 const char AANoCapture::ID = 0;
+const char AAValueSimplify::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!");
 
switch (IRP.getPositionKind()) {                                           \
       SWITCH_PK_CREATE(CLASS, IRP, IRP_ARGUMENT, Argument)                     \
       SWITCH_PK_CREATE(CLASS, IRP, IRP_RETURNED, Returned)                     \
       SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_SITE_RETURNED, CallSiteReturned)   \
       SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_SITE_ARGUMENT, CallSiteArgument)   \
     }                                                                          \
     return *AA;                                                                \
   }
 
+#define CREATE_ALL_ABSTRACT_ATTRIBUTE_FOR_POSITION(CLASS)                      \
+  CLASS &CLASS::createForPosition(const IRPosition &IRP, Attributor &A) {      \
+    CLASS *AA = nullptr;                                                       \
+    switch (IRP.getPositionKind()) {                                           \
+      SWITCH_PK_INV(CLASS, IRP_INVALID, "invalid")                             \
+      SWITCH_PK_CREATE(CLASS, IRP, IRP_FUNCTION, Function)                     \
+      SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_SITE, CallSite)                    \
+      SWITCH_PK_CREATE(CLASS, IRP, IRP_FLOAT, Floating)                        \
+      SWITCH_PK_CREATE(CLASS, IRP, IRP_ARGUMENT, Argument)                     \
+      SWITCH_PK_CREATE(CLASS, IRP, IRP_RETURNED, Returned)                     \
+      SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_SITE_RETURNED, CallSiteReturned)   \
+      SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_SITE_ARGUMENT, CallSiteArgument)   \
+    }                                                                          \
+    return *AA;                                                                \
+  }
+
 CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoUnwind)
 CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoSync)
 CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoFree)
 CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoRecurse)
 CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAWillReturn)
 CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoReturn)
 CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAIsDead)
 CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAReturnedValues)
 
 CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANonNull)
 CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoAlias)
 CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AADereferenceable)
 CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAAlign)
 CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoCapture)
 
+CREATE_ALL_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAValueSimplify)
+
 #undef CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION
 #undef CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION
+#undef CREATE_ALL_ABSTRACT_ATTRIBUTE_FOR_POSITION
 #undef SWITCH_PK_CREATE
 #undef SWITCH_PK_INV
 
 INITIALIZE_PASS_BEGIN(AttributorLegacyPass, "attributor",
                       "Deduce and propagate attributes", false, false)
 INITIALIZE_PASS_END(AttributorLegacyPass, "attributor",
                     "Deduce and propagate attributes", false, false)

llvm/trunk/test/Transforms/FunctionAttrs/align.ll

 ; Function Attrs: nounwind readnone ssp uwtable
 define internal i8* @f2(i8* readnone %0) local_unnamed_addr #0 {
 ; ATTRIBUTOR: define internal nonnull align 8 dereferenceable(1) i8* @f2(i8* nonnull readnone align 8 dereferenceable(1) "no-capture-maybe-returned" %0)
   %2 = icmp eq i8* %0, null
   br i1 %2, label %5, label %3
 
 ; <label>:3:                                      ; preds = %1
 
-; ATTRIBUTOR: %4 = tail call i8* @f1(i8* nonnull align 8 dereferenceable(1) "no-capture-maybe-returned" %0)
+; ATTRIBUTOR: %4 = tail call i8* @f1(i8* nonnull align 8 dereferenceable(1) "no-capture-maybe-returned" @a1)
   %4 = tail call i8* @f1(i8* nonnull %0)
   br label %7
 
 ; <label>:5:                                      ; preds = %1
 ; ATTRIBUTOR: %6 = tail call i8* @f3(i8* nonnull align 16 dereferenceable(1) @a2)
   %6 = tail call i8* @f3(i8* nonnull @a2)
   br label %7
 

llvm/trunk/test/Transforms/FunctionAttrs/noreturn_sync.ll

-; RUN: opt -functionattrs -attributor -attributor-disable=false -attributor-max-iterations-verify -attributor-max-iterations=4 -S < %s | FileCheck %s
+; RUN: opt -functionattrs -attributor -attributor-disable=false -attributor-max-iterations-verify -attributor-max-iterations=5 -S < %s | FileCheck %s
 ;
 ; This file is the same as noreturn_async.ll but with a personality which
 ; indicates that the exception handler *cannot* catch asynchronous exceptions.
 ; As a consequence, invokes to noreturn and nounwind functions are translated
 ; to calls followed by an unreachable.
 ;
 ; https://reviews.llvm.org/D59978#inline-586873
 ;

llvm/trunk/test/Transforms/FunctionAttrs/nounwind.ll

 ; RUN: opt < %s -functionattrs -S | FileCheck %s
-; RUN: opt < %s -attributor -attributor-disable=false -attributor-max-iterations-verify -attributor-max-iterations=4 -S | FileCheck %s --check-prefix=ATTRIBUTOR
+; RUN: opt < %s -attributor -attributor-disable=false -attributor-max-iterations-verify -attributor-max-iterations=5 -S | FileCheck %s --check-prefix=ATTRIBUTOR
 
 ; TEST 1
 ; CHECK: Function Attrs: norecurse nounwind readnone
 ; CHECK-NEXT: define i32 @foo1()
 ; ATTRIBUTOR: Function Attrs: nofree nosync nounwind
 ; ATTRIBUTOR-NEXT: define i32 @foo1()
 define i32 @foo1() {
   ret i32 1

llvm/trunk/test/Transforms/FunctionAttrs/value-simplify.ll

+; RUN: opt -attributor --attributor-disable=false -S < %s | FileCheck %s
+; TODO: Add max-iteration check
+; ModuleID = 'value-simplify.ll'
+source_filename = "value-simplify.ll"
+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
+declare void @f(i32)
+
+; Test1: Replace argument with constant
+define internal void @test1(i32 %a) {
+; CHECK: tail call void @f(i32 1)
+  tail call void @f(i32 %a)
+  ret void
+}
+
+define void @test1_helper() {
+  tail call void @test1(i32 1)
+  ret void
+}
+
+; TEST 2 : Simplify return value
+define i32 @return0() {
+  ret i32 0
+}
+
+define i32 @return1() {
+  ret i32 1
+}
+
+; CHECK: define i32 @test2_1(i1 %c)
+define i32 @test2_1(i1 %c) {
+  br i1 %c, label %if.true, label %if.false
+if.true:
+  %call = tail call i32 @return0()
+
+; FIXME: %ret0 should be replaced with i32 1.
+; CHECK: %ret0 = add i32 0, 1
+  %ret0 = add i32 %call, 1
+  br label %end
+if.false:
+  %ret1 = tail call i32 @return1()
+  br label %end
+end:
+
+; FIXME: %ret should be replaced with i32 1.
+; CHECK: %ret = phi i32 [ %ret0, %if.true ], [ 1, %if.false ]
+  %ret = phi i32 [ %ret0, %if.true ], [ %ret1, %if.false ]
+
+; FIXME: ret i32 1
+; CHECK: ret i32 %ret
+  ret i32 %ret
+}
+
+
+
+; CHECK: define i32 @test2_2(i1 %c)
+define i32 @test2_2(i1 %c) {
+; FIXME: %ret should be replaced with i32 1.
+  %ret = tail call i32 @test2_1(i1 %c)
+; FIXME: ret i32 1
+; CHECK: ret i32 %ret
+  ret i32 %ret
+}
+
+declare void @use(i32)
+; CHECK: define void @test3(i1 %c)
+define void @test3(i1 %c) {
+  br i1 %c, label %if.true, label %if.false
+if.true:
+  br label %end
+if.false:
+  %ret1 = tail call i32 @return1()
+  br label %end
+end:
+
+; CHECK: %r = phi i32 [ 1, %if.true ], [ 1, %if.false ]
+  %r = phi i32 [ 1, %if.true ], [ %ret1, %if.false ]
+
+; CHECK: tail call void @use(i32 1)
+  tail call void @use(i32 %r)
+  ret void
+}
+
+define void @test-select-phi(i1 %c) {
+  %select-same = select i1 %c, i32 1, i32 1
+  ; CHECK: tail call void @use(i32 1)
+  tail call void @use(i32 %select-same)
+
+  %select-not-same = select i1 %c, i32 1, i32 0
+  ; CHECK: tail call void @use(i32 %select-not-same)
+  tail call void @use(i32 %select-not-same)
+  br i1 %c, label %if-true, label %if-false
+if-true:
+  br label %end
+if-false:
+  br label %end
+end:
+  %phi-same = phi i32 [ 1, %if-true ], [ 1, %if-false ]
+  %phi-not-same = phi i32 [ 0, %if-true ], [ 1, %if-false ]
+  %phi-same-prop = phi i32 [ 1, %if-true ], [ %select-same, %if-false ]
+  %phi-same-undef = phi i32 [ 1, %if-true ], [ undef, %if-false ]
+  %select-not-same-undef = select i1 %c, i32 %phi-not-same, i32 undef
+
+
+  ; CHECK: tail call void @use(i32 1)
+  tail call void @use(i32 %phi-same)
+
+  ; CHECK: tail call void @use(i32 %phi-not-same)
+  tail call void @use(i32 %phi-not-same)
+
+  ; CHECK: tail call void @use(i32 1)
+  tail call void @use(i32 %phi-same-prop)
+
+  ; CHECK: tail call void @use(i32 1)
+  tail call void @use(i32 %phi-same-undef)
+
+  ; CHECK: tail call void @use(i32 %select-not-same-undef)
+  tail call void @use(i32 %select-not-same-undef)
+
+  ret void
+
+}