GitLab

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.

Entities need not be in their final form after the new_entity call, 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

also move copy_const_value from typerep/entity to irgmod.

We do not model them as a type anymore, but simply annotate
compound_member entities with a bit offset and bit size.

- Semantic was strange: shallow checking for pointers, deep checking for
  structs (because no real solution in case of cycles was implemented)
- Implementation was incomplete/buggy
- Nobody was using it anyway

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

Accordingly remove repr_class from entities.

This is used to implement C99 "inline"/GNU89 "extern inline" ie. an
entity which is externally defined but where we know an inlineable
definition anyway.

This commit removes the strange differentiation between
ir_visibility_external and ir_visibility_default. We now only have
ir_visibility_external for all symbols visible across compilation units.
You may or may not attach graphs/initializers to them.

This adds support for C99/gcc style compound types where the last
element is an array of unspecified size. The compound size is the
minimum size (assuming the array has no elements), or is calculated
by the size of an initializer.

Types "own" entities, so they should also free them when they get freed.

unknown_type, code_type, none_type, unknown_entity reference are hold in
the irprog now. This makes handling more consistent since now all types
and entities are equally part of irprog.

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

Make sure all types are in the global type list, remove type_walk_prog
which was a strange alternative to type_walk attempting to not miss
types not in the global list.

Use a special kind of entity on the frame type instead of a value_type
struct inside a method type. This makes replacement of function types
slightly easier (it's still a complex operation though) and handling in
the backend a bit more consistent since it's more or less a normal stack
access (with special offsets).

* get_associated_type is unnecessary
* is_lowered_type is an internal inline function now
* set_lowered_type is an internal inline function now