FunctionAttrs: Factor out a function for querying memory access of a specific copy of a function. NFC.

[pcc]

Summary

This will later be used by ThinLTOBitcodeWriter to add copies of readnone
functions to the regular LTO module.

[tejohnson]

llvm/lib/Transforms/IPO/FunctionAttrs.cpp

55

Why don't we want to check this in the callers of computeFunctionBodyMemoryAccess? Isn't it a strong guarantee?

[pcc]

• Address review comments

[pcc]

llvm/lib/Transforms/IPO/FunctionAttrs.cpp

55

Yes, we could (and that would let us simplify the caller in D29803 a little). I've uploaded a new patch that does that, and also simplifies the signature of computeFunctionBodyMemoryAccess a little by removing the SCCNodeSet, as we currently have no plans to call that function from an SCC pass.

[tejohnson]

llvm/lib/Transforms/IPO/FunctionAttrs.cpp

52

Document options (specifically the new ThisBody needs some comment).

[tejohnson]

LGTM with comment as suggested

llvm/include/llvm/Transforms/IPO/FunctionAttrs.h

 #define LLVM_TRANSFORMS_IPO_FUNCTIONATTRS_H
 
 #include "llvm/Analysis/LazyCallGraph.h"
 #include "llvm/Analysis/CGSCCPassManager.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
+class AAResults;
+
+typedef SmallSetVector<Function *, 8> SCCNodeSet;
+
+/// The three kinds of memory access relevant to 'readonly' and
+/// 'readnone' attributes.
+enum MemoryAccessKind {
+  MAK_ReadNone = 0,
+  MAK_ReadOnly = 1,
+  MAK_MayWrite = 2
+};
+
+/// Returns the memory access properties of this copy of the function.
+MemoryAccessKind
+computeFunctionBodyMemoryAccess(Function &F, AAResults &AAR,
+                                const SCCNodeSet &SCCNodes);
+
 /// Computes function attributes in post-order over the call graph.
 ///
 /// By operating in post-order, this pass computes precise attributes for
 /// called functions prior to processsing their callers. This "bottom-up"
 /// approach allows powerful interprocedural inference of function attributes
 /// like memory access patterns, etc. It can discover functions that do not
 /// access memory, or only read memory, and give them the readnone/readonly
 /// attribute. It also discovers function arguments that are not captured by

llvm/lib/Transforms/IPO/FunctionAttrs.cpp

 STATISTIC(NumNoCapture, "Number of arguments marked nocapture");
 STATISTIC(NumReturned, "Number of arguments marked returned");
 STATISTIC(NumReadNoneArg, "Number of arguments marked readnone");
 STATISTIC(NumReadOnlyArg, "Number of arguments marked readonly");
 STATISTIC(NumNoAlias, "Number of function returns marked noalias");
 STATISTIC(NumNonNullReturn, "Number of function returns marked nonnull");
 STATISTIC(NumNoRecurse, "Number of functions marked as norecurse");
 
-namespace {
-typedef SmallSetVector<Function *, 8> SCCNodeSet;
-}
-
-namespace {
-/// The three kinds of memory access relevant to 'readonly' and
-/// 'readnone' attributes.
-enum MemoryAccessKind {
-  MAK_ReadNone = 0,
-  MAK_ReadOnly = 1,
-  MAK_MayWrite = 2
-};
-}
-
 static MemoryAccessKind checkFunctionMemoryAccess(Function &F, AAResults &AAR,
                                                   const SCCNodeSet &SCCNodes) {
   FunctionModRefBehavior MRB = AAR.getModRefBehavior(&F);
   if (MRB == FMRB_DoesNotAccessMemory)
     // Already perfect!
     return MAK_ReadNone;
 
   // Non-exact function definitions may not be selected at link time, and an
   // alternative version that writes to memory may be selected.  See the comment
   // on GlobalValue::isDefinitionExact for more details.
   if (!F.hasExactDefinition()) {
     if (AliasAnalysis::onlyReadsMemory(MRB))
       return MAK_ReadOnly;
 
     // Conservatively assume it writes to memory.
     return MAK_MayWrite;
   }
 
+  return computeFunctionBodyMemoryAccess(F, AAR, SCCNodes);
+}
+
+MemoryAccessKind
+llvm::computeFunctionBodyMemoryAccess(Function &F, AAResults &AAR,
+                                      const SCCNodeSet &SCCNodes) {
   // Scan the function body for instructions that may read or write memory.
   bool ReadsMemory = false;
   for (inst_iterator II = inst_begin(F), E = inst_end(F); II != E; ++II) {
     Instruction *I = &*II;
 
     // Some instructions can be ignored even if they read or write memory.
     // Detect these now, skipping to the next instruction if one is found.
     CallSite CS(cast<Value>(I));