llvm.isnan doesn't access memory

[oota-llvm.git] / lib / Analysis / BasicAliasAnalysis.cpp

diff --git a/lib/Analysis/BasicAliasAnalysis.cpp b/lib/Analysis/BasicAliasAnalysis.cpp
index 8fc561ea1d9cc09b7afc4e8a9cd9a8e871d50070..efaa7beb89baad1a845673c507152aa0b355d9be 100644 (file)
--- a/lib/Analysis/BasicAliasAnalysis.cpp
+++ b/lib/Analysis/BasicAliasAnalysis.cpp
@@ -36,13 +36,55 @@ using namespace llvm;
 void llvm::BasicAAStub() {}
 
 namespace {
-  struct BasicAliasAnalysis : public ImmutablePass, public AliasAnalysis {
-    
+  /// NoAA - This class implements the -no-aa pass, which always returns "I
+  /// don't know" for alias queries.  NoAA is unlike other alias analysis
+  /// implementations, in that it does not chain to a previous analysis.  As
+  /// such it doesn't follow many of the rules that other alias analyses must.
+  ///
+  struct NoAA : public ImmutablePass, public AliasAnalysis {
+    virtual AliasResult alias(const Value *V1, unsigned V1Size,
+                              const Value *V2, unsigned V2Size) {
+      return MayAlias;
+    }
+
+    virtual void getMustAliases(Value *P, std::vector<Value*> &RetVals) { }
+    virtual bool pointsToConstantMemory(const Value *P) { return false; }
+    virtual bool doesNotAccessMemory(Function *F) { return false; }
+    virtual bool onlyReadsMemory(Function *F) { return false; }
+    virtual ModRefResult getModRefInfo(CallSite CS, Value *P, unsigned Size) {
+      return ModRef;
+    }
+    virtual ModRefResult getModRefInfo(CallSite CS1, CallSite CS2) {
+      return ModRef;
+    }
+    virtual bool hasNoModRefInfoForCalls() const { return true; }
+
+    virtual void deleteValue(Value *V) {}
+    virtual void copyValue(Value *From, Value *To) {}
+    virtual void getAnalysisUsage(AnalysisUsage &AU) const {}
+  };
+ 
+  // Register this pass...
+  RegisterOpt<NoAA>
+  U("no-aa", "No Alias Analysis (always returns 'may' alias)");
+
+  // Declare that we implement the AliasAnalysis interface
+  RegisterAnalysisGroup<AliasAnalysis, NoAA> V;
+}  // End of anonymous namespace
+
+
+namespace {
+  /// BasicAliasAnalysis - This is the default alias analysis implementation.
+  /// Because it doesn't chain to a previous alias analysis (like -no-aa), it
+  /// derives from the NoAA class.
+  struct BasicAliasAnalysis : public NoAA {
     virtual void getAnalysisUsage(AnalysisUsage &AU) const {
-      AliasAnalysis::getAnalysisUsage(AU);
+      AU.addRequired<TargetData>();
     }
     
-    virtual void initializePass();
+    virtual void initializePass() {
+      TD = &getAnalysis<TargetData>();
+    }
 
     AliasResult alias(const Value *V1, unsigned V1Size,
                       const Value *V2, unsigned V2Size);
@@ -79,10 +121,6 @@ namespace {
   RegisterAnalysisGroup<AliasAnalysis, BasicAliasAnalysis, true> Y;
 }  // End of anonymous namespace
 
-void BasicAliasAnalysis::initializePass() {
-  InitializeAliasAnalysis(this);
-}
-
 // hasUniqueAddress - Return true if the specified value points to something
 // with a unique, discernable, address.
 static inline bool hasUniqueAddress(const Value *V) {
@@ -611,7 +649,7 @@ namespace {
 // that set errno on a domain or other error.
 static const char *DoesntAccessMemoryTable[] = {
   // LLVM intrinsics:
-  "llvm.frameaddress", "llvm.returnaddress", "llvm.readport",
+  "llvm.frameaddress", "llvm.returnaddress", "llvm.readport", "llvm.isnan",
 
   "abs", "labs", "llabs", "imaxabs", "fabs", "fabsf", "fabsl",
   "trunc", "truncf", "truncl", "ldexp",