[GlobalsModRef] Apply indirect-global rule to all globals initialized from noalias calls

[reames]

Summary

Extend the existing malloc-family specific optimization to all noalias calls.

[nikic]

LGTM

llvm/lib/Analysis/GlobalsModRef.cpp

for (Use &U : V->uses()) {
     }
   }
 
   return false;
 }
 
 /// AnalyzeIndirectGlobalMemory - We found an non-address-taken global variable
 /// which holds a pointer type.  See if the global always points to non-aliased
-/// heap memory: that is, all initializers of the globals are allocations, and
-/// those allocations have no use other than initialization of the global.
+/// heap memory: that is, all initializers of the globals store a value known
+/// to be obtained via a noalias return function call which have no other use.
 /// Further, all loads out of GV must directly use the memory, not store the
 /// pointer somewhere.  If this is true, we consider the memory pointed to by
 /// GV to be owned by GV and can disambiguate other pointers from it.
 bool GlobalsAAResult::AnalyzeIndirectGlobalMemory(GlobalVariable *GV) {
   // Keep track of values related to the allocation of the memory, f.e. the
-  // value produced by the malloc call and any casts.
+  // value produced by the noalias call and any casts.
   std::vector<Value *> AllocRelatedValues;
 
   // If the initializer is a valid pointer, bail.
   if (Constant *C = GV->getInitializer())
     if (!C->isNullValue())
       return false;
 
   // Walk the user list of the global.  If we find anything other than a direct
if (LoadInst *LI = dyn_cast<LoadInst>(U)) {
 
       // If storing the null pointer, ignore it.
       if (isa<ConstantPointerNull>(SI->getOperand(0)))
         continue;
 
       // Check the value being stored.
       Value *Ptr = getUnderlyingObject(SI->getOperand(0));
 
-      if (!isAllocLikeFn(Ptr, &GetTLI(*SI->getFunction())))
+      if (!isNoAliasCall(Ptr))
         return false; // Too hard to analyze.
 
       // Analyze all uses of the allocation.  If any of them are used in a
       // non-simple way (e.g. stored to another global) bail out.
       if (AnalyzeUsesOfPointer(Ptr, /*Readers*/ nullptr, /*Writers*/ nullptr,
                                GV))
         return false; // Loaded pointer escapes.
 

llvm/test/Analysis/GlobalsModRef/indirect-global.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -basic-aa -globals-aa -gvn -instcombine -S -enable-unsafe-globalsmodref-alias-results | FileCheck %s
 ; RUN: opt < %s -aa-pipeline=basic-aa,globals-aa -passes="require<globals-aa>,function(gvn,instcombine)" -S -enable-unsafe-globalsmodref-alias-results | FileCheck %s
 ;
 ; Note that this test relies on an unsafe feature of GlobalsModRef. While this
 ; test is correct and safe, GMR's technique for handling this isn't generally.
 
 @G = internal global i32* null    ; <i32**> [#uses=3]
 
-declare i8* @malloc(i32)
+declare noalias i8* @malloc(i32)
 define void @malloc_init() {
 ; CHECK-LABEL: @malloc_init(
 ; CHECK-NEXT:    [[A:%.*]] = call dereferenceable_or_null(4) i8* @malloc(i32 4)
 ; CHECK-NEXT:    store i8* [[A]], i8** bitcast (i32** @G to i8**), align 8
 ; CHECK-NEXT:    ret void
 ;
   %a = call i8* @malloc(i32 4)
   %A = bitcast i8* %a to i32*
;
   %g2 = load i32*, i32** @G    ; <i32*> [#uses=0]
   %h2 = load i32, i32* %g1    ; <i32> [#uses=1]
   %X = sub i32 %h1, %h2   ; <i32> [#uses=1]
   ret i32 %X
 }
 
 @G2 = internal global i32* null   ; <i32**> [#uses=3]
 
-declare i8* @calloc(i32, i32)
+declare noalias i8* @calloc(i32, i32)
 define void @calloc_init() {
 ; CHECK-LABEL: @calloc_init(
 ; CHECK-NEXT:    [[A:%.*]] = call dereferenceable_or_null(4) i8* @calloc(i32 4, i32 1)
 ; CHECK-NEXT:    store i8* [[A]], i8** bitcast (i32** @G2 to i8**), align 8
 ; CHECK-NEXT:    ret void
 ;
   %a = call i8* @calloc(i32 4, i32 1)
   %A = bitcast i8* %a to i32*
;
   %a = call i8* @my_alloc(i32 4)
   %A = bitcast i8* %a to i32*
   store i32* %A, i32** @G3
   ret void
 }
 
 define i32 @my_alloc_test(i32* %P) {
 ; CHECK-LABEL: @my_alloc_test(
-; CHECK-NEXT:    [[G1:%.*]] = load i32*, i32** @G3, align 8
-; CHECK-NEXT:    [[H1:%.*]] = load i32, i32* [[G1]], align 4
 ; CHECK-NEXT:    store i32 123, i32* [[P:%.*]], align 4
-; CHECK-NEXT:    [[H2:%.*]] = load i32, i32* [[G1]], align 4
-; CHECK-NEXT:    [[X:%.*]] = sub i32 [[H1]], [[H2]]
-; CHECK-NEXT:    ret i32 [[X]]
+; CHECK-NEXT:    ret i32 0
 ;
   %g1 = load i32*, i32** @G3    ; <i32*> [#uses=2]
   %h1 = load i32, i32* %g1    ; <i32> [#uses=1]
   store i32 123, i32* %P
   %g2 = load i32*, i32** @G3    ; <i32*> [#uses=0]
   %h2 = load i32, i32* %g1    ; <i32> [#uses=1]
   %X = sub i32 %h1, %h2   ; <i32> [#uses=1]
   ret i32 %X
 }