GitLab

We combine all non-arithmetic modes into irms_auxiliary (two auxiliary
nodes are considered equal iff they have the same name).

Most uses in the backend should be mode_is_data() the few remaining uses
can compare with mode_b explicitely.

We couldn't generate sensible code for them anyway.

The new design simply lets you specify hex or not in tarval_snprintf.
This is way simpler than the previous machinery and enough for all users in
libfirm.

- Only allow get_entity_irg()/set_entity_irg() for method entities now.
- Allow setting/getting of additional properties for method and alias
  entities.
- Add some missing is_method_entity() checks in cgana.

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()

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.

This also fixes the return value of snprintf variants in case of full
buffer: The number of bytes that would have been written with an
infinite buffer is returned.

Types need not be in their final form after the new_entity so there is no
need to have _d variants like we have with all the graph nodes. You can easily
use set_entity_dbg_info() after construction.

It is not usefull for optimization in most languages:
- In C/C++ you can't really change the value of enum constants as casting
  from/to integer has to produce the expected results.
- In Java (and other OO languages) enum members are objects so the
  libfirm enumeration type can't be used there anyway

This is a type which is aggregated from multiple primtive/simple
elements. In libfirm such a type cannot be represented as a mode.

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

If a Store uses the value and memory output of a Load just before it, and
shares the same pointer with the Load, the Store is killed.

The new code has less options and variants, if you call irg_verify()
verification is performed, regardless of DEBUG_libfirm, or NDEBUG being
set and regardless of firm verification setting switches. On the other
side no atomic dump and abort is performed anymore, the call has to do
this, though an irg_assert_verify() function has been added as a
convenience measure.
There has also been a complete rewrite of the actual checking performed.
The new code is simpler, should produce more consistent output and
can report more than one error.

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.

This is necessary because the walker does not guarantee that all Projs
of the second Tuple are visited after we optimized the first Tuple.