[Attributor] Deduce "align" attribute

[uenoku]

Summary

Deduce "align" attribute in attributor.

[uenoku]

Fix patch

[uenoku]

@jdoerfert
I know align attribute is integer attribute and we need somewhat different deduction with other attributes. However, I implement AAAlignImpl as a subclass of BooleanState for now. Is it better to add some base class for the integer attribute?

llvm/test/Transforms/FunctionAttrs/align.ll

36

I want to test this for

if (ICS && ICS.hasRetAttr(Attribute::Alignment))
  return CompareOrSet(ICS.getRetAlignment());

but it does not work well now.
I find that ICS.hasRetAttr(Attribute::Alignment) returns true but ICS.getRetAlignment() returns 0 and get error in the current implementation. I think maybe that this is parse level problem... I'll investigate more.

[jdoerfert]

In D64152#1569030, @uenoku wrote:

@jdoerfert
I know align attribute is integer attribute and we need somewhat different deduction with other attributes. However, I implement AAAlignImpl as a subclass of BooleanState for now. Is it better to add some base class for the integer attribute?

Why not make it derive from IntegerState and use the integer as the alignment, zero would be the worst possible = unknown.

[jdoerfert]

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

711

Please add getters for the assumed and known alignment here.

llvm/lib/Transforms/IPO/Attributor.cpp

1903

Can you unify the two initialize methods in the base class (AAAlignImpl) with the index trick used in addIfNotExistent?

1927

What you want to do use to take the minimum of all align values and the current state (IntegerState). Remember the state at the beginning of this function to determine if it changed. We also need a test for this.

1939

For the return value you should do two things (for now):

1. Use Value::getPointerAlignment to get the known alignment in the IR.
2. Use getAAFor<AAAlign>() to the the known and assumed alignment from the Attributor.

Later, 1) would be replaced by a new ValueTracking.h getPointerAlignment method that does traversal, e.g., look through casts, compute new alignment based on constant geps, etc.
Later later, the new 1) and 2) would be merged to use traversal and assumed alignment together.

You can work on the later points as well if you want.

1959

There is (probably) no need for the ExistsAssume trick here, you can leave it but add a comment to explain that it is a shortcut to identify an optimistic fixpoint.

llvm/test/Transforms/FunctionAttrs/align.ll

23

We want align 4 here.

[uenoku]

Use IntegerState and take a minimum of alignment.

[uenoku]

Use getPointerAlignment.

[jdoerfert]

llvm/lib/Transforms/IPO/Attributor.cpp

347

I think you want to return -1 so it is clearly not a valid argument position.

850

return value or argument, right?

854

One could use the existing attribute as "known" and not indicate a fixpoint so that we can compute a better value.
We should have a test for it even if you keep it this way to describe the possibility.

864

Why the if? Can't you take the minimum of the knownAlign and the maximum allowed? Or initialize the assumed to the maximum allowed value already in the initialization?

865

style: remove braces around single statements.

916

If there is no top state, we can reach optimistic fixpoint earlier.

"If no assumed state was used for reasoning, an optimistic fixpoint is reached earlier."

1890

I think you want to first look at the in-flight AAAlign attribute before you look at the IR.

llvm/test/Transforms/FunctionAttrs/align.ll

43

Can we have SCC tests as well

[uenoku]

Address comments.

[uenoku]

Rebase and add callsite argument and argument deduction. It is ready for review.

[uenoku]

Minor update

[jdoerfert]

llvm/lib/Transforms/IPO/Attributor.cpp

1995

Are the statistics missing?

1999

Make the 1U << 29 a static const member with a proper name and description.

2003

The state is not initialized here as above. Call the general constructor from the specialized one (above) to avoid such inconsistencies.

2041

I think we should, for consistency, call getAssumedAlign() here.

2399

remove isPointerTy, see above.

llvm/test/Transforms/FunctionAttrs/align.ll

44

What happened to test5 again? Why is it commented out?

58

Please add a more meaningful SCC test, 3 functions, conditionals, malloc, etc. This one is a no-return recursion for which we can deduce everything.

76

check the call sites.

[uenoku]

Address comments

[uenoku]

llvm/test/Transforms/FunctionAttrs/align.ll

44

The problem was that getPointerAlignment didn't work well in test5_2. This will be fixed in D65281.

[jdoerfert]

LGTM.

[uenoku]

