[Analysis] Attribute alignment should not prevent tail call optimization

[xbolva00]

Summary

Fixes tail folding issue mentioned in D100879.

[dmgreen]

Thanks. LGTM

There is also some code in TargetLowering::isInTailCallPosition, but I believe that only gets used in expanding libcalls. Might be worth a check though, to see if it deserves the same treatment.

[xbolva00]

Handle isInTailCallPosition too.

llvm/lib/CodeGen/Analysis.cpp

bool llvm::attributesPermitTailCall(const Function *F, const Instruction *I,
   ADS = true;
 
   AttrBuilder CallerAttrs(F->getAttributes(), AttributeList::ReturnIndex);
   AttrBuilder CalleeAttrs(cast<CallInst>(I)->getAttributes(),
                           AttributeList::ReturnIndex);
 
   // Following attributes are completely benign as far as calling convention
   // goes, they shouldn't affect whether the call is a tail call.
-  CallerAttrs.removeAttribute(Attribute::NoAlias);
-  CalleeAttrs.removeAttribute(Attribute::NoAlias);
-  CallerAttrs.removeAttribute(Attribute::NonNull);
-  CalleeAttrs.removeAttribute(Attribute::NonNull);
-  CallerAttrs.removeAttribute(Attribute::Dereferenceable);
-  CalleeAttrs.removeAttribute(Attribute::Dereferenceable);
-  CallerAttrs.removeAttribute(Attribute::DereferenceableOrNull);
-  CalleeAttrs.removeAttribute(Attribute::DereferenceableOrNull);
+  for (const auto &Attr : {Attribute::Alignment, Attribute::Dereferenceable,
+                           Attribute::DereferenceableOrNull, Attribute::NoAlias,
+                           Attribute::NonNull}) {
+    CallerAttrs.removeAttribute(Attr);
+    CalleeAttrs.removeAttribute(Attr);
+  }
 
   if (CallerAttrs.contains(Attribute::ZExt)) {
     if (!CalleeAttrs.contains(Attribute::ZExt))
       return false;
 
     ADS = false;
     CallerAttrs.removeAttribute(Attribute::ZExt);
     CalleeAttrs.removeAttribute(Attribute::ZExt);

llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp

bool TargetLowering::isInTailCallPosition(SelectionDAG &DAG, SDNode *Node,
                                           SDValue &Chain) const {
   const Function &F = DAG.getMachineFunction().getFunction();
 
   // First, check if tail calls have been disabled in this function.
   if (F.getFnAttribute("disable-tail-calls").getValueAsBool())
     return false;
 
   // Conservatively require the attributes of the call to match those of
-  // the return. Ignore NoAlias and NonNull because they don't affect the
+  // the return. Ignore following attributes because they don't affect the
   // call sequence.
-  AttributeList CallerAttrs = F.getAttributes();
-  if (AttrBuilder(CallerAttrs, AttributeList::ReturnIndex)
-          .removeAttribute(Attribute::NoAlias)
-          .removeAttribute(Attribute::NonNull)
-          .hasAttributes())
+  AttrBuilder CallerAttrs(F.getAttributes(), AttributeList::ReturnIndex);
+  for (const auto &Attr : {Attribute::Alignment, Attribute::Dereferenceable,
+                           Attribute::DereferenceableOrNull, Attribute::NoAlias,
+                           Attribute::NonNull})
+    CallerAttrs.removeAttribute(Attr);
+
+  if (CallerAttrs.hasAttributes())
     return false;
 
   // It's not safe to eliminate the sign / zero extension of the return value.
-  if (CallerAttrs.hasAttribute(AttributeList::ReturnIndex, Attribute::ZExt) ||
-      CallerAttrs.hasAttribute(AttributeList::ReturnIndex, Attribute::SExt))
+  if (CallerAttrs.contains(Attribute::ZExt) ||
+      CallerAttrs.contains(Attribute::SExt))
     return false;
 
   // Check if the only use is a function return node.
   return isUsedByReturnOnly(Node, Chain);
 }
 
 bool TargetLowering::parametersInCSRMatch(const MachineRegisterInfo &MRI,
     const uint32_t *CallerPreservedMask,

llvm/test/CodeGen/ARM/tail-call.ll

 define void @v_caller_ints_fail(i32 %y, i64 %z) {
 ; CHECK-LABEL: v_caller_ints_fail:
 ; CHECK: bl variadic
 entry:
   %call = tail call i32 (i32, ...) @variadic(i32 %y, i64 %z, i64 %z)
   ret void
 }
 
-; Check that NonNull attributes don't inhibit tailcalls.
+; Check that nonnull attributes don't inhibit tailcalls.
 
 declare nonnull i8* @nonnull_callee(i8* %p, i32 %val)
 define i8* @nonnull_caller(i8* %p, i32 %val) {
 ; CHECK-LABEL: nonnull_caller:
 ; CHECK-TAIL: b nonnull_callee
 ; CHECK-NO-TAIL: bl nonnull_callee
 entry:
   %call = tail call i8* @nonnull_callee(i8* %p, i32 %val)
   ret i8* %call
 }
+
+; Check that noalias attributes don't inhibit tailcalls.
+
+declare noalias i8* @noalias_callee(i8* %p, i32 %val)
+define i8* @noalias_caller(i8* %p, i32 %val) {
+; CHECK-LABEL: noalias_caller:
+; CHECK-TAIL: b noalias_callee
+; CHECK-NO-TAIL: bl noalias_callee
+entry:
+  %call = tail call i8* @noalias_callee(i8* %p, i32 %val)
+  ret i8* %call
+}
+
+
+; Check that alignment attributes don't inhibit tailcalls.
+
+declare align 8 i8* @align8_callee(i8* %p, i32 %val)
+define i8* @align8_caller(i8* %p, i32 %val) {
+; CHECK-LABEL: align8_caller:
+; CHECK-TAIL: b align8_callee
+; CHECK-NO-TAIL: bl align8_callee
+entry:
+  %call = tail call i8* @align8_callee(i8* %p, i32 %val)
+  ret i8* %call
+}

llvm/test/CodeGen/X86/tail-calls-compatible-attrs.ll

 
 define i8* @test4() nounwind {
 ; CHECK-LABEL: test4:
 ; CHECK:       # %bb.0:
 ; CHECK-NEXT:    jmp foo # TAILCALL
   %ret = tail call dereferenceable_or_null(8) i8* @foo()
   ret i8* %ret
 }
+
+define align 8 i8* @test5() nounwind {
+; CHECK-LABEL: test5:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    jmp foo # TAILCALL
+  %ret = tail call i8* @foo()
+  ret i8* %ret
+}
+
+define i8* @test6() nounwind {
+; CHECK-LABEL: test6:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    jmp foo # TAILCALL
+  %ret = tail call align 8 i8* @foo()
+  ret i8* %ret
+}