RFR 8222717 [lworld] Calling convention - repair C1 stack

[Ioi Lam]

I found a bug in the code that saves the real stack size. It was saving 
to 0x08(rsp). It should save to [frame size - 8](rsp) instead. Here's 
the delta from the previous webrev, plus a bunch of test cases that 
checks for stack walking with an extended C1 stack frame.

http://cr.openjdk.java.net/~iklam/valhalla/8222717-c1-stack-repair.v02-delta/

Stack unwinding doesn't work yet. I'll fix that in a separate patch. See 
https://bugs.openjdk.java.net/browse/JDK-8222908

Thanks
- Ioi

On 4/22/19 6:02 PM, Ioi Lam wrote:
>  Hi Tobias,
>
> Here's an example of the code that I am generating for JDK-8222717 
> [lworld] Calling
> convention - repair C1 stack [1]
>
> The C2 stack repair code relies on the reserved slots in the VEP 
> calling convention
> (see [2], page 14) to preserve the caller's return address.
>
> However, I haven't quite figured out how to do the same thing for
> the VVEP calling convention (as doing so will also recursively affect 
> the VEP convetion).
> So for now, I decide to have a simplier approach for C1, by directly 
> manipulating the
> return address on the stack. See line 165 in the following dump.
>
> Actually, I am not quite sure how the C2 code uses the RA pushed by 
> line 31, but it
> turns out to be very handy for C1 :-)
>
> Here's the webrev:
>
> http://cr.openjdk.java.net/~iklam/valhalla/8222717-c1-stack-repair.v01/
>
> With C1, the frequency of stack extension is much lower (only when you 
> have scalarized
> floating-point fields), so even though the code is not as efficient as 
> the C2 stack
> repair code, maybe it's still OK?
>
> What do you think?
>
> Thanks
> - Ioi
>
>
>
>
>
> public class Foo {
>     static value class V {
>       int a = 0, b = 0;
>     }
>     // C1 extends stack (1 extra stack word)
>     static int test(U u1, int a1, int a2, int a3, int a4, int a5, int 
> a6) {
>         return a1 + a2 + a6;
>     }
>     public static void main(String args[]) {
>         V v = new V();
>         System.out.println("Hello: " + test(u, 1, 2, 3, 4, 5, 6));
>     }
> }
>
> ----------------------------------------------------------------------
>
> Foo.test(QFoo$U;IIIIII)I  [0x00007fc7a0e361e0, 0x00007fc7a0e36398]  
> 440 bytes
> [Disassembling for mach='i386:x86-64']
>   # {method} {0x00007fc78b2f7808} 'test' '(QFoo$U;IIIIII)I' in 'Foo'
> [Entry Point]
> [Verified Entry Point]
> [Verified Value Entry Point (RO)]
>   # parm0:    xmm0      = float
>   # parm1:    xmm1      = float
>   # parm2:    xmm2      = float
>   # parm3:    rsi       = int
>   # parm4:    rdx       = int
>   # parm5:    rcx       = int
>   # parm6:    r8        = int
>   # parm7:    r9        = int
>   # parm8:    rdi       = int
>   #           [sp+0x40]  (sp of caller)
>  ;;  block B1 [0, 0]
>
>      0: push   %rbp
>      1: sub    $0x30,%rsp
>      5: mov    $0x7fc78b2f7808,%rbx
>     15: callq  0x00007fc7a09d8ac0  ;   {runtime_call buffer_value_args 
> Runtime1 stub}
>     20: pop    %rbp
>
> // extend stack
>     21: add    $0x30,%rsp
>     25: pop    %r13
>     27: sub    $0x10,%rsp
>     31: push   %r13                ; << RA saved by stack extension code
>
>     33: mov    %rdi,0x8(%rsp)
>     38: mov    %r9,%rdi
>     41: mov    %r8,%r9
>     44: mov    %rcx,%r8
>     47: mov    %rdx,%rcx
>     50: mov    %rsi,%rdx
>     53: mov    0x10(%rax),%esi
>     56: vmovss %xmm0,0x10(%rsi)
>     61: vmovss %xmm1,0x14(%rsi)
>     66: vmovss %xmm2,0x18(%rsi)
>
>     71: mov    %eax,-0x16000(%rsp)
>
>     78: push   %rbp                ; << now RA is just one word below 
> saved rbp
>     79: sub    $0x30,%rsp
>     83: movq   $0x50,0x8(%rsp)
>     92: jmpq    L_1 (149) v
>
> [Verified Value Entry Point]
>   # parm0:    rsi:rsi   = 'java/lang/Object'
>   # parm1:    rdx       = int
>   # parm2:    rcx       = int
>   # parm3:    r8        = int
>   # parm4:    r9        = int
>   # parm5:    rdi       = int
>   # parm6:    [sp+0x40]   = int  (sp of caller)
>    128: mov    %eax,-0x16000(%rsp)
>    135: push   %rbp                ; << RA is  one word below saved rbp
>    136: sub    $0x30,%rsp
>    140: movq   $0x40,0x8(%rsp)
>
> L_1
>    149: mov    0x40(%rsp),%eax
>  ;;  block B0 [0, 6]
>
>    153: add    %ecx,%edx
>    155: add    %eax,%edx
>    157: mov    %rdx,%rax
>
>    // stack repair
>    160: mov    0x38(%rsp),%r13     ; get saved RA
>    165: mov    0x30(%rsp),%rbp     ; restore saved rbp
>    170: add    0x8(%rsp),%rsp
>    175: push   %r13                ; push RA, so stack would look the
>                                    ; same as @ line 135
>    // stack repair - end
>
>    177: mov    0x128(%r15),%r10
>    184: test   %eax,(%r10)         ;   {poll_return}
>    187: retq                       ; return to caller
>
>
> ----------------------------------------------------------------------
> [1] https://bugs.openjdk.java.net/browse/JDK-8222717
> [2] 
> http://cr.openjdk.java.net/~thartmann/talks/2019-ValueType_Optimizations.pdf
>