This fixes opt/loadstore5.c.

- document this correctly
- correctly test with tarval_is_constant() if you expect a constant
  value.

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 removes the strange entity/type duality and we get rid of union symconst_symbol.

This fixes opt/loadstore4.c.

We cannot delete the Store if its address aliases with the source of the
CopyB.

This fixes opt/loadstore3.c.

Most firm analyses behaved incorrectlye when: A called SymConst did not
have a method entity, assumed the code reachable by get_entity_irg is
the code called. These assumptions are wrong when doing crazy casts in C
or when dealing with weak symbols. This is fixed by introducing some
convenience functions: get_Call_callee(), get_entity_linktime_irg()

We first have to create the new replacement store after the phi, so the
following removal of the old nodes does not assume the ptr input value is
unused and kills 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.

Andreas Fried authored Aug 02, 2013 and yb9976 committed Sep 04, 2013

This covers two cases (assuming no aliasing operations in between the nodes):

Firstly, a Store node whose destination lies completely within the CopyB's
destination can be deleted.

Secondly, if a previous CopyB (A) writes to the source of CopyB to be optimized
(B), we can use A's source pointer for further optimizations. If A's source is
constant, we can change B to read from A's source.  Cases with offsets are not
handled.

Andreas Fried authored Aug 02, 2013 and yb9976 committed Sep 04, 2013

When following the Memory chain for a Store, a CopyB node may be skipped, if
both its destination and source do not alias with the Store's destination.

Like a Store, a non-volatile CopyB whose destination is never read can be
removed.

If a Load reads from a location written to by a previous CopyB, we can use the
equivalent memory location in the CopyB's source buffer for further
optimizations (e.g. Load-after-Store).

In addition, if said CopyB source buffer is constant (e.g. an initializer),
we may directly replace the Load's pointer value with the equivalent memory
location in the initializer.

Code using get_alias_relation is converted by calling get_type_for_mode at
the appropriate locations.

This is in preparation for optimizations involving CopyB, which needs this
additional flexibility.

This requires to actually compute volatility in a number of places.
Therefore, this also adds some helper functions to do that.

also removed some assert(0) used in verifiers to stop when compiling
with assertions (you better use your debugger to stop and keep the code
clean)

- Previously it was part of load-store optimisations, the rewrite now
works as a localopt.
- The new version works for address arithmetic and not for Sels anymore
  (while the old code only worked for Sels)
- The new version can handle some forms of initializer spanning loads
  like loading a string like "bla" with an mode_Iu to get all 3 chars
  and the zero in one load.

also move copy_const_value from typerep/entity to irgmod.

We do not model them as a type anymore, but simply annotate
compound_member entities with a bit offset and bit size.

After killing a store (e.g. if it is dead), its Store value can be killed,
if no other node uses it. We can use the code in reduce_adr_usage for that,
which also works for non-pointers.

This commit adds a new function kill_and_reduce_usage, which works for Load
and Store nodes. It kills the node and all Loads on which only the killed
node depends.

optimize_load can introduce dead stores, which are not removed, because
they have already been visited (the irg is walked from Start to End).

This commit adds a second irg walk for dead store elimination after the
other optimizations have run, and removes dead store elimination from the
first walk.

Previously, if the load and store mode were equal, the optimization
aborted immediately. This is not necessary, we must only abort if the load
and store modes' arithmetic are not equal.

This causes a bug in type-based alias analysis to appear: When a CopyB is
lowered to Loads and Stores, the modes of these are always Iu instead of
the actual modes of the struct's members. The test-case "opt/fehler199.c"
will fail as a result.

Therefore, type-based alias analysis is switched off in cparser.

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.

This is the conservative and fast solution. We would get better results
if we would follow all Sync predecessors and ensure there is a store on
all of them (or after a join point).

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.