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
57 --------------------------
69 .. code-block:: c++
77 C[1] = A[9-i]; /* One byte store */
80 In this case, the ``basic-aa`` pass will disambiguate the stores to ``C[0]`` and
82 the accesses are each one byte. In this case, the Loop Invariant Code Motion
86 .. code-block:: c++
94 C[1] = A[9-i]; /* One byte store */
97 In this case, the two stores to C do alias each other, because the access to the
99 the query, even the first case would have to conservatively assume that the
105 --------------------
123 non-overlapping memory ranges. Another is when the two pointers are only ever
125 between accesses through one pointer and accesses through the other --- in this
126 case, there is a dependence, but it's mediated by the free and reallocation.
143 -----------------------------
159 --------------------------------------
169 globally-constant memory (for which it returns ``NoModRef``) or
170 locally-invariant memory (for which it returns ``Ref``). Globally-constant
172 Locally-invariant memory is memory that we know is invariant for the lifetime
174 the memory pointed to by ``readonly`` ``noalias`` parameters is known-invariant
192 side-effect free and only depend on their input arguments, allowing them to be
198 that (at most) the function only reads from non-volatile memory. Functions with
199 this property are side-effect free, only depending on their input arguments and
208 Writing a new alias analysis implementation for LLVM is quite straight-forward.
214 ---------------------
217 you need to use for your Alias Analysis. As is the case with most other
222 #. If you are a function-local analysis, subclass ``FunctionPass``.
230 -----------------------------
239 .. code-block:: c++
251 .. code-block:: c++
260 ----------------------------
265 .. code-block:: c++
274 ---------------------------------
278 default to providing :ref:`chaining <aliasanalysis-chaining>` to another alias
284 .. _aliasanalysis-chaining:
287 -----------------------------------
290 example, the user can specify "``-basic-aa -ds-aa -licm``" to get the maximum
296 .. code-block:: c++
304 // Couldn't determine a must or no-alias result.
315 ---------------------------------------------
325 their internal data structures are kept up-to-date as the program changes (for
372 -----------------
382 -----------
388 to be able to do something like "``opt -my-aa -O2``" and have it use ``-my-aa``
401 Similarly, the ``opt -p`` option introduces ``ModulePass`` passes between each
416 non-deterministic number of alias queries. This can cause debugging techniques
433 -------------------------------------------
435 The ``memdep`` pass uses alias analysis to provide high-level dependence
436 information about memory-using instructions. This will tell you which store
443 -----------------------------------
470 pointer argument is loop-invariant.
476 uses the union-find algorithm to efficiently merge AliasSets when a pointer is
483 these hash-table nodes to avoid having to allocate memory unnecessarily, and to
492 ----------------------------------------------
496 higher-level methods when possible (e.g., use mod/ref information instead of the
511 -------------------------------------------
514 interface. All of these :ref:`chain <aliasanalysis-chaining>` to other
517 The ``-basic-aa`` pass
520 The ``-basic-aa`` pass is an aggressive local analysis that *knows* many
531 escape from the function that allocates them (a common case for automatic
534 The ``-globalsmodref-aa`` pass
537 This pass implements a simple context-sensitive mod/ref and alias analysis for
544 The real power of this pass is that it provides context-sensitive mod/ref
551 This pass is somewhat limited in its scope (only support non-address taken
554 The ``-steens-aa`` pass
557 The ``-steens-aa`` pass implements a variation on the well-known "Steensgaard's
559 unification-based, flow-insensitive, context-insensitive, and field-insensitive
562 The LLVM ``-steens-aa`` pass implements a "speculatively field-**sensitive**"
569 ``-steens-aa`` is available in the optional "poolalloc" module. It is not part
572 The ``-ds-aa`` pass
575 The ``-ds-aa`` pass implements the full Data Structure Analysis algorithm. Data
576 Structure Analysis is a modular unification-based, flow-insensitive,
577 context-**sensitive**, and speculatively field-**sensitive** alias
581 queries, and can provide context-sensitive mod/ref information as well. The
582 only major facility not implemented so far is support for must-alias
587 ``-ds-aa`` is available in the optional "poolalloc" module. It is not part of
590 The ``-scev-aa`` pass
593 The ``-scev-aa`` pass implements AliasAnalysis queries by translating them into
599 -------------------------------------
601 LLVM includes several alias-analysis driven transformations which can be used
604 The ``-adce`` pass
607 The ``-adce`` pass, which implements Aggressive Dead Code Elimination uses the
609 side-effects and are not used.
611 The ``-licm`` pass
614 The ``-licm`` pass implements various Loop Invariant Code Motion related
622 write to memory and are loop-invariant.
628 The ``-argpromotion`` pass
631 The ``-argpromotion`` pass promotes by-reference arguments to be passed in
632 by-value instead. In particular, if pointer arguments are only loaded from it
638 The ``-gvn``, ``-memcpyopt``, and ``-dse`` passes
646 -------------------------------------------------------
651 .. code-block:: bash
653 % opt -ds-aa -aa-eval foo.bc -disable-output -stats
655 The ``-print-alias-sets`` pass
658 The ``-print-alias-sets`` pass is exposed as part of the ``opt`` tool to print
662 .. code-block:: bash
664 % opt -ds-aa -print-alias-sets -disable-output
666 The ``-aa-eval`` pass
669 The ``-aa-eval`` pass simply iterates through all pairs of pointers in a
688 intra- or inter-block level. Because of its laziness and caching policy, using