Minor fix.

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

 };
 
 struct AANoUnwind : public AbstractAttribute {
   /// An abstract interface for all nosync attributes.
   AANoUnwind(Value &V, InformationCache &InfoCache)
       : AbstractAttribute(V, InfoCache) {}
 
   /// See AbstractAttribute::getAttrKind()/
   Attribute::AttrKind getAttrKind() const override { return ID; }
 
   static constexpr Attribute::AttrKind ID = Attribute::NoUnwind;
 
   /// Returns true if nounwind is assumed.
   virtual bool isAssumedNoUnwind() const = 0;
 
   /// Returns true if nounwind is known.
   virtual bool isKnownNoUnwind() const = 0;
struct AADereferenceable : public AbstractAttribute {
 
   /// See AbastractState::getAttrKind().
   Attribute::AttrKind getAttrKind() const override { return ID; }
 
   /// The identifier used by the Attributor for this class of attributes.
   static constexpr Attribute::AttrKind ID = Attribute::Dereferenceable;
 };
 
+/// An abstract interface for all align attributes.
+struct AAAlign : public AbstractAttribute {
+
+  /// See AbstractAttribute::AbstractAttribute(...).
+  AAAlign(Value &V, InformationCache &InfoCache)
+      : AbstractAttribute(V, InfoCache) {}
+
+  /// See AbstractAttribute::AbstractAttribute(...).
+  AAAlign(Value *AssociatedVal, Value &AnchoredValue,
+          InformationCache &InfoCache)
+      : AbstractAttribute(AssociatedVal, AnchoredValue, InfoCache) {}
+
+  /// See AbastractState::getAttrKind().
+  Attribute::AttrKind getAttrKind() const override { return ID; }
+
+  /// Return assumed alignment.
+  virtual unsigned getAssumedAlign() const = 0;
+
+  /// Return known alignemnt.
+  virtual unsigned getKnownAlign() const = 0;
+
+  /// The identifier used by the Attributor for this class of attributes.
+  static constexpr Attribute::AttrKind ID = Attribute::Alignment;
+};
+
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_IPO_FUNCTIONATTRS_H

llvm/lib/Transforms/IPO/Attributor.cpp

 STATISTIC(NumFnWillReturn, "Number of functions marked willreturn");
 STATISTIC(NumFnArgumentNoAlias, "Number of function arguments marked noalias");
 STATISTIC(NumFnReturnedDereferenceable,
           "Number of function return values marked dereferenceable");
 STATISTIC(NumFnArgumentDereferenceable,
           "Number of function arguments marked dereferenceable");
 STATISTIC(NumCSArgumentDereferenceable,
           "Number of call site arguments marked dereferenceable");
+STATISTIC(NumFnReturnedAlign, "Number of function return values marked align");
+STATISTIC(NumFnArgumentAlign, "Number of function arguments marked align");
+STATISTIC(NumCSArgumentAlign, "Number of call site arguments marked align");
 
 // TODO: Determine a good default value.
 //
 // In the LLVM-TS and SPEC2006, 32 seems to not induce compile time overheads
 // (when run with the first 5 abstract attributes). The results also indicate
 // that we never reach 32 iterations but always find a fixpoint sooner.
 //
 // This will become more evolved once we perform two interleaved fixpoint

 
 /// Helper to adjust the statistics.
 static void bookkeeping(AbstractAttribute::ManifestPosition MP,
                         const Attribute &Attr) {
   if (!AreStatisticsEnabled())
     return;
 
   switch (Attr.getKindAsEnum()) {
+  case Attribute::Alignment:
+    switch (MP) {
+    case AbstractAttribute::MP_RETURNED:
+      NumFnReturnedAlign++;
+      break;
+    case AbstractAttribute::MP_ARGUMENT:
+      NumFnArgumentAlign++;
+      break;
+    case AbstractAttribute::MP_CALL_SITE_ARGUMENT:
+      NumCSArgumentAlign++;
+      break;
+    default:
+      break;
+    }
+    break;
   case Attribute::Dereferenceable:
     switch (MP) {
     case AbstractAttribute::MP_RETURNED:
       NumFnReturnedDereferenceable++;
       break;
     case AbstractAttribute::MP_ARGUMENT:
       NumFnArgumentDereferenceable++;
       break;
ChangeStatus AbstractAttribute::update(Attributor &A) {
 
   HasChanged = updateImpl(A);
 
   LLVM_DEBUG(dbgs() << "[Attributor] Update " << HasChanged << " " << *this
                     << "\n");
 
   return HasChanged;
 }
 
 ChangeStatus AbstractAttribute::manifest(Attributor &A) {
   assert(getState().isValidState() &&
          "Attempted to manifest an invalid state!");
   assert(getAssociatedValue() &&
          "Attempted to manifest an attribute without associated value!");
 
   ChangeStatus HasChanged = ChangeStatus::UNCHANGED;
   SmallVector<Attribute, 4> DeducedAttrs;
struct AANoSyncFunction : AANoSync, BooleanState {
 
   /// See AANoSync::isKnownNoSync()
   bool isKnownNoSync() const override { return getKnown(); }
 
   /// Helper function used to determine whether an instruction is non-relaxed
   /// atomic. In other words, if an atomic instruction does not have unordered
   /// or monotonic ordering
   static bool isNonRelaxedAtomic(Instruction *I);
 
   /// Helper function used to determine whether an instruction is volatile.
   static bool isVolatile(Instruction *I);
 
   /// Helper function uset to check if intrinsic is volatile (memcpy, memmove,
   /// memset).
   static bool isNoSyncIntrinsic(Instruction *I);
 };
 
 bool AANoSyncFunction::isNonRelaxedAtomic(Instruction *I) {
   if (!I->isAtomic())
     return false;
 
   AtomicOrdering Ordering;
   switch (I->getOpcode()) {
   case Instruction::AtomicRMW:
     Ordering = cast<AtomicRMWInst>(I)->getOrdering();
     break;
   case Instruction::Store:
     Ordering = cast<StoreInst>(I)->getOrdering();
     break;
   case Instruction::Load:
     Ordering = cast<LoadInst>(I)->getOrdering();
     break;

 bool AANoSyncFunction::isNoSyncIntrinsic(Instruction *I) {
   if (auto *II = dyn_cast<IntrinsicInst>(I)) {
     switch (II->getIntrinsicID()) {
     /// Element wise atomic memory intrinsics are can only be unordered,
     /// therefore nosync.
     case Intrinsic::memset_element_unordered_atomic:
     case Intrinsic::memmove_element_unordered_atomic:
     case Intrinsic::memcpy_element_unordered_atomic:
       return true;
     case Intrinsic::memset:
     case Intrinsic::memmove:
     case Intrinsic::memcpy:
       if (!cast<MemIntrinsic>(II)->isVolatile())
         return true;
       return false;
     default:
       return false;
struct AADereferenceableArgument : AADereferenceableImpl {
   AADereferenceableArgument(Argument &A, InformationCache &InfoCache)
       : AADereferenceableImpl(A, InfoCache) {}
 
   /// See AbstractAttribute::getManifestPosition().
   ManifestPosition getManifestPosition() const override { return MP_ARGUMENT; }
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override;
 };
 
 ChangeStatus AADereferenceableArgument::updateImpl(Attributor &A) {
   Function &F = getAnchorScope();
   Argument &Arg = cast<Argument>(getAnchoredValue());
 
   auto BeforeState = static_cast<DerefState>(*this);
 
   unsigned ArgNo = Arg.getArgNo();
 
   syncNonNull(A.getAAFor<AANonNull>(*this, F, ArgNo));
 
   bool IsNonNull = isAssumedNonNull();
   bool IsGlobal = isAssumedGlobal();
 
   // Callback function
   std::function<bool(CallSite)> CallSiteCheck = [&](CallSite CS) -> bool {
     assert(CS && "Sanity check: Call site was not initialized properly!");
 
     // Check that DereferenceableAA is AADereferenceableCallSiteArgument.
     if (auto *DereferenceableAA =
             A.getAAFor<AADereferenceable>(*this, *CS.getInstruction(), ArgNo)) {
       ImmutableCallSite ICS(&DereferenceableAA->getAnchoredValue());
       if (ICS && CS.getInstruction() == ICS.getInstruction()) {
         takeAssumedDerefBytesMinimum(
             DereferenceableAA->getAssumedDereferenceableBytes());
         IsNonNull &= DereferenceableAA->isAssumedNonNull();
         IsGlobal &= DereferenceableAA->isAssumedGlobal();
         return isValidState();
       }
     }
 
     takeAssumedDerefBytesMinimum(computeAssumedDerefenceableBytes(
         A, *CS.getArgOperand(ArgNo), IsNonNull, IsGlobal));
 
     return isValidState();
   };
 
   if (!A.checkForAllCallSites(F, CallSiteCheck, true)) {
     indicatePessimisticFixpoint();
     return ChangeStatus::CHANGED;
   }
 
   updateAssumedNonNullGlobalState(IsNonNull, IsGlobal);
 
   return BeforeState == static_cast<DerefState>(*this) ? ChangeStatus::UNCHANGED
                                                        : ChangeStatus::CHANGED;
 }
 
 /// Dereferenceable attribute for a call site argument.
 struct AADereferenceableCallSiteArgument : AADereferenceableImpl {
 
   /// See AADereferenceableImpl::AADereferenceableImpl(...).
   AADereferenceableCallSiteArgument(CallSite CS, unsigned ArgNo,
                                     InformationCache &InfoCache)
       : AADereferenceableImpl(CS.getArgOperand(ArgNo), *CS.getInstruction(),
                               InfoCache),
         ArgNo(ArgNo) {}
 
   /// See AbstractAttribute::initialize(...).
   void initialize(Attributor &A) override {
     CallSite CS(&getAnchoredValue());
     if (CS.paramHasAttr(ArgNo, Attribute::Dereferenceable))
       takeKnownDerefBytesMaximum(CS.getDereferenceableBytes(ArgNo));
 
     if (CS.paramHasAttr(ArgNo, Attribute::DereferenceableOrNull))
       takeKnownDerefBytesMaximum(CS.getDereferenceableOrNullBytes(ArgNo));
   }
 
   /// See AbstractAttribute::updateImpl(Attributor &A).
   ChangeStatus updateImpl(Attributor &A) override;
 
   /// See AbstractAttribute::getManifestPosition().
   ManifestPosition getManifestPosition() const override {
     return MP_CALL_SITE_ARGUMENT;
   };
 
   // Return argument index of associated value.
ChangeStatus AADereferenceableCallSiteArgument::updateImpl(Attributor &A) {
   takeAssumedDerefBytesMinimum(
       computeAssumedDerefenceableBytes(A, V, IsNonNull, IsGlobal));
   updateAssumedNonNullGlobalState(IsNonNull, IsGlobal);
 
   return BeforeState == static_cast<DerefState>(*this) ? ChangeStatus::UNCHANGED
                                                        : ChangeStatus::CHANGED;
 }
 
+// ------------------------ Align Argument Attribute ------------------------
+
+struct AAAlignImpl : AAAlign, IntegerState {
+
+  // Max alignemnt value allowed in IR
+  static const unsigned MAX_ALIGN = 1U << 29;
+
+  AAAlignImpl(Value *AssociatedVal, Value &AnchoredValue,
+              InformationCache &InfoCache)
+      : AAAlign(AssociatedVal, AnchoredValue, InfoCache),
+        IntegerState(MAX_ALIGN) {}
+
+  AAAlignImpl(Value &V, InformationCache &InfoCache)
+      : AAAlignImpl(&V, V, InfoCache) {}
+
+  /// See AbstractAttribute::getState()
+  /// {
+  AbstractState &getState() override { return *this; }
+  const AbstractState &getState() const override { return *this; }
+  /// }
+
+  virtual const std::string getAsStr() const override {
+    return getAssumedAlign() ? ("align<" + std::to_string(getKnownAlign()) +
+                                "-" + std::to_string(getAssumedAlign()) + ">")
+                             : "unknown-align";
+  }
+
+  /// See AAAlign::getAssumedAlign().
+  unsigned getAssumedAlign() const override { return getAssumed(); }
+
+  /// See AAAlign::getKnownAlign().
+  unsigned getKnownAlign() const override { return getKnown(); }
+
+  /// See AbstractAttriubute::initialize(...).
+  void initialize(Attributor &A) override {
+    Function &F = getAnchorScope();
+
+    unsigned AttrIdx =
+        getAttrIndex(getManifestPosition(), getArgNo(getAnchoredValue()));
+
+    // Already the function has align attribute on return value or argument.
+    if (F.getAttributes().hasAttribute(AttrIdx, ID))
+      addKnownBits(F.getAttribute(AttrIdx, ID).getAlignment());
+  }
+
+  /// See AbstractAttribute::getDeducedAttributes
+  virtual void
+  getDeducedAttributes(SmallVectorImpl<Attribute> &Attrs) const override {
+    LLVMContext &Ctx = AnchoredVal.getContext();
+
+    Attrs.emplace_back(Attribute::getWithAlignment(Ctx, getAssumedAlign()));
+  }
+};
+
+/// Align attribute for function return value.
+struct AAAlignReturned : AAAlignImpl {
+
+  AAAlignReturned(Function &F, InformationCache &InfoCache)
+      : AAAlignImpl(F, InfoCache) {}
+
+  /// See AbstractAttribute::getManifestPosition().
+  virtual ManifestPosition getManifestPosition() const override {
+    return MP_RETURNED;
+  }
+
+  /// See AbstractAttribute::updateImpl(...).
+  virtual ChangeStatus updateImpl(Attributor &A) override;
+};
+
+ChangeStatus AAAlignReturned::updateImpl(Attributor &A) {
+  Function &F = getAnchorScope();
+  auto *AARetValImpl = A.getAAFor<AAReturnedValuesImpl>(*this, F);
+  if (!AARetValImpl) {
+    indicatePessimisticFixpoint();
+    return ChangeStatus::CHANGED;
+  }
+
+  // Currently, align<n> is deduced if alignments in return values are assumed
+  // as greater than n. We reach pessimistic fixpoint if any of the return value
+  // wouldn't have align. If no assumed state was used for reasoning, an
+  // optimistic fixpoint is reached earlier.
+
+  base_t BeforeState = getAssumed();
+  std::function<bool(Value &)> Pred = [&](Value &RV) -> bool {
+    auto *AlignAA = A.getAAFor<AAAlign>(*this, RV);
+
+    if (AlignAA)
+      takeAssumedMinimum(AlignAA->getAssumedAlign());
+    else
+      // Use IR information.
+      takeAssumedMinimum(RV.getPointerAlignment(
+          getAnchorScope().getParent()->getDataLayout()));
+
+    return isValidState();
+  };
+
+  if (!AARetValImpl->checkForallReturnedValues(Pred)) {
+    indicatePessimisticFixpoint();
+    return ChangeStatus::CHANGED;
+  }
+
+  return (getAssumed() != BeforeState) ? ChangeStatus::CHANGED
+                                       : ChangeStatus::UNCHANGED;
+}
+
+/// Align attribute for function argument.
+struct AAAlignArgument : AAAlignImpl {
+
+  AAAlignArgument(Argument &A, InformationCache &InfoCache)
+      : AAAlignImpl(A, InfoCache) {}
+
+  /// See AbstractAttribute::getManifestPosition().
+  virtual ManifestPosition getManifestPosition() const override {
+    return MP_ARGUMENT;
+  }
+
+  /// See AbstractAttribute::updateImpl(...).
+  virtual ChangeStatus updateImpl(Attributor &A) override;
+};
+
+ChangeStatus AAAlignArgument::updateImpl(Attributor &A) {
+
+  Function &F = getAnchorScope();
+  Argument &Arg = cast<Argument>(getAnchoredValue());
+
+  unsigned ArgNo = Arg.getArgNo();
+  const DataLayout &DL = F.getParent()->getDataLayout();
+
+  auto BeforeState = getAssumed();
+
+  // Callback function
+  std::function<bool(CallSite)> CallSiteCheck = [&](CallSite CS) {
+    assert(CS && "Sanity check: Call site was not initialized properly!");
+
+    auto *AlignAA = A.getAAFor<AAAlign>(*this, *CS.getInstruction(), ArgNo);
+
+    // Check that AlignAA is AAAlignCallSiteArgument.
+    if (AlignAA) {
+      ImmutableCallSite ICS(&AlignAA->getAnchoredValue());
+      if (ICS && CS.getInstruction() == ICS.getInstruction()) {
+        takeAssumedMinimum(AlignAA->getAssumedAlign());
+        return isValidState();
+      }
+    }
+
+    Value *V = CS.getArgOperand(ArgNo);
+    takeAssumedMinimum(V->getPointerAlignment(DL));
+    return isValidState();
+  };
+
+  if (!A.checkForAllCallSites(F, CallSiteCheck, true))
+    indicatePessimisticFixpoint();
+
+  return BeforeState == getAssumed() ? ChangeStatus::UNCHANGED
+                                     : ChangeStatus ::CHANGED;
+}
+
+struct AAAlignCallSiteArgument : AAAlignImpl {
+
+  /// See AANonNullImpl::AANonNullImpl(...).
+  AAAlignCallSiteArgument(CallSite CS, unsigned ArgNo,
+                          InformationCache &InfoCache)
+      : AAAlignImpl(CS.getArgOperand(ArgNo), *CS.getInstruction(), InfoCache),
+        ArgNo(ArgNo) {}
+
+  /// See AbstractAttribute::initialize(...).
+  void initialize(Attributor &A) override {
+    CallSite CS(&getAnchoredValue());
+    takeKnownMaximum(getAssociatedValue()->getPointerAlignment(
+        getAnchorScope().getParent()->getDataLayout()));
+  }
+
+  /// See AbstractAttribute::updateImpl(Attributor &A).
+  ChangeStatus updateImpl(Attributor &A) override;
+
+  /// See AbstractAttribute::getManifestPosition().
+  ManifestPosition getManifestPosition() const override {
+    return MP_CALL_SITE_ARGUMENT;
+  };
+
+  // Return argument index of associated value.
+  int getArgNo() const { return ArgNo; }
+
+private:
+  unsigned ArgNo;
+};
+
+ChangeStatus AAAlignCallSiteArgument::updateImpl(Attributor &A) {
+  // NOTE: Never look at the argument of the callee in this method.
+  //       If we do this, "align" is always deduced because of the assumption.
+
+  auto BeforeState = getAssumed();
+
+  Value &V = *getAssociatedValue();
+
+  auto *AlignAA = A.getAAFor<AAAlign>(*this, V);
+
+  if (AlignAA)
+    takeAssumedMinimum(AlignAA->getAssumedAlign());
+  else
+    indicatePessimisticFixpoint();
+
+  return BeforeState == getAssumed() ? ChangeStatus::UNCHANGED
+                                     : ChangeStatus::CHANGED;
+}
+
 /// ----------------------------------------------------------------------------
 ///                               Attributor
 /// ----------------------------------------------------------------------------
 
 bool Attributor::checkForAllCallSites(Function &F,
                                       std::function<bool(CallSite)> &Pred,
                                       bool RequireAllCallSites) {
   // We can try to determine information from
void Attributor::identifyDefaultAbstractAttributes(
   Type *ReturnType = F.getReturnType();
   if (!ReturnType->isVoidTy()) {
     // Argument attribute "returned" --- Create only one per function even
     // though it is an argument attribute.
     if (!Whitelist || Whitelist->count(AAReturnedValues::ID))
       registerAA(*new AAReturnedValuesImpl(F, InfoCache));
 
     if (ReturnType->isPointerTy()) {
+      // Every function with pointer return type might be marked align.
+      if (!Whitelist || Whitelist->count(AAAlignReturned::ID))
+        registerAA(*new AAAlignReturned(F, InfoCache));
+
       // Every function with pointer return type might be marked nonnull.
       if (!Whitelist || Whitelist->count(AANonNullReturned::ID))
         registerAA(*new AANonNullReturned(F, InfoCache));
 
       // Every function with pointer return type might be marked noalias.
       if (!Whitelist || Whitelist->count(AANoAliasReturned::ID))
         registerAA(*new AANoAliasReturned(F, InfoCache));
 
for (Argument &Arg : F.args()) {
     if (Arg.getType()->isPointerTy()) {
       // Every argument with pointer type might be marked nonnull.
       if (!Whitelist || Whitelist->count(AANonNullArgument::ID))
         registerAA(*new AANonNullArgument(Arg, InfoCache));
 
       // Every argument with pointer type might be marked dereferenceable.
       if (!Whitelist || Whitelist->count(AADereferenceableArgument::ID))
         registerAA(*new AADereferenceableArgument(Arg, InfoCache));
+
+      // Every argument with pointer type might be marked align.
+      if (!Whitelist || Whitelist->count(AAAlignArgument::ID))
+        registerAA(*new AAAlignArgument(Arg, InfoCache));
     }
   }
 
   // Every function might be "will-return".
   registerAA(*new AAWillReturnFunction(F, InfoCache));
 
   // Check for dead BasicBlocks in every function.
   registerAA(*new AAIsDeadFunction(F, InfoCache));
if (CS && CS.getCalledFunction()) {
         if (!Whitelist || Whitelist->count(AANonNullCallSiteArgument::ID))
           registerAA(*new AANonNullCallSiteArgument(CS, i, InfoCache), i);
 
         // Call site argument attribute "dereferenceable".
         if (!Whitelist ||
             Whitelist->count(AADereferenceableCallSiteArgument::ID))
           registerAA(*new AADereferenceableCallSiteArgument(CS, i, InfoCache),
                      i);
+
+        // Call site argument attribute "align".
+        if (!Whitelist || Whitelist->count(AAAlignCallSiteArgument::ID))
+          registerAA(*new AAAlignCallSiteArgument(CS, i, InfoCache), i);
       }
     }
   }
 }
 
 /// Helpers to ease debugging through output streams and print calls.
 ///
 ///{

llvm/test/Transforms/FunctionAttrs/align.ll

+; RUN: opt -attributor -attributor-disable=false -S < %s | FileCheck %s --check-prefix=ATTRIBUTOR
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
+; Test cases specifically designed for "align" attribute.
+; We use FIXME's to indicate problems and missing attributes.
+
+
+; TEST 1
+; ATTRIBUTOR: define align 8 i32* @test1(i32* returned align 8)
+define i32* @test1(i32* align 8) #0 {
+  ret i32* %0
+}
+
+; TEST 2
+; ATTRIBUTOR: define i32* @test2(i32* returned)
+define i32* @test2(i32*) #0 {
+  ret i32* %0
+}
+
+; TEST 3
+; ATTRIBUTOR: define align 4 i32* @test3(i32* align 8, i32* align 4, i1)
+define i32* @test3(i32* align 8, i32* align 4, i1) #0 {
+  %ret = select i1 %2, i32* %0, i32* %1
+  ret i32* %ret
+}
+
+; TEST 4
+; ATTRIBUTOR: define align 32 i32* @test4(i32* align 32, i32* align 32, i1)
+define i32* @test4(i32* align 32, i32* align 32, i1) #0 {
+  %ret = select i1 %2, i32* %0, i32* %1
+  ret i32* %ret
+}
+
+; TEST 5
+declare i32* @unknown()
+declare align 8 i32* @align8()
+
+
+; ATTRIBUTOR: define align 8 i32* @test5_1()
+define i32* @test5_1() {
+  %ret = tail call align 8 i32* @unknown()
+  ret i32* %ret
+}
+
+; FIXME: missing align
+; ATTRIBUTOR: define i32* @test5_2()
+define i32* @test5_2() {
+  %ret = tail call i32* @align8()
+  ret i32* %ret
+}
+
+; TEST 6
+; SCC
+; ATTRIBUTOR: define noalias nonnull align 536870912 dereferenceable(4294967295) i32* @test6_1()
+define i32* @test6_1() #0 {
+  %ret = tail call i32* @test6_2()
+  ret i32* %ret
+}
+
+; ATTRIBUTOR: define noalias nonnull align 536870912 dereferenceable(4294967295) i32* @test6_2()
+define i32* @test6_2() #0 {
+  %ret = tail call i32* @test6_1()
+  ret i32* %ret
+}
+
+
+; char a1 __attribute__((aligned(8)));
+; char a2 __attribute__((aligned(16)));
+;
+; char* f1(char* a ){
+;     return a?a:f2(&a1);
+; }
+; char* f2(char* a){
+;     return a?f1(a):f3(&a2);
+; }
+;
+; char* f3(char* a){
+;     return a?&a1: f1(&a2);
+; }
+
+@a1 = common global i8 0, align 8
+@a2 = common global i8 0, align 16
+
+; Function Attrs: nounwind readnone ssp uwtable
+define internal i8* @f1(i8* readnone) local_unnamed_addr #0 {
+; ATTRIBUTOR: define internal nonnull align 8 i8* @f1(i8* nonnull readnone align 8)
+  %2 = icmp eq i8* %0, null
+  br i1 %2, label %3, label %5
+
+; <label>:3:                                      ; preds = %1
+; ATTRIBUTOR: %4 = tail call i8* @f2(i8* nonnull align 8 @a1)
+  %4 = tail call i8* @f2(i8* nonnull @a1)
+  br label %5
+
+; <label>:5:                                      ; preds = %1, %3
+  %6 = phi i8* [ %4, %3 ], [ %0, %1 ]
+  ret i8* %6
+}
+
+; Function Attrs: nounwind readnone ssp uwtable
+define internal i8* @f2(i8* readnone) local_unnamed_addr #0 {
+; ATTRIBUTOR: define internal nonnull align 8 i8* @f2(i8* nonnull readnone align 8)
+  %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 %0)
+  %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 @a2)
+  %6 = tail call i8* @f3(i8* nonnull @a2)
+  br label %7
+
+; <label>:7:                                      ; preds = %5, %3
+  %8 = phi i8* [ %4, %3 ], [ %6, %5 ]
+  ret i8* %8
+}
+
+; Function Attrs: nounwind readnone ssp uwtable
+define internal i8* @f3(i8* readnone) local_unnamed_addr #0 {
+; ATTRIBUTOR: define internal nonnull align 8 i8* @f3(i8* nonnull readnone align 16)
+  %2 = icmp eq i8* %0, null
+  br i1 %2, label %3, label %5
+
+; <label>:3:                                      ; preds = %1
+; ATTRIBUTOR: %4 = tail call i8* @f1(i8* nonnull align 16 @a2)
+  %4 = tail call i8* @f1(i8* nonnull @a2)
+  br label %5
+
+; <label>:5:                                      ; preds = %1, %3
+  %6 = phi i8* [ %4, %3 ], [ @a1, %1 ]
+  ret i8* %6
+}
+
+; TEST 7
+; Better than IR information
+; ATTRIBUTOR: define align 32 i32* @test7(i32* returned align 32 %p)
+define align 4 i32* @test7(i32* align 32 %p) #0 {
+  ret i32* %p
+}
+
+
+; TEST 8
+define void @test8_helper() {
+  %ptr0 = tail call i32* @unknown()
+  %ptr1 = tail call align 4 i32* @unknown()
+  %ptr2 = tail call align 8 i32* @unknown()
+
+  tail call void @test8(i32* %ptr1, i32* %ptr1, i32* %ptr0)
+; ATTRIBUTOR: tail call void @test8(i32* align 4 %ptr1, i32* align 4 %ptr1, i32* %ptr0)
+  tail call void @test8(i32* %ptr2, i32* %ptr1, i32* %ptr1)
+; ATTRIBUTOR: tail call void @test8(i32* align 8 %ptr2, i32* align 4 %ptr1, i32* align 4 %ptr1)
+  tail call void @test8(i32* %ptr2, i32* %ptr1, i32* %ptr1)
+; ATTRIBUTOR: tail call void @test8(i32* align 8 %ptr2, i32* align 4 %ptr1, i32* align 4 %ptr1)
+  ret void
+}
+
+define internal void @test8(i32* %a, i32* %b, i32* %c) {
+; ATTRIBUTOR: define internal void @test8(i32* align 4 %a, i32* align 4 %b, i32* %c)
+  ret void
+}
+
+
+attributes #0 = { nounwind uwtable noinline }
+attributes #1 = { uwtable noinline }

