Alternative fix for const functions with aggregate return

They really are const before lowering. So only mark the function
as non-const after lowering

This reverts commit 72c631f337f78b20460c508bd8af37fe67a5af37.

sparc: initial support for Alloc/Free nodes

This commit also adds a generic Alloc/Free lowering helper
Unfortunately we often produce invalid code, because currently our
stackpointer wiring logic is too weak and produces invalid results for
example when using alloca in a loop.

rename Free argument from size to count to be consistent with Alloc

Fix cfopt bug due to infinite loops

Print the linkage of entities only once, not twice.

Print the value of const initializers instead of just <CONST>Const.

Add missing newlines when dumping entities.

Print "default" instead of nothing if an entity has default linkage.

We may return a parameter and thus need to copy them.

This fixes opt/fehler200.c.

Directly ask backend for current machine size in CopyB lowering.

Old version used parameter.

Adapt documentation to implementation

Cmp must not counted as an operation

Let collect_nodes cope with Bad nodes

Do not regard functions with compound return types as pure/const.

Improved CopyB lowering, made it part of target lowering.

Backends can configure CopyB lowering, so that it's possible to keep
CopyB nodes in a certain size range for special backend-specific
optimizations.  Furthermore, large CopyBs are turned into memcpy calls.

fix warning

Improve cfopt

The part, which does not handle Phis is now recomputing block info,
because converting Cond -> Jmp, might make this info obsolete.

Additionally, it can now remove empty Jmp blocks with more than one
control flow predecessor, provided the origin block has no Phis.

Now cfopt should now be idempotent
(at least the part not handling Phis).

fix the fix of the call ordering...

ia32: make sure the stackframe IncSp is always used

sparc: support va_start

a const parameter is enough for get_method_XXX()

add special constant to represent VA_START-address in a parameter_entity

beverify: test register width in regalloc verification

fix mode of call-result proj

Fixed call dependency comparison for backend call ordering.

Code was taken from cmp_call_dependency in beabi.c which handles the
situation correctly.

Bugfix: Added special case for x mod 1.

IR export: export mode name as string; mark "the" mode_P mode.

Clarify remove_bads doc

Correct comment.

Reduce code duplication.

Use new_*_Const(irg, get_mode_$VAL(mode)) instead of new_*_Const_long(irg, mode, $VAL).

sparc: Set object file format when initializing backend.

Old version breaks for files which do not contain any functions because
in this case, emit_routine never gets called.

Fix div by one

For k==0 the Div to Shift conversion is wrong.
Instead, we just convert to the left operand of the Div.

Refactoring to remove one level of indentation

A comment for better understanding

sparc: Added a comment.

sparc: Add support for Conds where selector is not a Cmp.

cleanup

The variable is overwritten right afterwards

Don't try to import cons_flags.

Fixed opt/fehler196.c.

Allow selecting one past the last parameter to get variadic parameters.

Remove unnecessary assignment, which at worst hides a panic.

Fix emission of string initializers.

Non-printable characters are emitted as octal sequences, e.g. \0 for 0.
Always pad them to three digits, so they do not accidently join with a following ASCII digit.
E.g. "\0""7" was emitted as "\07", correct is "\0007".

Fixed local optimization.

We have to convert the values the same way the program does.

replace unsupported builtins with library calls

sparc: fix mode of Ldf Projs

add callback for constructing spill/reload

So we are not forced to use the generic be_Spill, be_Reload functions
which don't work correctly with double-width register requirements.
This should really fix sparc float spill/reload this time.

simplify copy interface and respect double/aligned reqs

fix warnings reported by cparser

Correct reg_reqs_equal().

If req2 was limited and req1 wasn't, then it incorrectly returned true.

Correct typos in comments.

Correct indentation.

Added soft float support for SPARC backend.

Fix C/bitfield4

Load-Store-Opt now shifts constant loads from bitfields accordingly.

cleanup

fix missing else

API Change: Use graph state instead of parameter

The lowering phase had a lower_bitfield parameter.
Instead of passing "true", the (e.g. EDG) frontends now must
set_irg_state(irg, IR_GRAPH_STATE_IMPLICIT_BITFIELD_MASKING).

This is necessary, because not only the lowering phase is affected.
Additionally, the load store optimisation should handle Sels differently.

cleanup

Removes obsolete debug output and confusing comments

big refactoring of arch_XXX functions

This tries to get the names in a consistent format. We basically have 2
views on register allocation/constraints now:

1) Register Requirements and Assigments are per-instruction. Each
   instruction has requirements on its inputs and outputs, register get
   assigned for outputs of an instruction (assignment is an attribute of
   an instruction, not of the Proj-nodes).
   The internal datastructures model this form!

   The functions here have the form:
     arch_get_irn_register_req_in(node, input_nr)
     arch_get_irn_register_in(node, input_nr)
     arch_get_irn_register_req_out(node, output_nr)
     arch_set_irn_register_out(node, output_nr, register)

2) Register Requirements and Assignments are on firm-values. This view
   allows to query/assign requirements and registers at the Proj nodes
   instead of the repsective predecessors.
   This is a convenience interface modeled on top of the other!

   The functions have the form:
     arch_get_irn_register_req(node)
     arch_get_irn_register(node)
     arch_set_irn_register(node, register)

remove old type

sparc: fix spilling+reloading of float values

implement aggregate returns according to sparc ABI

custom stack bias code for sparc

sparc: fix float calling conventions

sparc: fix mode of fdiv result

sparc: fix wrong incsp in omit-fp mode

fix names of some dumped vcg files

sparc: floatingpoint flags producing nodes have 1 cycle delay, add an ad-hoc fix for that

fix sparc fneg instruction emitter

avoid generic names like flags in generator

Implement double-register support for prefalloc with an ILP method

use 'default' ilp solver if nothing specified

lpp: only read solution in gurobi solver if one was found

lpp: call the constraint types lpp_{less|greater}_equal because they are a {less|greater} equal operation

consistently give all lpp functions an lpp_ prefix

lpp: use inline functions instead of macros

lpp: add firm copyright header, some cleanups

fix cparser warnings in beprefalloc

prefalloc will respect alignment when initially assigning registers

do not sign_extend too early in tarval_convert_to

simplify/remove unnecessary complicated copy-pasta code

merge after_ra and finish phase, and move stack_bias fixing into backends

Added soft float support for IA32 backend.

Implemented floating point lowering to Calls into a soft float library.

Fix size_t related warnings

Inliner must not inline parameter entities

This reverts commit a63fa62c9468f8af3fa6b16001912de9c9c472af.

While the inliner could do this right,
the fix for now is to not inline such functions.

Inliner must clear parameter flag of entities

also change mode_P when setting a new modeP_data

let backends specify the complete long double type

allow setting primitive type size so we can model things like 'long double' size 16 with mode_E

Directly create Start/Return node in sparc backend

Since we have no complicated barrier/prolog stuff in the transform phase
anymore we can move away from beabihelper now and create the nodes
directly which will be necessary when modeling special constraints like
wide aligned registers.

factor out code for address of register param taken

So sparc can handle this case now.

maintain method types variadicity,properties,calling convention when modifying them

rework taking of parameter addresses

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

simplify/rework lower_calls interface and code

This was done by removing unnecessary options/options that only
allowed marginal tweakings to improve performance while at the same time
making the interface cumbersome.

a few cleanups in scalar replacement code

remove (broken+unused) support for right_to_left parameter passing

call hook_new_entity after copying entity so the firm debugger can catch it

split irg and irp resources, add IRP_RESOURCE_TYPE_LINK

ia32_Minus64Bit needs no contraint copies.

Its emitter handles this.