GitLab

Also added a new matcher for the ia32 backend matching Shl(x,1) to
Lea(x,x).

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.

These SymConst nodes have an attached entity whose owner type is not a segment.

- This avoids missing cases when new arithmetic modes are introduced.
- This also fixes a wrong case in mode_overflow_on_unary_Minus()

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

Nobody uses it currently, and it is a burden for everyone writing a new
pass.

Most aspects of the fp_model flag would need to be enforced by
constructing the firm graph in a certain way. Setting it as a flag won't
help. Apart from that nearly nothing of the stuff was implemented
anyway.

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.

the templates are now friendlier for usage outside of libfirm

Templates are put in separate files now, making the main script more
generic in nature

It has been empty for nearly all systems. People who used to put stuff
in config.h can still create a config.h on their own and inject
-include (gcc) or /FI (msvc) into their CPPFLAGS.

(C1 - x) + C2 = (C1 + C2) - x
C1 - (x + C2) = (C1 - C2) - x
~(x + C) = (~C) - x (extended from ~(x + -1) = -x)
~(C - x) = x + (~C)
-(x + C) = (-C) - x

Ingmar Wirths authored Jan 21, 2013 and yb9976 committed Apr 04, 2013

This implements the "round down" algorithm by ridiculous_fish (see
Faster Unsigned Division by Constants,
http://ridiculousfish.com/blog/posts/labor-of-division-episode-iii.html),
which improves the generated code for some constants (like 42).

The builtin can be used to generate fast code for unsigned division by constant.

Code generation is supported for the IA32 and the SPARC backend.
Since our ARM backend currently has no Add with Carry instruction,
the builtin is currently not supported on Arm.
The same holds for the AMD64 backend, which does not support a division yet.

For newly created nodes without any user the function now correctly
returns false. Thus, these nodes are no longer ignored when performing
(global?) common subexpression elimination.

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.

Also simplified the code.