!fixup refine aa handling

Author: antoniofrighetto

llvm/lib/Analysis/BasicAliasAnalysis.cpp

@@ -929,6 +929,7 @@ ModRefInfo BasicAAResult::getModRefInfo(const CallBase *Call,
     return ModRefInfo::NoModRef;
 
   ModRefInfo ArgMR = ME.getModRef(IRMemLocation::ArgMem);
+  ModRefInfo ErrnoMR = ME.getModRef(IRMemLocation::ErrnoMem);
   ModRefInfo OtherMR = ME.getModRef(IRMemLocation::Other);
 
   // An identified function-local object that does not escape can only be
@@ -971,12 +972,17 @@ ModRefInfo BasicAAResult::getModRefInfo(const CallBase *Call,
 
   ModRefInfo Result = ArgMR | OtherMR;
 
-  // Refine writes to errno memory. Do not include the errno location, if TBAA
-  // proves the given memory location does not alias errno.
-  ModRefInfo ErrnoMR = ME.getModRef(IRMemLocation::ErrnoMem);
-  if (ErrnoMR == ModRefInfo::Mod &&
-      AAQI.AAR.aliasErrno(Loc, Call->getModule()) != AliasResult::NoAlias)
-    Result |= ErrnoMR;
+  // Refine writes to errno memory. We can safely exclude the errno location if
+  // the given memory location is an alloca, the size of the memory access is
+  // larger than `sizeof(int)` or if TBAA proves it does not alias errno.
+  if ((ErrnoMR | OtherMR) != OtherMR) {
+    bool IsLocSizeUnknown = Loc.Size == MemoryLocation::UnknownSize;
+    if (ErrnoMR == ModRefInfo::Mod && !isa<AllocaInst>(Object) &&
+        (IsLocSizeUnknown ||
+         (!IsLocSizeUnknown && Loc.Size.getValue() <= sizeof(int))) &&
+        AAQI.AAR.aliasErrno(Loc, Call->getModule()) != AliasResult::NoAlias)
+      Result |= ErrnoMR;
+  }
 
   if (!isModAndRefSet(Result))
     return Result;

llvm/test/Transforms/InstCombine/may-alias-errno.ll

@@ -7,7 +7,7 @@ define float @does_not_alias_errno(ptr noundef %p, float noundef %f) {
 ; CHECK-LABEL: define float @does_not_alias_errno(
 ; CHECK-SAME: ptr noundef [[P:%.*]], float noundef [[F:%.*]]) {
 ; CHECK-NEXT:  [[ENTRY:.*:]]
-; CHECK-NEXT:    store float 0.000000e+00, ptr [[P]], align 4, !tbaa [[TBAA3:![0-9]+]]
+; CHECK-NEXT:    store float 0.000000e+00, ptr [[P]], align 4, !tbaa [[TBAA4:![0-9]+]]
 ; CHECK-NEXT:    [[CALL:%.*]] = call float @sinf(float noundef [[F]])
 ; CHECK-NEXT:    ret float 0.000000e+00
 ;
@@ -18,6 +18,42 @@ entry:
   ret float %0
 }
 
+; sinf clobbering errno, but %p is alloca memory, wich can never aliases errno.
+; Hence, can do constant store-to-load forwarding.
+define float @does_not_alias_errno_2(float %f) {
+; CHECK-LABEL: define float @does_not_alias_errno_2(
+; CHECK-SAME: float [[F:%.*]]) {
+; CHECK-NEXT:    [[P:%.*]] = alloca float, align 4
+; CHECK-NEXT:    call void @escape(ptr nonnull [[P]])
+; CHECK-NEXT:    store float 0.000000e+00, ptr [[P]], align 4
+; CHECK-NEXT:    [[TMP1:%.*]] = call float @sinf(float [[F]])
+; CHECK-NEXT:    ret float 0.000000e+00
+;
+  %p = alloca float
+  call void @escape(ptr %p)
+  store float 0.0, ptr %p
+  call float @sinf(float %f)
+  %v = load float, ptr %p
+  ret float %v
+}
+
+; sinf clobbering errno, but %p is memory accessed w/ size larger than errno.
+; Hence, can do constant store-to-load forwarding.
+define double @does_not_alias_errno_3(ptr %p, float %f) {
+; CHECK-LABEL: define double @does_not_alias_errno_3(
+; CHECK-SAME: ptr [[P:%.*]], float [[F:%.*]]) {
+; CHECK-NEXT:    call void @escape(ptr [[P]])
+; CHECK-NEXT:    store double 0.000000e+00, ptr [[P]], align 8
+; CHECK-NEXT:    [[TMP1:%.*]] = call float @sinf(float [[F]])
+; CHECK-NEXT:    ret double 0.000000e+00
+;
+  call void @escape(ptr %p)
+  store double 0.0, ptr %p
+  call float @sinf(float %f)
+  %v = load double, ptr %p
+  ret double %v
+}
+
 ; sinf clobbering errno, unknown TBAA info, %p may alias errno.
 define float @may_alias_errno(ptr noundef %p, float noundef %f) {
 ; CHECK-LABEL: define float @may_alias_errno(
@@ -36,6 +72,7 @@ entry:
 }
 
 declare float @sinf(float noundef) memory(errnomem: write)
+declare void @escape(ptr %p)
 
 !llvm.errno.tbaa = !{!0}
 
@@ -45,3 +82,9 @@ declare float @sinf(float noundef) memory(errnomem: write)
 !3 = !{!"Simple C/C++ TBAA"}
 !4 = !{!5, !5, i64 0}
 !5 = !{!"float", !2, i64 0}
+;.
+; CHECK: [[META2:![0-9]+]] = !{!"omnipotent char", [[META3:![0-9]+]], i64 0}
+; CHECK: [[META3]] = !{!"Simple C/C++ TBAA"}
+; CHECK: [[TBAA4]] = !{[[META5:![0-9]+]], [[META5]], i64 0}
+; CHECK: [[META5]] = !{!"float", [[META2]], i64 0}
+;.