[AA] Consider globalmemonly in getModRefInfo()

[MugilanGN]

Summary

If a function is GlobalMemOnly and a memory location does not point to a global object, getModRefInfo can infer that no aliasing between the function and the location can occur.

[nikic]

llvm/lib/Analysis/AliasAnalysis.cpp

283

Just because the underlying object is not a global value, doesn't mean that it can't be based on one -- e.g. imagine a global being passed to a function argument. getUnderlyingObject() will just give you the argument in that case, which may still alias with a global.

At the very least, you need to check for isIdentifiedObject() here. However, even that may be insufficient, as noalias arguments are identified objects, but I don't think you can apply this optimization to them (a noalias argument could point to a global, and a globalmemonly function could access the global through a passed-on noalias argument).

[jdoerfert]

llvm/lib/Analysis/AliasAnalysis.cpp

283

The last part is were it becomes interesting. If we say accesses to a global via an argument are globalmemonly or argmemonly. I think, given argmemonly, we could/should not say a function accessing globals only but via argument pointers can be globalmemonly. That resolves the problem here, I think. Identified objects are necessary for sure though.

llvm/include/llvm/Analysis/AliasAnalysis.h

 /// function call.
 enum FunctionModRefLocation {
   /// Base case is no access to memory.
   FMRL_Nowhere = 0,
   /// Access to memory via argument pointers.
   FMRL_ArgumentPointees = 8,
   /// Memory that is inaccessible via LLVM IR.
   FMRL_InaccessibleMem = 16,
+  /// Access to global variables
+  FMRL_GlobalMem = 32,
   /// Access to any memory.
-  FMRL_Anywhere = 32 | FMRL_InaccessibleMem | FMRL_ArgumentPointees
+  FMRL_Anywhere =
+      64 | FMRL_InaccessibleMem | FMRL_ArgumentPointees | FMRL_GlobalMem
 };
 
 /// Summary of how a function affects memory in the program.
 ///
 /// Loads from constant globals are not considered memory accesses for this
 /// interface. Also, functions may freely modify stack space local to their
 /// invocation without having to report it through these interfaces.
 enum FunctionModRefBehavior {
enum FunctionModRefBehavior {
 
   // This function does not read from memory anywhere, but may write to any
   // memory location.
   //
   // This property corresponds to the LLVM IR 'writeonly' attribute.
   // This property corresponds to the IntrWriteMem LLVM intrinsic flag.
   FMRB_OnlyWritesMemory = FMRL_Anywhere | static_cast<int>(ModRefInfo::Mod),
 
+  /// This function only reads and writes global variables.
+  ///
+  /// This property corresponds to the LLVM IR 'globalmemonly' attribute.
+  FMRB_OnlyAccessesGlobalMem =
+      FMRL_GlobalMem | static_cast<int>(ModRefInfo::ModRef),
+
   /// This indicates that the function could not be classified into one of the
   /// behaviors above.
   FMRB_UnknownModRefBehavior =
       FMRL_Anywhere | static_cast<int>(ModRefInfo::ModRef)
 };
 
 // Wrapper method strips bits significant only in FunctionModRefBehavior,
 // to obtain a valid ModRefInfo. The benefit of using the wrapper is that if
public:
   /// Checks if functions with the specified behavior are known to read and
   /// write at most from memory that is inaccessible from LLVM IR or objects
   /// pointed to by their pointer-typed arguments (with arbitrary offsets).
   static bool onlyAccessesInaccessibleOrArgMem(FunctionModRefBehavior MRB) {
     return !((unsigned)MRB & FMRL_Anywhere &
              ~(FMRL_InaccessibleMem | FMRL_ArgumentPointees));
   }
 
+  /// Checks if functions with the specified behavior are known to read and
+  /// write only from global variables.
+  static bool onlyAccessesGlobalMem(FunctionModRefBehavior MRB) {
+    return !((unsigned)MRB & FMRL_Anywhere & ~FMRL_GlobalMem);
+  }
+
   /// getModRefInfo (for call sites) - Return information about whether
   /// a particular call site modifies or reads the specified memory location.
   ModRefInfo getModRefInfo(const CallBase *Call, const MemoryLocation &Loc);
 
   /// getModRefInfo (for call sites) - A convenience wrapper.
   ModRefInfo getModRefInfo(const CallBase *Call, const Value *P,
                            LocationSize Size) {
     return getModRefInfo(Call, MemoryLocation(P, Size));

llvm/include/llvm/IR/Function.h

public:
   ///  inaccessible from the IR.
   bool onlyAccessesInaccessibleMemory() const {
     return hasFnAttribute(Attribute::InaccessibleMemOnly);
   }
   void setOnlyAccessesInaccessibleMemory() {
     addFnAttr(Attribute::InaccessibleMemOnly);
   }
 
+  /// Determine if the function may only access or modify global
+  /// variables
+  bool onlyAccessesGlobalMemory() const {
+    return hasFnAttribute(Attribute::GlobalMemOnly);
+  }
+  void setOnlyAccessesGlobalMemory() { addFnAttr(Attribute::GlobalMemOnly); }
+
   /// Determine if the function may only access memory that is
   ///  either inaccessible from the IR or pointed to by its arguments.
   bool onlyAccessesInaccessibleMemOrArgMem() const {
     return hasFnAttribute(Attribute::InaccessibleMemOrArgMemOnly);
   }
   void setOnlyAccessesInaccessibleMemOrArgMem() {
     addFnAttr(Attribute::InaccessibleMemOrArgMemOnly);
   }

llvm/include/llvm/IR/InstrTypes.h

public:
   /// Determine if the function may only access memory that is
   /// either inaccessible from the IR or pointed to by its arguments.
   bool onlyAccessesInaccessibleMemOrArgMem() const {
     return hasFnAttr(Attribute::InaccessibleMemOrArgMemOnly);
   }
   void setOnlyAccessesInaccessibleMemOrArgMem() {
     addFnAttr(Attribute::InaccessibleMemOrArgMemOnly);
   }
+
+  /// Determine if the function may only access or modify global
+  /// variables
+  bool onlyAccessesGlobalMemory() const {
+    return hasFnAttr(Attribute::GlobalMemOnly);
+  }
+  void setOnlyAccessesGlobalMemory() {
+    addAttribute(AttributeList::FunctionIndex, Attribute::GlobalMemOnly);
+  }
+
   /// Determine if the call cannot return.
   bool doesNotReturn() const { return hasFnAttr(Attribute::NoReturn); }
   void setDoesNotReturn() { addFnAttr(Attribute::NoReturn); }
 
   /// Determine if the call should not perform indirect branch tracking.
   bool doesNoCfCheck() const { return hasFnAttr(Attribute::NoCfCheck); }
 
   /// Determine if the call cannot unwind.

llvm/lib/Analysis/AliasAnalysis.cpp

if (onlyAccessesArgPointees(MRB) || onlyAccessesInaccessibleOrArgMem(MRB)) {
     if (isNoModRef(AllArgsMask))
       return ModRefInfo::NoModRef;
     // Logical & between other AA analyses and argument analysis.
     Result = intersectModRef(Result, AllArgsMask);
     // If only MustAlias found above, set Must bit.
     Result = IsMustAlias ? setMust(Result) : clearMust(Result);
   }
 
+  // If Loc is not a global memory location, it could not be modified or
+  // referenced by a call that only accesses global memory locations
+  if (onlyAccessesGlobalMem(MRB)) {
+    const Value *V1 =
+        getUnderlyingObject(Loc.Ptr->stripPointerCastsForAliasAnalysis());
+    if (!isa<GlobalValue>(V1)) {
+      return ModRefInfo::NoModRef;
+    }
+  }
+
   // If Loc is a constant memory location, the call definitely could not
   // modify the memory location.
   if (isModSet(Result) && pointsToConstantMemory(Loc, AAQI, /*OrLocal*/ false))
     Result = clearMod(Result);
 
   return Result;
 }
 

llvm/lib/Analysis/BasicAliasAnalysis.cpp

FunctionModRefBehavior BasicAAResult::getModRefBehavior(const CallBase *Call) {
 
   if (Call->onlyAccessesArgMemory())
     Min = FunctionModRefBehavior(Min & FMRB_OnlyAccessesArgumentPointees);
   else if (Call->onlyAccessesInaccessibleMemory())
     Min = FunctionModRefBehavior(Min & FMRB_OnlyAccessesInaccessibleMem);
   else if (Call->onlyAccessesInaccessibleMemOrArgMem())
     Min = FunctionModRefBehavior(Min & FMRB_OnlyAccessesInaccessibleOrArgMem);
 
+  if (Call->onlyAccessesGlobalMemory())
+    Min = FunctionModRefBehavior(Min & FMRB_OnlyAccessesGlobalMem);
+
   // If the call has operand bundles then aliasing attributes from the function
   // it calls do not directly apply to the call.  This can be made more precise
   // in the future.
   if (!Call->hasOperandBundles())
     if (const Function *F = Call->getCalledFunction())
       Min =
           FunctionModRefBehavior(Min & getBestAAResults().getModRefBehavior(F));
 
FunctionModRefBehavior BasicAAResult::getModRefBehavior(const Function *F) {
 
   if (F->onlyAccessesArgMemory())
     Min = FunctionModRefBehavior(Min & FMRB_OnlyAccessesArgumentPointees);
   else if (F->onlyAccessesInaccessibleMemory())
     Min = FunctionModRefBehavior(Min & FMRB_OnlyAccessesInaccessibleMem);
   else if (F->onlyAccessesInaccessibleMemOrArgMem())
     Min = FunctionModRefBehavior(Min & FMRB_OnlyAccessesInaccessibleOrArgMem);
 
+  if (F->onlyAccessesGlobalMemory())
+    Min = FunctionModRefBehavior(Min & FMRB_OnlyAccessesGlobalMem);
+
   return Min;
 }
 
 /// Returns true if this is a writeonly (i.e Mod only) parameter.
 static bool isWriteOnlyParam(const CallBase *Call, unsigned ArgIdx,
                              const TargetLibraryInfo &TLI) {
   if (Call->paramHasAttr(ArgIdx, Attribute::WriteOnly))
     return true;

llvm/test/Analysis/BasicAA/globalmemonly.ll

+; RUN: opt -basic-aa -print-all-alias-modref-info -aa-eval < %s 2>&1 | FileCheck %s
+
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+@g  = global i32 0, align 4
+@g2 = global i32 0, align 4
+
+define void @globalmemonly_function(i32* %0) globalmemonly {
+bb:
+  store i32 1, i32* @g2, align 4
+  ret void
+}
+
+define void @test_alloca_globalmemonly() {
+; CHECK:  Function: test_alloca_globalmemonly: 1 pointers, 1 call sites
+; CHECK-NEXT: NoModRef:  Ptr: i32* %0 <->  call void @globalmemonly_function(i32* %0)
+bb:
+  %0= alloca i32, align 4
+  store i32 1, i32* %0, align 4
+  call void @globalmemonly_function(i32* %0)
+  ret void
+}
+
+define void @test_global_globalmemonly() {
+; CHECK:  Function: test_global_globalmemonly: 1 pointers, 1 call sites
+; CHECK-NEXT: Both ModRef:  Ptr: i32* @g  <->  call void @globalmemonly_function(i32* @g)
+
+bb:
+  call void @globalmemonly_function(i32* @g)
+  ret void
+}