llvm/test/CodeGen/X86/hipe-cc64.ll

   1 ; RUN: llc < %s -stack-symbol-ordering=0 -tailcallopt -relocation-model=static -code-model=medium -mtriple=x86_64-linux-gnu -mcpu=opteron | FileCheck %s
   2
   3 ; Check the HiPE calling convention works (x86-64)
   4
   5 define void @zap(i64 %a, i64 %b) nounwind {
   6 entry:
   7   ; CHECK:      movq %rsi, %rdx
   8   ; CHECK-NEXT: movl $8, %ecx
   9   ; CHECK-NEXT: movl $9, %r8d
  10   ; CHECK-NEXT: movq %rdi, %rsi
  11   ; CHECK-NEXT: callq addfour
  12   %0 = call cc 11 {i64, i64, i64} @addfour(i64 undef, i64 undef, i64 %a, i64 %b, i64 8, i64 9)
  13   %res = extractvalue {i64, i64, i64} %0, 2
  14
  15   ; CHECK:      movl $1, %edx
  16   ; CHECK-NEXT: movl $2, %ecx
  17   ; CHECK-NEXT: movl $3, %r8d
  18   ; CHECK-NEXT: movq %rax, %r9
  19   ; CHECK:      callq foo
  20   tail call void @foo(i64 undef, i64 undef, i64 1, i64 2, i64 3, i64 %res) nounwind
  21   ret void
  22 }
  23
  24 define cc 11 {i64, i64, i64} @addfour(i64 %hp, i64 %p, i64 %x, i64 %y, i64 %z, i64 %w) nounwind {
  25 entry:
  26   ; CHECK:      leaq (%rsi,%rdx), %rax
  27   ; CHECK-NEXT: addq %rcx, %rax
  28   ; CHECK-NEXT: addq %r8, %rax
  29   %0 = add i64 %x, %y
  30   %1 = add i64 %0, %z
  31   %2 = add i64 %1, %w
  32
  33   ; CHECK:      ret
  34   %res = insertvalue {i64, i64, i64} undef, i64 %2, 2
  35   ret {i64, i64, i64} %res
  36 }
  37
  38 define cc 11 void @foo(i64 %hp, i64 %p, i64 %arg0, i64 %arg1, i64 %arg2, i64 %arg3) nounwind {
  39 entry:
  40   ; CHECK:      movq  %r15, 40(%rsp)
  41   ; CHECK-NEXT: movq  %rbp, 32(%rsp)
  42   ; CHECK-NEXT: movq  %rsi, 24(%rsp)
  43   ; CHECK-NEXT: movq  %rdx, 16(%rsp)
  44   ; CHECK-NEXT: movq  %rcx, 8(%rsp)
  45   ; CHECK-NEXT: movq  %r8, (%rsp)
  46   %hp_var   = alloca i64
  47   %p_var    = alloca i64
  48   %arg0_var = alloca i64
  49   %arg1_var = alloca i64
  50   %arg2_var = alloca i64
  51   %arg3_var = alloca i64
  52   store i64 %hp, ptr %hp_var
  53   store i64 %p, ptr %p_var
  54   store i64 %arg0, ptr %arg0_var
  55   store i64 %arg1, ptr %arg1_var
  56   store i64 %arg2, ptr %arg2_var
  57   store i64 %arg3, ptr %arg3_var
  58
  59   ; Loads are reading values just writen from corresponding register and are therefore noops.
  60   %0 = load i64, ptr %hp_var
  61   %1 = load i64, ptr %p_var
  62   %2 = load i64, ptr %arg0_var
  63   %3 = load i64, ptr %arg1_var
  64   %4 = load i64, ptr %arg2_var
  65   %5 = load i64, ptr %arg3_var
  66   ; CHECK:      jmp bar
  67   tail call cc 11 void @bar(i64 %0, i64 %1, i64 %2, i64 %3, i64 %4, i64 %5) nounwind
  68   ret void
  69 }
  70
  71 define cc 11 void @baz() nounwind {
  72   %tmp_clos = load i64, ptr @clos
  73   %tmp_clos2 = inttoptr i64 %tmp_clos to ptr
  74   ; CHECK:      movl $42, %esi
  75   ; CHECK-NEXT: jmpq *(%rax)
  76   tail call cc 11 void %tmp_clos2(i64 undef, i64 undef, i64 42) nounwind
  77   ret void
  78 }
  79
  80 ; Sanity-check the tail call sequence. Number of arguments was chosen as to
  81 ; expose a bug where the tail call sequence clobbered the stack.
  82 define cc 11 { i64, i64, i64 } @tailcaller(i64 %hp, i64 %p) #0 {
  83   ; CHECK:      movl    $15, %esi
  84   ; CHECK-NEXT: movl    $31, %edx
  85   ; CHECK-NEXT: movl    $47, %ecx
  86   ; CHECK-NEXT: movl    $63, %r8d
  87   ; CHECK-NEXT: popq    %rax
  88   ; CHECK-NEXT: .cfi_def_cfa_offset 16
  89   ; CHECK-NEXT: jmp     tailcallee
  90   %ret = tail call cc11 { i64, i64, i64 } @tailcallee(i64 %hp, i64 %p, i64 15,
  91      i64 31, i64 47, i64 63, i64 79) #1
  92   ret { i64, i64, i64 } %ret
  93 }
  94
  95 !hipe.literals = !{ !0, !1, !2 }
  96 !0 = !{ !"P_NSP_LIMIT", i32 160 }
  97 !1 = !{ !"X86_LEAF_WORDS", i32 24 }
  98 !2 = !{ !"AMD64_LEAF_WORDS", i32 24 }
  99 @clos = external constant i64
 100 declare cc 11 void @bar(i64, i64, i64, i64, i64, i64)
 101 declare cc 11 { i64, i64, i64 } @tailcallee(i64, i64, i64, i64, i64, i64, i64)
 102 !llvm.module.flags = !{!3}
 103 !3 = !{i32 2, !"override-stack-alignment", i32 8}