* This also resolves an out-of-bounds access when a '#' is encountered.
* This also corrects a wrong format specifier in a panic message in the x86 backend.

Now we get a nice abort instead of silently generating invalid code, when a sparc immediate constraint cannot be fulfilled.

This enables matching Address+Const.

'A' is for 5-bit immediates, but the code matches the behavior of 'i', i.e. any immediate.

mode_b cannot/must be present in these places, otherwise the verifier would have complained.

amd64, arm, sparc: Replace the dependency edge of the IncSP after the Call by a stack output of the call.

This removes the only uses of dependency edges.

They only produce a single result and having mode_T is unnecessary.
This could be improved, i.e. use both results.
But I just corrected the current usage.

Since the prologue is added late, there are no Save nodes during transformation.

This flag is plain redundant.

* No \n at end; panic() adds one
* No punctuation mark at end
* Lowercase first letter

All other structs holding a register class call it cls, too.

- alignment is set on each single IncSP now instead of a global arch_env
  setting
- fixed ia32 not requesting any alignment anymore (even on darwin where
  we need it)
- fixed amd64 creating IncSP nodes without flag_modifies_flags set

The start block is not special block without any "real" instructions
anymore. In particular this means:

- There is no X_initial_exec Proj from the Start node anymore, "normal"
  cfopts are used for jumping out of the start block.
- The backend never had the special convention of the start block not
  containing actual code and used to fixup this discrpancy, no more
  fixup code needed now.
- The part_block() code got a bit more complicated because splitting the
  start block is tricky (previously part_block() simply failed in this
  case but was never used in the Start block because of its special
  convention)

- It was only available in the ia32 backend and broken there. As the
  feature is rarely used, I remove it for now instead of going through
  the trouble of fixing it.

The previous approach put the irg link into the block attributes, so
while saving memory an extra indirection was necessary. Some testing
with valgrind massif+callgrind revealed that a direct link increses peak
memory usage by ~1% while also increasing runtime by ~1%. More
importantly the code gets a bit simpler and some strange corner cases can be
removed with the direct link.