[llvm-commits] CVS: llvm/include/llvm/Analysis/AliasAnalysis.h

[Chris Lattner]

Changes in directory llvm/include/llvm/Analysis:

AliasAnalysis.h updated: 1.16 -> 1.17

---
Log message:

Several *major* changes to the AA interfaces:

1. Provide interfaces so that clients can update alias analyses to reflect 
   the changes made by the transformations.
2. Change how alias analysis implementations work overall.  In particular, 
   now clients will automatically forward to chained AA implementations: they 
   don't have to remember to do it themselves.


---
Diffs of the changes:  (+43 -11)

Index: llvm/include/llvm/Analysis/AliasAnalysis.h
diff -u llvm/include/llvm/Analysis/AliasAnalysis.h:1.16 llvm/include/llvm/Analysis/AliasAnalysis.h:1.17
--- llvm/include/llvm/Analysis/AliasAnalysis.h:1.16	Sun Apr 11 11:42:50 2004
+++ llvm/include/llvm/Analysis/AliasAnalysis.h	Sun May 23 16:12:38 2004
@@ -40,8 +40,10 @@
 class TargetData;
 
 class AliasAnalysis {
-  const TargetData *TD;
 protected:
+  const TargetData *TD;
+  AliasAnalysis *AA;       // Previous Alias Analysis to chain to.
+
   /// InitializeAliasAnalysis - Subclasses must call this method to initialize
   /// the AliasAnalysis interface before any other methods are called.  This is
   /// typically called by the run* methods of these subclasses.  This may be
@@ -55,7 +57,7 @@
   virtual void getAnalysisUsage(AnalysisUsage &AU) const;
 
 public:
-  AliasAnalysis() : TD(0) {}
+  AliasAnalysis() : TD(0), AA(0) {}
   virtual ~AliasAnalysis();  // We want to be subclassed
 
   /// getTargetData - Every alias analysis implementation depends on the size of
@@ -82,9 +84,7 @@
   /// analysis implementations.
   ///
   virtual AliasResult alias(const Value *V1, unsigned V1Size,
-                            const Value *V2, unsigned V2Size) {
-    return MayAlias;
-  }
+                            const Value *V2, unsigned V2Size);
 
   /// getMustAliases - If there are any pointers known that must alias this
   /// pointer, return them now.  This allows alias-set based alias analyses to
@@ -92,13 +92,13 @@
   /// alias analysis supports this, it should ADD any must aliased pointers to
   /// the specified vector.
   ///
-  virtual void getMustAliases(Value *P, std::vector<Value*> &RetVals) {}
+  virtual void getMustAliases(Value *P, std::vector<Value*> &RetVals);
 
   /// pointsToConstantMemory - If the specified pointer is known to point into
   /// constant global memory, return true.  This allows disambiguation of store
   /// instructions from constant pointers.
   ///
-  virtual bool pointsToConstantMemory(const Value *P) { return false; }
+  virtual bool pointsToConstantMemory(const Value *P);
 
   /// doesNotAccessMemory - If the specified function is known to never read or
   /// write memory, return true.  If the function only reads from known-constant
@@ -111,7 +111,7 @@
   ///
   /// This property corresponds to the GCC 'const' attribute.
   ///
-  virtual bool doesNotAccessMemory(Function *F) { return false; }
+  virtual bool doesNotAccessMemory(Function *F);
 
   /// onlyReadsMemory - If the specified function is known to only read from
   /// non-volatile memory (or not access memory at all), return true.  Functions
@@ -122,7 +122,7 @@
   ///
   /// This property corresponds to the GCC 'pure' attribute.
   ///
-  virtual bool onlyReadsMemory(Function *F) { return doesNotAccessMemory(F); }
+  virtual bool onlyReadsMemory(Function *F);
 
 
   //===--------------------------------------------------------------------===//
@@ -158,8 +158,7 @@
   /// Remember that if you override this and chain to another analysis, you must
   /// make sure that it doesn't have mod/ref info either.
   ///
-  virtual bool hasNoModRefInfoForCalls() const { return false; }
-
+  virtual bool hasNoModRefInfoForCalls() const;
 
   /// Convenience functions...
   ModRefResult getModRefInfo(LoadInst *L, Value *P, unsigned Size);
@@ -180,6 +179,10 @@
     }
   }
 
+  //===--------------------------------------------------------------------===//
+  /// Higher level methods for querying mod/ref information.
+  ///
+
   /// canBasicBlockModify - Return true if it is possible for execution of the
   /// specified basic block to modify the value pointed to by Ptr.
   ///
@@ -192,6 +195,35 @@
   ///
   bool canInstructionRangeModify(const Instruction &I1, const Instruction &I2,
                                  const Value *Ptr, unsigned Size);
+
+  //===--------------------------------------------------------------------===//
+  /// Methods that clients should call when they transform the program to allow
+  /// alias analyses to update their internal data structures.  Note that these
+  /// methods may be called on any instruction, regardless of whether or not
+  /// they have pointer-analysis implications.
+  ///
+
+  /// deleteValue - This method should be called whenever an LLVM Value is
+  /// deleted from the program, for example when an instruction is found to be
+  /// redundant and is eliminated.
+  ///
+  virtual void deleteValue(Value *V);
+
+  /// copyValue - This method should be used whenever a preexisting value in the
+  /// program is copied or cloned, introducing a new value.  Note that analysis
+  /// implementations should tolerate clients that use this method to introduce
+  /// the same value multiple times: if the analysis already knows about a
+  /// value, it should ignore the request.
+  ///
+  virtual void copyValue(Value *From, Value *To);
+
+  /// replaceWithNewValue - This method is the obvious combination of the two
+  /// above, and it provided as a helper to simplify client code.
+  ///
+  void replaceWithNewValue(Value *Old, Value *New) {
+    copyValue(Old, New);
+    deleteValue(Old);
+  }
 };
 
 // Because of the way .a files work, we must force the BasicAA implementation to