GitLab

This commit does:
- Remove tarval_reachable+tarval_unreachable, dataflow analysis rather
  use top/bottom instead of other special values.
- Rename tarval_undefined to tarval_unknown as it corresponds to the
  Unknown node (=a value which we don't know)
- Remove predefined tarval_top/tarval_bottom from tv.h and place the
  defines into combo.c
- Change compute_XXX constant folding functions to return tarval_unknown
  instead of tarval_bad if folding failed
- compute_Unknown in combo results in tarval_bottom == tarval_unknown
  this eliminates strange special cases in the Cond/Switch rules and the
  now unnecessary cprop_X list.

This fixes a bug where the code path handling immediate evaluation was
not able to evaluate some Cmp(Confirm, Const) combinations, but the
normal code could do it.

All users of NEW_ARR_A used it to construct a simple array, yet noone
cared about it actually being an array with a length field in front. For
this simple use case you should use ALLOCAN.

Nobody uses it currently, and it is a burden for everyone writing a new
pass.

It has been empty for nearly all systems. People who used to put stuff
in config.h can still create a config.h on their own and inject
-include (gcc) or /FI (msvc) into their CPPFLAGS.

Just state the copyright and the project the files belong to. You can
then find the COPYING file for the whole project.

cleanup: Remove pointless assert(is_${NODE}(x)) just before get_${NODE}_${FOO}(x), which do the same assert.

The opt_manage framework didn't really do much except assuring that some
analysis info is computed before a pass starts. We can achieve this
simpler by providing an assure_irg_properties function.
This commit also fixes some places where analysis info was potentially
not invalidated before.

graph_properties are things that a transformation may destroy but which
can be easily recalculated.

graph_constraints are set after lowering phases have been running and
forbid certain constructs that no (later) transformation is allowed to construct

This is the new way of handling switch-jumps. The node contains a table
which maps (ranges of) input values to proj numbers. Compared to a
Cond-node this results in a clean consecutive sequence of Proj numbers
(no searching for a free number for the default_pn anymore) and allows
factoring multiple cases jumping to the same block in a single Proj
(though we still need the optimisation in cfopt for that).

some were missing anyway and nobody is using the global declarations anyway

Converted: ifconv, boolopt, combo, fpvrp, ldst, code placement,
jumpthreading, deconv, parallelize mem, loop, scalar replacement,
cfopt.

This reverts commit 2dc83299.

The commit made jumpthreading "more conservative", which fixed the
problem. However, it is not a good solution in general.

We need a bigger rewrite of opt/jumpthreading, so it analyzes then
modifies the graph instead of on-the-fly changes. This prevents the
infinite loop, which would e.g. happen with such a cf graph:

    \     A         \     A
   __\    |        __\    |
   |  B   |   =>   |  B   |  => ...
   | / \  |        | / \  |
   |    D |        |    E |
   |     \|        |     \|
    \     C         \     D
     \___/           \   /
                      \_C

Breaks opt/jumpthreading5 and opt/jumpthreading5b

* the splitted edge is never critical, so the name was misleading
* it might result in an infinite loop
  fixes opt/jumpthreading5 and opt/jumpthreading5b

jump threading must also copy Keep edges to keep End reachable.

See http://www.libfirm.org/Unreachable_Code for details

This fixes opt/jumpthreading3.c.

[r28198]

[r28127]