This also disables the memcombine optimisation if unaligned stores are
not supported by the backend.
We may add some tests in the future to reenable this in cases where we
can prove that the combined store is aligned.

Rework load memory chain walking:
- We keep the pointer as a base + offset representation all the time
- Reuse predict_load code from localopt for more accurate replacement of
  Loads from constant entities
- Support some more cases where load-after-load and load-after-store did
  not use the same mode but where we can easily get the value with some
  arithmetic.

This fixes opt/loadstore6.c.

Some analysis parts create new nodes destroying the CONSISTENT_OUT_EDGES
property even though no real change has been performed.

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.