[doc] Removed obsolete -count-aa from AliasAnalysis documentation

[mamai]

Summary

This patch removes references to AliasAnalysisCounter pass from the AliasAnalysis documentation. That pass have been eliminated in 2015, at revision trunk@247167.

[hfinkel]

LGTM

llvm/trunk/docs/AliasAnalysis.rst

 There is no way for transform passes to declare that they preserve
 ``AliasAnalysis`` implementations. The ``AliasAnalysis`` interface includes
 ``deleteValue`` and ``copyValue`` methods which are intended to allow a pass to
 keep an AliasAnalysis consistent, however there's no way for a pass to declare
 in its ``getAnalysisUsage`` that it does so. Some passes attempt to use
 ``AU.addPreserved<AliasAnalysis>``, however this doesn't actually have any
 effect.
 
-``AliasAnalysisCounter`` (``-count-aa``) are implemented as ``ModulePass``
-classes, so if your alias analysis uses ``FunctionPass``, it won't be able to
-use these utilities. If you try to use them, the pass manager will silently
-route alias analysis queries directly to ``BasicAliasAnalysis`` instead.
-
 Similarly, the ``opt -p`` option introduces ``ModulePass`` passes between each
 pass, which prevents the use of ``FunctionPass`` alias analysis passes.
 
 The ``AliasAnalysis`` API does have functions for notifying implementations when
 values are deleted or copied, however these aren't sufficient. There are many
 other ways that LLVM IR can be modified which could be relevant to
 ``AliasAnalysis`` implementations which can not be expressed.
 
 The ``AliasAnalysisDebugger`` utility seems to suggest that ``AliasAnalysis``
 implementations can expect that they will be informed of any relevant ``Value``
 before it appears in an alias query. However, popular clients such as ``GVN``
 don't support this, and are known to trigger errors when run with the
 ``AliasAnalysisDebugger``.
 
-Due to several of the above limitations, the most obvious use for the
-``AliasAnalysisCounter`` utility, collecting stats on all alias queries in a
-compilation, doesn't work, even if the ``AliasAnalysis`` implementations don't
-use ``FunctionPass``.  There's no way to set a default, much less a default
-sequence, and there's no way to preserve it.
-
 The ``AliasSetTracker`` class (which is used by ``LICM``) makes a
-non-deterministic number of alias queries. This can cause stats collected by
-``AliasAnalysisCounter`` to have fluctuations among identical runs, for
-example. Another consequence is that debugging techniques involving pausing
-execution after a predetermined number of queries can be unreliable.
+non-deterministic number of alias queries. This can cause debugging techniques
+involving pausing execution after a predetermined number of queries to be
+unreliable.
 
 Many alias queries can be reformulated in terms of other alias queries. When
 multiple ``AliasAnalysis`` queries are chained together, it would make sense to
 start those queries from the beginning of the chain, with care taken to avoid
 infinite looping, however currently an implementation which wants to do this can
 only start such queries from itself.
 
 Using alias analysis results

 The ``-print-alias-sets`` pass is exposed as part of the ``opt`` tool to print
 out the Alias Sets formed by the `AliasSetTracker`_ class.  This is useful if
 you're using the ``AliasSetTracker`` class.  To use it, use something like:
 
 .. code-block:: bash
 
   % opt -ds-aa -print-alias-sets -disable-output
 
-The ``-count-aa`` pass
-^^^^^^^^^^^^^^^^^^^^^^
-
-The ``-count-aa`` pass is useful to see how many queries a particular pass is
-making and what responses are returned by the alias analysis.  As an example:
-
-.. code-block:: bash
-
-  % opt -basicaa -count-aa -ds-aa -count-aa -licm
-
-will print out how many queries (and what responses are returned) by the
-``-licm`` pass (of the ``-ds-aa`` pass) and how many queries are made of the
-``-basicaa`` pass by the ``-ds-aa`` pass.  This can be useful when debugging a
-transformation or an alias analysis implementation.
-
 The ``-aa-eval`` pass
 ^^^^^^^^^^^^^^^^^^^^^
 
 The ``-aa-eval`` pass simply iterates through all pairs of pointers in a
 function and asks an alias analysis whether or not the pointers alias.  This
 gives an indication of the precision of the alias analysis.  Statistics are
 printed indicating the percent of no/may/must aliases found (a more precise
 algorithm will have a lower number of may aliases).