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``) are implemented as ``ModulePass``
397 Similarly, the ``opt -p`` option introduces ``ModulePass`` passes between each
418 non-deterministic number of alias queries. This can cause stats collected by
436 -------------------------------------------
438 The ``memdep`` pass uses alias analysis to provide high-level dependence
439 information about memory-using instructions. This will tell you which store
446 -----------------------------------
473 pointer argument is loop-invariant.
479 uses the union-find algorithm to efficiently merge AliasSets when a pointer is
486 these hash-table nodes to avoid having to allocate memory unnecessarily, and to
495 ----------------------------------------------
499 higher-level methods when possible (e.g., use mod/ref information instead of the
514 -------------------------------------------
517 interface. With the exception of the :ref:`-no-aa <aliasanalysis-no-aa>`
518 implementation, all of these :ref:`chain <aliasanalysis-chaining>` to other
521 .. _aliasanalysis-no-aa:
523 The ``-no-aa`` pass
526 The ``-no-aa`` pass is just like what it sounds: an alias analysis that never
530 The ``-basicaa`` pass
533 The ``-basicaa`` pass is an aggressive local analysis that *knows* many
544 escape from the function that allocates them (a common case for automatic
547 The ``-globalsmodref-aa`` pass
550 This pass implements a simple context-sensitive mod/ref and alias analysis for
557 The real power of this pass is that it provides context-sensitive mod/ref
564 This pass is somewhat limited in its scope (only support non-address taken
567 The ``-steens-aa`` pass
570 The ``-steens-aa`` pass implements a variation on the well-known "Steensgaard's
572 unification-based, flow-insensitive, context-insensitive, and field-insensitive
575 The LLVM ``-steens-aa`` pass implements a "speculatively field-**sensitive**"
582 ``-steens-aa`` is available in the optional "poolalloc" module. It is not part
585 The ``-ds-aa`` pass
588 The ``-ds-aa`` pass implements the full Data Structure Analysis algorithm. Data
589 Structure Analysis is a modular unification-based, flow-insensitive,
590 context-**sensitive**, and speculatively field-**sensitive** alias
594 queries, and can provide context-sensitive mod/ref information as well. The
595 only major facility not implemented so far is support for must-alias
600 ``-ds-aa`` is available in the optional "poolalloc" module. It is not part of
603 The ``-scev-aa`` pass
606 The ``-scev-aa`` pass implements AliasAnalysis queries by translating them into
612 -------------------------------------
614 LLVM includes several alias-analysis driven transformations which can be used
617 The ``-adce`` pass
620 The ``-adce`` pass, which implements Aggressive Dead Code Elimination uses the
622 side-effects and are not used.
624 The ``-licm`` pass
627 The ``-licm`` pass implements various Loop Invariant Code Motion related
635 write to memory and are loop-invariant.
641 The ``-argpromotion`` pass
644 The ``-argpromotion`` pass promotes by-reference arguments to be passed in
645 by-value instead. In particular, if pointer arguments are only loaded from it
651 The ``-gvn``, ``-memcpyopt``, and ``-dse`` passes
659 -------------------------------------------------------
664 .. code-block:: bash
666 % opt -ds-aa -aa-eval foo.bc -disable-output -stats
668 The ``-print-alias-sets`` pass
671 The ``-print-alias-sets`` pass is exposed as part of the ``opt`` tool to print
675 .. code-block:: bash
677 % opt -ds-aa -print-alias-sets -disable-output
679 The ``-count-aa`` pass
682 The ``-count-aa`` pass is useful to see how many queries a particular pass is
685 .. code-block:: bash
687 % opt -basicaa -count-aa -ds-aa -count-aa -licm
690 ``-licm`` pass (of the ``-ds-aa`` pass) and how many queries are made of the
691 ``-basicaa`` pass by the ``-ds-aa`` pass. This can be useful when debugging a
694 The ``-aa-eval`` pass
697 The ``-aa-eval`` pass simply iterates through all pairs of pointers in a
710 intra- or inter-block level. Because of its laziness and caching policy, using