GitLab

- Compound type selection is performed with Member
- Array indexing is performed with Sel
- Instead of the simpleSel constructor functions you can use the normal Member
  constructors now
- The concept of array element entities has been removed, Sel nodes just
  contain a pointer to the array type now.

By default a node needs the graph explicitly given iff it has a known block.

Just inspecting the attribute block is sufficient.

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.

= is_entconst(), is_typeconst, get_entconst_entity() and
get_typeconst_type()

Deduce the mode automatically from the given entity.

This removes the strange entity/type duality and we get rid of union symconst_symbol.

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 requires to actually compute volatility in a number of places.
Therefore, this also adds some helper functions to do that.

This reverts commit 3d1d2c43.

Creating a Bad node does not imply that it has users or is reachable
within an irg. While clearing the property is certainly correct as a
conservative approximation, it should not be necessary.

This node was used by OO code in the past, but newer versions of liboo
have their own node and don't need it anymore.

CopyB is normally used to transfer data on the stack or to enable compound
value calling conventions. Exceptions don't happen in these cases.

I don't really understand what it was supposed to do (because nodes
using/producing should be pretty much immovable anyway because of their
dependencies, so an additional pinning type appears unnecessary).
In practice there was no code differentiating between mem_pinned and exc_pinned.

The backends which support rotl now match for or(shl,shr) patterns.

They are considered low level operations now which just allocate/free a
block of memory on the stack. There is no highlevel typeinformation
attached anymore or support for heap allocation. Frontends/liboo should
provide their custom highlevel nodes if they need these features.

They weren't used in a sensible way and their semantic for
non-arithmetic ops was unclear.
Also implicitely fixes a bunch of bugs where these where set but no op_index
was set at the same time.

oparity_unary, oparity_binary require opindex to be set, which wasn't
always the case.
Also people seem to expect certain semantics from unops/binops, like
being arithmetic operations. So we shouldn't automatically set
oparity_XXX.

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

It is the job of the frontend to keep loops.
These hacks here only worked for some, but not all cases.
In particular a more clever SSA-construction algorithm might not place redundant PhiMs, which would render memory before memory-less loops unkept.