From 130d9efec3e856c1c8302df978afe5456ac7a0b9 Mon Sep 17 00:00:00 2001
From: Duncan Sands <baldrick@free.fr>
Date: Mon, 1 Sep 2008 11:40:11 +0000
Subject: [PATCH] Add a small pass that sets the readnone/readonly attributes
 on functions, based on the result of alias analysis.  It's not hardwired to
 use GlobalsModRef even though this is the only (AFAIK) alias analysis that
 results in this pass actually doing something.  Enable as follows:   opt ...
 -globalsmodref-aa -markmodref ... Advantages of this pass: (1) records the
 result of globalsmodref in the bitcode, meaning it is available for use by
 later passes (currently the pass manager isn't smart enough to magically make
 an advanced alias analysis available to all later passes), which may expose
 more optimization opportunities; (2) hopefully speeds up compilation when
 code is optimized twice, for example when a file is compiled to bitcode, then
 later LTO is done on it: marking functions readonly/readnone when producing
 the initial bitcode should speed up alias analysis during LTO; (3) good for
 discovering that globalsmodref doesn't work very well :) Not currently turned
 on by default.

llvm-svn: 55604
---
 llvm/include/llvm/LinkAllPasses.h         |  1 +
 llvm/include/llvm/Transforms/Scalar.h     |  5 ++
 llvm/lib/Transforms/Scalar/MarkModRef.cpp | 69 +++++++++++++++++++++++
 3 files changed, 75 insertions(+)
 create mode 100644 llvm/lib/Transforms/Scalar/MarkModRef.cpp

diff --git a/llvm/include/llvm/LinkAllPasses.h b/llvm/include/llvm/LinkAllPasses.h
index aabebf766a36..9e82e67507b1 100644
--- a/llvm/include/llvm/LinkAllPasses.h
+++ b/llvm/include/llvm/LinkAllPasses.h
@@ -85,6 +85,7 @@ namespace {
       (void) llvm::createLowerInvokePass();
       (void) llvm::createLowerSetJmpPass();
       (void) llvm::createLowerSwitchPass();
+      (void) llvm::createMarkModRefPass();
       (void) llvm::createNoAAPass();
       (void) llvm::createNoProfileInfoPass();
       (void) llvm::createProfileLoaderPass();
diff --git a/llvm/include/llvm/Transforms/Scalar.h b/llvm/include/llvm/Transforms/Scalar.h
index 8799a6f10931..3cd4a5c49951 100644
--- a/llvm/include/llvm/Transforms/Scalar.h
+++ b/llvm/include/llvm/Transforms/Scalar.h
@@ -137,6 +137,11 @@ LoopPass *createLoopRotatePass();
 //
 LoopPass *createLoopIndexSplitPass();
 
+//===----------------------------------------------------------------------===//
+//
+// MarkModRef - This pass marks functions readnone/readonly.
+//
+FunctionPass *createMarkModRefPass();
 
 //===----------------------------------------------------------------------===//
 //
diff --git a/llvm/lib/Transforms/Scalar/MarkModRef.cpp b/llvm/lib/Transforms/Scalar/MarkModRef.cpp
new file mode 100644
index 000000000000..e20278aed3ee
--- /dev/null
+++ b/llvm/lib/Transforms/Scalar/MarkModRef.cpp
@@ -0,0 +1,69 @@
+//===--------- MarkModRef.cpp - Mark functions readnone/readonly ----------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This pass marks functions readnone/readonly based on the results of alias
+// analysis.  This requires a sufficiently powerful alias analysis, such as
+// GlobalsModRef (invoke as "opt ... -globalsmodref-aa -markmodref ...").
+//
+//===----------------------------------------------------------------------===//
+
+#define DEBUG_TYPE "markmodref"
+#include "llvm/ADT/Statistic.h"
+#include "llvm/Analysis/AliasAnalysis.h"
+#include "llvm/Support/Compiler.h"
+#include "llvm/Transforms/Scalar.h"
+#include "llvm/Function.h"
+#include "llvm/Pass.h"
+using namespace llvm;
+
+STATISTIC(NumReadNone, "Number of functions marked readnone");
+STATISTIC(NumReadOnly, "Number of functions marked readonly");
+
+namespace {
+  struct VISIBILITY_HIDDEN MarkModRef : public FunctionPass {
+    static char ID; // Pass identification, replacement for typeid
+    MarkModRef() : FunctionPass((intptr_t)&ID) {}
+
+    bool runOnFunction(Function &F);
+
+    virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+      AU.setPreservesCFG();
+      AU.addRequired<AliasAnalysis>();
+      AU.addPreserved<AliasAnalysis>();
+    }
+  };
+}
+
+char MarkModRef::ID = 0;
+static RegisterPass<MarkModRef>
+X("markmodref", "Mark functions readnone/readonly");
+
+bool MarkModRef::runOnFunction(Function &F) {
+  // FIXME: Wrong for functions with weak linkage.
+  if (F.doesNotAccessMemory())
+    // Cannot do better.
+    return false;
+
+  AliasAnalysis &AA = getAnalysis<AliasAnalysis>();
+  AliasAnalysis::ModRefBehavior ModRef = AA.getModRefBehavior(&F);
+  if (ModRef == AliasAnalysis::DoesNotAccessMemory) {
+    F.setDoesNotAccessMemory();
+    NumReadNone++;
+    return true;
+  } else if (ModRef == AliasAnalysis::OnlyReadsMemory && !F.onlyReadsMemory()) {
+    F.setOnlyReadsMemory();
+    NumReadOnly++;
+    return true;
+  }
+  return false;
+}
+
+FunctionPass *llvm::createMarkModRefPass() {
+  return new MarkModRef();
+}