Aligning stack offsets for spills

[Jeff Law <jlaw@tachyum.com>]

So, as many of you know I left Red Hat a while ago and joined Tachyum.  
We're building a new processor and we've come across an issue where I 
think we need upstream discussion.

I can't divulge many of the details right now, but one of the quirks of 
our architecture is that reg+d addressing modes for our vector 
loads/stores require the displacement to be aligned.  This is an 
artifact of how these instructions are encoded.

Obviously we can emit a load of the address into a register when the 
displacement isn't aligned.  From a correctness point that works 
perfectly.  Unfortunately, it's a significant performance hit on some 
standard benchmarks (spec) where we have a great number of spills of 
vector objects into the stack at unaligned offsets in the hot parts of 
the code.


We've considered 3 possible approaches to solve this problem.

1. When the displacement isn't properly aligned, allocate more space in 
assign_stack_local so that we can make the offset aligned.  The downside 
is this potentially burns a lot of stack space, but in practice the cost 
was minimal (16 bytes in a 9k frame)  From a performance standpoint this 
works perfectly.

2. Abuse the register elimination code to create a second pointer into 
the stack.  Spills would start as <virtual> + offset, then either get 
eliminated to sp+offset' when the offset is aligned or gpr+offset'' when 
the offset wasn't properly aligned. We started a bit down this path, but 
with #1 working so well, we didn't get this approach to proof-of-concept.

3. Hack up the post-reload optimizers to fix things up as best as we 
can.  This may still be advantageous, but again with #1 working so well, 
we didn't explore this in any significant way.  We may still look at 
this at some point in other contexts.



Here's what we're playing with.  Obviously we'd need a target hook to 
drive this behavior.  I was thinking that we'd pass in any slot offset 
alignment requirements (from the target hook) to assign_stack_local and 
that would bubble down to this point in try_fit_stack_local:

diff --git a/gcc/function.c b/gcc/function.c
index d616f5f64f4..7f441b87a63 100644
--- a/gcc/function.c
+++ b/gcc/function.c
@@ -307,6 +307,14 @@ try_fit_stack_local (poly_int64 start, poly_int64 
length,
    frame_off = targetm.starting_frame_offset () % frame_alignment;
    frame_phase = frame_off ? frame_alignment - frame_off : 0;

+  if (known_eq (size, 64) && alignment < 64)
+    alignment = 64;
+
    /* Round the frame offset to the specified alignment.  */

    if (FRAME_GROWS_DOWNWARD)

Thoughts?

Jeff