llvm/test/Transforms/FunctionAttrs/arg_nocapture.ll

 ;          srec16(srec16(srec16(srec16(
 ;                        a
 ;          ))))))))))))))));
 ; }
 ;
 ; Other arguments are possible here due to the no-return behavior.
 ;
 ; FIXME: no-return missing
-; CHECK: define noalias nonnull dereferenceable(4294967295) i32* @srec16(i32* nocapture readnone %a)
+; CHECK: define noalias nonnull align 536870912 dereferenceable(4294967295) i32* @srec16(i32* nocapture readnone %a)
 define i32* @srec16(i32* %a) #0 {
 entry:
   %call = call i32* @srec16(i32* %a)
   %call1 = call i32* @srec16(i32* %call)
   %call2 = call i32* @srec16(i32* %call1)
   %call3 = call i32* @srec16(i32* %call2)
   %call4 = call i32* @srec16(i32* %call3)
   %call5 = call i32* @srec16(i32* %call4)

llvm/test/Transforms/FunctionAttrs/noalias_returned.ll

5:                                                ; preds = %1, %3
   ret i8* %6
 }
 
 declare i8* @baz(...) nounwind uwtable
 
 ; TEST 5
 
 ; Returning global pointer. Should not be noalias.
-; CHECK: define nonnull dereferenceable(8) i8** @getter()
+; CHECK: define nonnull align 8 dereferenceable(8) i8** @getter()
 define i8** @getter() {
   ret i8** @G
 }
 
 ; Returning global pointer. Should not be noalias.
