[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

1885

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

1909

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.

1921

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.

1941

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

329

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

832

return value or argument, right?

836

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.

846

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?

847

style: remove braces around single statements.

898

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."

1872

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

1977

Are the statistics missing?

1981

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

1985

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

2023

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

2383

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

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 {
+  AAAlignImpl(Value &V, InformationCache &InfoCache)
+      : AAAlign(V, InfoCache), IntegerState(1U << 29) {}
+
+  AAAlignImpl(Value *AssociatedVal, Value &AnchoredValue,
+              InformationCache &InfoCache)
+      : AAAlign(AssociatedVal, AnchoredValue, 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, getKnownAlign()));
+  }
+};
+
+/// 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 known 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<AAAlignImpl>(*this, RV);
+
+    if (AlignAA && AlignAA->isValidState()) {
+      takeAssumedMinimum(AlignAA->getAssumedAlign());
+      return true;
+    }
+
+    unsigned Align =
+        RV.getPointerAlignment(getAnchorScope().getParent()->getDataLayout());
+
+    // Alignment is known in IR information.
+    if (Align) {
+      takeAssumedMinimum(Align);
+      return true;
+    }
+
+    return false;
+  };
+
+  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 (ReturnType->isPointerTy() &&
+          (!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 align 8 i32* @align8() #0
+declare i32* @unknown() #0
+
+
+; define i32* @test5() {
+;  %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
+}
+
+
+; 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)
+  tail call void @test8(i32* %ptr2, i32* %ptr1, i32* %ptr1)
+  tail call void @test8(i32* %ptr2, i32* %ptr1, i32* %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 }
 No newline at end of file

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