Directly reading tp->align breaks (at least) for array types.

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

As they were just a single flag the name should reflect that. I did not
change arch_irn_flags_none, as that is not about a single flag.

- fix: not just aggregate parameters need special handling but also
  aggregate return types.
- don't just look at the called function but also on the call type.

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

few typo fix

This allows users - such as Special Instruction creation for
reconfigurable microarchitectures - to override the backend's
predicate.

This removes all predecessors from Syncs which are reachable through a path
beginning at another predecessor.

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.

Instead of the maximum of the two type sizes, use the size of the type of
numerically smaller pointer to check whether two pointers with offsets
alias.

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.

The parallelization functions now keep track of all visited nodes, and do
not visit any node twice anymore. Hopefully, this finally makes
parallelize_mem polynomial in time.

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)