Lines Matching refs:code

66 This is inspired and adapted from code by: Naveen Neelakantam, Francesco
225 Another limitation is that it assumes all code will be executed.  A store
232 code.
234 This code may be run before :ref:`instcombine <passes-instcombine>`.  In many
389 ADCE aggressively tries to eliminate code.  This pass is similar to :ref:`DCE
407 of the address of the value.  This can cause recursive simplification of code
408 and lead to the elimination of allocas (especially in C++ template code like
435 resulting code.
454 ``-codegenprepare``: Optimize for code generation
457 This pass munges the code in the input function to better prepare it for
458 SelectionDAG-based code generation.  This works around limitations in its
474 Dead code elimination is similar to :ref:`dead instruction elimination
570   .. code-block:: c++
576   .. code-block:: c++
606 .. code-block:: llvm
613 .. code-block:: llvm
680 An example of when this can occur is code like this:
682 .. code-block:: c++
699 into the right code:
701 .. code-block:: c++
723 This pass performs loop invariant code motion, attempting to remove as much
724 code from the body of a loop as possible.  It does this by either hoisting code
725 into the preheader block, or by sinking code to the exit blocks if it is safe.
821 not pessimize generated code.
839 .. code-block:: c++
843       code(i, j)                 code(i, j)
844                                  code(i+1, j)
845                                  code(i+2, j)
846                                  code(i+3, j)
860 to have multiple loops.  For example, it turns the left into the right code:
862 .. code-block:: c++
871 This can increase the size of the code exponentially (doubling it every time a
872 loop is unswitched) so we only unswitch if the resultant code will be smaller
898 ``-lowerinvoke``: Lower invokes to calls, for unwindless code generators
901 This transformation is designed for use by code generators which do not yet
904 become dead code (which can be removed by running the ``-simplifycfg`` pass
1036 Performs dead code elimination and basic block merging.  Specifically:
1053 Performs code stripping.  This transformation can delete:
1059 Note that this transformation makes code much less readable, so it should only
1061 code size or making it harder to reverse engineer code.
1068 performs code stripping. this transformation can delete:
1074 note that this transformation makes code much less readable, so it should only
1076 code size or making it harder to reverse engineer code.
1091 This pass implements code stripping.  Specifically, it can delete:
1097 Note that this transformation makes code much less readable, so it should only
1099 code size or making it harder to reverse engineer code.
1106 This pass implements code stripping.  Specifically, it can delete:
1112 Note that this transformation makes code much less readable, so it should only
1114 code size or making it harder to reverse engineer code.
1129    the typical naive factorial or fib implementation into efficient code.
1137    are marked as eligible for tail call elimination (by the code generator).
1169 Verifies an LLVM IR code.  This is useful to run after an optimization which is
1180 #. The code is in valid SSA form.
1198 #. All other things that are tested by asserts spread about the code.
1201 instead just tries to ensure that code is well-formed.