GitLab

Previously a Bad node was returned which could hide problems and more
importantly you create new nodes (the BadBB) in an operation that apparently
only queries the graph.

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

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

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

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

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.

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

irgmod: Pass the new inputs to turn_into_tuple() instead of initialising them with Bad and setting them afterwards.

Projs are always in the same block as their predecessor.

This means floatingpoint calculation in a firm graph must be performed
in the mode specified (and may not be performed in a wider mode as
before).

You can still attach NoMem if no memory input is present.
This makes it more consistent with the Call node and fixes failing
get_ASM_mem in case of no memory input.

This makes it consistent with other functions like get_irn_arity().
(Though I must admit that we should change all these functions from
 "int" to unsigned at some point)

- Setting dep edges to NULL is illegal now
- add_irn_dep is simpler but does not check for duplicates anymore

First it is unclear what is a good way to deconstruct a program into extended
basic blocks, also none of our optimizations works on extended basic
blocks.

Now every bit in the public API is documented so we can enable doxygen
warnings for undocumented members.

- Put things into logical groups
- Add cross references from node overview to API docu

memops are nodes that have memory inputs, you can generically query them
for their memory input. We can also get rid of get_fragile_op_mem in
favor of get_memop_mem.

This is the new way of handling switch-jumps. The node contains a table
which maps (ranges of) input values to proj numbers. Compared to a
Cond-node this results in a clean consecutive sequence of Proj numbers
(no searching for a free number for the default_pn anymore) and allows
factoring multiple cases jumping to the same block in a single Proj
(though we still need the optimisation in cfopt for that).