-; CHECK: define nonnull dereferenceable(8) i8** @calle1()
+; CHECK: define nonnull align 8 dereferenceable(8) i8** @calle1()
 define i8** @calle1(){
   %1 = call i8** @getter()
   ret i8** %1
 }
 
 ; TEST 6
 declare noalias i8* @strdup(i8* nocapture) nounwind
 

llvm/test/Transforms/FunctionAttrs/nonnull.ll

; BOTH: define nonnull i8* @test3
   ret i8* %ret
 }
 
 ; Given a mutual recursive set of functions, we can mark them
 ; nonnull if neither can ever return null.  (In this case, they
 ; just never return period.)
 define i8* @test4_helper() {
 ; FNATTR: define noalias nonnull i8* @test4_helper
-; ATTRIBUTOR: define noalias nonnull dereferenceable(4294967295) i8* @test4_helper
+; ATTRIBUTOR: define noalias nonnull align 536870912 dereferenceable(4294967295) i8* @test4_helper
   %ret = call i8* @test4()
   ret i8* %ret
 }
 
 define i8* @test4() {
 ; FNATTR: define noalias nonnull i8* @test4
-; ATTRIBUTOR: define noalias nonnull dereferenceable(4294967295) i8* @test4
+; ATTRIBUTOR: define noalias nonnull align 536870912 dereferenceable(4294967295) i8* @test4
   %ret = call i8* @test4_helper()
   ret i8* %ret
 }
 
 ; Given a mutual recursive set of functions which *can* return null
 ; make sure we haven't marked them as nonnull.
 define i8* @test5_helper() {
 ; FNATTR: define noalias i8* @test5_helper