Lines Matching +full:case +full:- +full:sensitive
14 different ways of classifying them: flow-sensitive vs. flow-insensitive,
15 context-sensitive vs. context-insensitive, field-sensitive
16 vs. field-insensitive, unification-based vs. subset-based, etc. Traditionally,
27 are assumed to be flow-insensitive). In addition to simple alias analysis
58 --------------------------
70 .. code-block:: c++
78 C[1] = A[9-i]; /* One byte store */
81 In this case, the ``basicaa`` pass will disambiguate the stores to ``C[0]`` and
83 the accesses are each one byte. In this case, the Loop Invariant Code Motion
87 .. code-block:: c++
95 C[1] = A[9-i]; /* One byte store */
98 In this case, the two stores to C do alias each other, because the access to the
100 the query, even the first case would have to conservatively assume that the
106 --------------------
124 non-overlapping memory ranges. Another is when the two pointers are only ever
126 between accesses through one pointer and accesses through the other --- in this
127 case, there is a dependence, but it's mediated by the free and reallocation.
143 -----------------------------
159 --------------------------------------
182 side-effect free and only depend on their input arguments, allowing them to be
188 that (at most) the function only reads from non-volatile memory. Functions with
189 this property are side-effect free, only depending on their input arguments and
198 Writing a new alias analysis implementation for LLVM is quite straight-forward.
204 ---------------------
207 you need to use for your Alias Analysis. As is the case with most other
212 #. If you are a function-local analysis, subclass ``FunctionPass``.
220 -----------------------------
229 .. code-block:: c++
241 .. code-block:: c++
250 ----------------------------
255 .. code-block:: c++
264 ---------------------------------
268 default to providing :ref:`chaining <aliasanalysis-chaining>` to another alias
274 .. _aliasanalysis-chaining:
277 -----------------------------------
279 With only one special exception (the :ref:`-no-aa <aliasanalysis-no-aa>` pass)
281 example, the user can specify "``-basicaa -ds-aa -licm``" to get the maximum
287 .. code-block:: c++
295 // Couldn't determine a must or no-alias result.
306 ---------------------------------------------
316 their internal data structures are kept up-to-date as the program changes (for
363 -----------------
373 -----------
379 to be able to do something like "``opt -my-aa -O2``" and have it use ``-my-aa``
392 ``AliasAnalysisCounter`` (``-count-aa``) and ``AliasDebugger`` (``-debug-aa``)
398 Similarly, the ``opt -p`` option introduces ``ModulePass`` passes between each
419 non-deterministic number of alias queries. This can cause stats collected by
437 -------------------------------------------
439 The ``memdep`` pass uses alias analysis to provide high-level dependence
440 information about memory-using instructions. This will tell you which store
447 -----------------------------------
474 pointer argument is loop-invariant.
480 uses the union-find algorithm to efficiently merge AliasSets when a pointer is
487 these hash-table nodes to avoid having to allocate memory unnecessarily, and to
496 ----------------------------------------------
500 higher-level methods when possible (e.g., use mod/ref information instead of the
515 -------------------------------------------
518 interface. With the exception of the :ref:`-no-aa <aliasanalysis-no-aa>`
519 implementation, all of these :ref:`chain <aliasanalysis-chaining>` to other
522 .. _aliasanalysis-no-aa:
524 The ``-no-aa`` pass
527 The ``-no-aa`` pass is just like what it sounds: an alias analysis that never
531 The ``-basicaa`` pass
534 The ``-basicaa`` pass is an aggressive local analysis that *knows* many
545 escape from the function that allocates them (a common case for automatic
548 The ``-globalsmodref-aa`` pass
551 This pass implements a simple context-sensitive mod/ref and alias analysis for
558 The real power of this pass is that it provides context-sensitive mod/ref
565 This pass is somewhat limited in its scope (only support non-address taken
568 The ``-steens-aa`` pass
571 The ``-steens-aa`` pass implements a variation on the well-known "Steensgaard's
573 unification-based, flow-insensitive, context-insensitive, and field-insensitive
576 The LLVM ``-steens-aa`` pass implements a "speculatively field-**sensitive**"
583 ``-steens-aa`` is available in the optional "poolalloc" module. It is not part
586 The ``-ds-aa`` pass
589 The ``-ds-aa`` pass implements the full Data Structure Analysis algorithm. Data
590 Structure Analysis is a modular unification-based, flow-insensitive,
591 context-**sensitive**, and speculatively field-**sensitive** alias
595 queries, and can provide context-sensitive mod/ref information as well. The
596 only major facility not implemented so far is support for must-alias
601 ``-ds-aa`` is available in the optional "poolalloc" module. It is not part of
604 The ``-scev-aa`` pass
607 The ``-scev-aa`` pass implements AliasAnalysis queries by translating them into
613 -------------------------------------
615 LLVM includes several alias-analysis driven transformations which can be used
618 The ``-adce`` pass
621 The ``-adce`` pass, which implements Aggressive Dead Code Elimination uses the
623 side-effects and are not used.
625 The ``-licm`` pass
628 The ``-licm`` pass implements various Loop Invariant Code Motion related
636 write to memory and are loop-invariant.
642 The ``-argpromotion`` pass
645 The ``-argpromotion`` pass promotes by-reference arguments to be passed in
646 by-value instead. In particular, if pointer arguments are only loaded from it
652 The ``-gvn``, ``-memcpyopt``, and ``-dse`` passes
660 -------------------------------------------------------
665 .. code-block:: bash
667 % opt -ds-aa -aa-eval foo.bc -disable-output -stats
669 The ``-print-alias-sets`` pass
672 The ``-print-alias-sets`` pass is exposed as part of the ``opt`` tool to print
676 .. code-block:: bash
678 % opt -ds-aa -print-alias-sets -disable-output
680 The ``-count-aa`` pass
683 The ``-count-aa`` pass is useful to see how many queries a particular pass is
686 .. code-block:: bash
688 % opt -basicaa -count-aa -ds-aa -count-aa -licm
691 ``-licm`` pass (of the ``-ds-aa`` pass) and how many queries are made of the
692 ``-basicaa`` pass by the ``-ds-aa`` pass. This can be useful when debugging a
695 The ``-aa-eval`` pass
698 The ``-aa-eval`` pass simply iterates through all pairs of pointers in a
711 intra- or inter-block level. Because of its laziness and caching policy, using