C/LLVM backends: Improve comments at the top
Remove unused rtlMemCopy()
LLVM backend: Implement complex math ops (sin/cos/sgn/fix/abs/etc.)

This changes how complex math operations are handled for the C and LLVM
backends and implements support for them in the LLVM backend.

We have various UOPs (abs/sgn/sin/asin/cos/acos/tan/atan/sqrt/rsqrt/rcp/
log/exp/int(floor)/fix/frac) and one BOP (atan2) that the ASM backend
implements directly as "in-line" operations, i.e. it emits corresponding
x86 instructions for them. The C and LLVM backends however cannot do this
as easily because C and LLVM IR do not have all these operations, at least
not as UOPs/BOPs.

For the C backend, we can use various GCC __builtin_*() functions, e.g.
__builtin_sin(). For the LLVM backend, there also are various @llvm.*.*()
built-ins, e.g. @llvm.sin.f64(). All missing operations need to be
implemented via calls to CRT/libm functions.

Before this patch, when using the C backend, astNewUOP() channeled all
these built-in operations through rtlMathUop() which generated calls to
either real libfb/libm functions or calls to fake functions marked with
the GCCBUILTIN flag. Those were given special treatment by the C backend,
and turned into calls to the __builtin_*() functions.

This patch changes this interaction between AST and IR backends. Now,
astNewUOP() and other places in the AST ask the backend directly whether
a certain op is supported "in-line", or whether a RTL call should be used
instead. The ASM backend supports everything in-line currently. The C and
LLVM backends however implement only some operations directly, and let the
AST know that it has to use rtlMathUop/Bop() for the rest. All in-line
operations are emitted purely from inside the backends, while
rtlMathUop/Bop() are used only for real RTL calls.

This way it's easier to implement the complex inline operations for the
LLVM backend, because LLVM IR's built-in function names have different
suffix depending on the parameter/result types which couldn't be
represented in the rtl declaration tables, and some require data types
like i1 (1 bit integer) that FB can't represent. And on top of that,
in the future it may be better to even implement all operations in-line,
for allow C/LLVM to do better optimizations. (Although GCC/LLVM probably
even detect calls to libm functions and optimize them already)
tests: Add extensive tests for UOP/BOP constant evaluation

(currently some of the new tests fail due to bugs fixed in following
commits)
hConstUop()/hConstBop(): Reformat to make it easier to read
Fix abs() constant evaluation (ea511505 regression)

abs(&hFFFFFFFFu) was evaluated by abs(longint) instead of abs(long),
thus it returned &hFFFFFFFFu instead of 1 (= abs(-1)).

Test cases already added in 937d0355.
ASM backend: Fix Sgn(LongInt)

The old implementation was wrong; it did a 2nd cmp while still needing
the result from the 1st cmp. To fix this, the 2nd value must be stored
in a temp reg so the original can be overwritten, but still allowing
its value to be checked later.
astNewBOP(): Truncate shift amount to 0..bitsize-1

to ensure constant evaluation uses the same shift amount like the
real x86 shift would. (and besides that, this also helps avoiding
undefined behaviour in the C backend)

This fixes a regression from ea511505 since which constant evaluation
is done based on LongInts. This changed the result values produced
by 32bit shr/shl constant evaluation when shifting >= bitsize:
"int64 shl 32" suddenly worked, i.e. returned 0, instead of the
original value as would be done by "int32 shl 32" on x86 (x86 masks
with 31, so 32 ends up being 0, and shift by 0 = original value).
astConstGetAsInt64(): Remove unnecessary signed/unsigned distinction

In "longint = cunsg(longint)" the cunsg() is pointless, because the
size doesn't change and thus there's neither zero nor sign extension.
tests: Fix some SSE test cases that were enabled in 6d17deca