llvm/test/CodeGen/AArch64/GlobalISel/arm64-fallback.ll

   1 ; RUN: llc -O0 -global-isel -global-isel-abort=2 -pass-remarks-missed='gisel*' -verify-machineinstrs %s -o %t.out 2> %t.err
   2 ; RUN: FileCheck %s --check-prefix=FALLBACK-WITH-REPORT-OUT < %t.out
   3 ; RUN: FileCheck %s --check-prefix=FALLBACK-WITH-REPORT-ERR < %t.err
   4 ; RUN: not --crash llc -global-isel -mtriple aarch64_be %s -o - 2>&1 | FileCheck %s --check-prefix=BIG-ENDIAN
   5 ; This file checks that the fallback path to selection dag works.
   6 ; The test is fragile in the sense that it must be updated to expose
   7 ; something that fails with global-isel.
   8 ; When we cannot produce a test case anymore, that means we can remove
   9 ; the fallback path.
  10
  11 target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
  12 target triple = "aarch64--"
  13
  14 ; BIG-ENDIAN: unable to translate in big endian mode
  15
  16 ; Make sure we don't mess up metadata arguments.
  17 declare void @llvm.write_register.i64(metadata, i64)
  18
  19 ; FALLBACK-WITH-REPORT-ERR: remark: <unknown>:0:0: unable to legalize instruction: G_WRITE_REGISTER !0, %0:_(s64) (in function: test_write_register_intrin)
  20 ; FALLBACK-WITH-REPORT-ERR: warning: Instruction selection used fallback path for test_write_register_intrin
  21 ; FALLBACK-WITH-REPORT-LABEL: test_write_register_intrin:
  22 define void @test_write_register_intrin() {
  23   call void @llvm.write_register.i64(metadata !{!"sp"}, i64 0)
  24   ret void
  25 }
  26
  27 @_ZTIi = external global ptr
  28 declare i32 @__gxx_personality_v0(...)
  29
  30 ; FALLBACK-WITH-REPORT-ERR: remark: <unknown>:0:0: unable to legalize instruction: %2:_(<2 x p0>) = G_INSERT_VECTOR_ELT %0:_, %{{[0-9]+}}:_(p0), %{{[0-9]+}}:_(s32) (in function: vector_of_pointers_insertelement)
  31 ; FALLBACK-WITH-REPORT-ERR: warning: Instruction selection used fallback path for vector_of_pointers_insertelement
  32 ; FALLBACK-WITH-REPORT-OUT-LABEL: vector_of_pointers_insertelement:
  33 define void @vector_of_pointers_insertelement() {
  34   br label %end
  35
  36 block:
  37   %dummy = insertelement <2 x ptr> %vec, ptr null, i32 0
  38   store <2 x ptr> %dummy, ptr undef
  39   ret void
  40
  41 end:
  42   %vec = load <2 x ptr>, ptr undef
  43   br label %block
  44 }
  45
  46 ; FALLBACK-WITH-REPORT-ERR: remark: <unknown>:0:0: cannot select: RET_ReallyLR implicit $x0 (in function: strict_align_feature)
  47 ; FALLBACK-WITH-REPORT-ERR: warning: Instruction selection used fallback path for strict_align_feature
  48 ; FALLBACK-WITH-REPORT-OUT-LABEL: strict_align_feature
  49 define i64 @strict_align_feature(ptr %p) #0 {
  50   %x = load i64, ptr %p, align 1
  51   ret i64 %x
  52 }
  53
  54 attributes #0 = { "target-features"="+strict-align" }
  55
  56 ; FALLBACK-WITH-REPORT-ERR: remark: <unknown>:0:0: unable to translate instruction: call
  57 ; FALLBACK-WITH-REPORT-ERR: warning: Instruction selection used fallback path for direct_mem
  58 ; FALLBACK-WITH-REPORT-OUT-LABEL: direct_mem
  59 define void @direct_mem(i32 %x, i32 %y) {
  60 entry:
  61   tail call void asm sideeffect "", "imr,imr,~{memory}"(i32 %x, i32 %y)
  62   ret void
  63 }
  64
  65 ; FALLBACK-WITH-REPORT-ERR: remark: <unknown>:0:0: unable to lower function{{.*}}scalable_arg
  66 ; FALLBACK-WITH-REPORT-OUT-LABEL: scalable_arg
  67 define <vscale x 16 x i8> @scalable_arg(<vscale x 16 x i1> %pred, ptr %addr) #1 {
  68   %res = call <vscale x 16 x i8> @llvm.aarch64.sve.ld1.nxv16i8(<vscale x 16 x i1> %pred, ptr %addr)
  69   ret <vscale x 16 x i8> %res
  70 }
  71
  72 ; FALLBACK-WITH-REPORT-ERR: remark: <unknown>:0:0: unable to lower function{{.*}}scalable_ret
  73 ; FALLBACK-WITH-REPORT-OUT-LABEL: scalable_ret
  74 define <vscale x 16 x i8> @scalable_ret(ptr %addr) #1 {
  75   %pred = call <vscale x 16 x i1> @llvm.aarch64.sve.ptrue.nxv16i1(i32 0)
  76   %res = call <vscale x 16 x i8> @llvm.aarch64.sve.ld1.nxv16i8(<vscale x 16 x i1> %pred, ptr %addr)
  77   ret <vscale x 16 x i8> %res
  78 }
  79
  80 ; FALLBACK-WITH-REPORT-ERR: remark: <unknown>:0:0: unable to translate instruction{{.*}}scalable_call
  81 ; FALLBACK-WITH-REPORT-OUT-LABEL: scalable_call
  82 define i8 @scalable_call(ptr %addr) #1 {
  83   %pred = call <vscale x 16 x i1> @llvm.aarch64.sve.ptrue.nxv16i1(i32 0)
  84   %vec = call <vscale x 16 x i8> @llvm.aarch64.sve.ld1.nxv16i8(<vscale x 16 x i1> %pred, ptr %addr)
  85   %res = extractelement <vscale x 16 x i8> %vec, i32 0
  86   ret i8 %res
  87 }
  88
  89 ; FALLBACK-WITH-REPORT-ERR: remark: <unknown>:0:0: unable to translate instruction{{.*}}scalable_alloca
  90 ; FALLBACK-WITH-REPORT-OUT-LABEL: scalable_alloca
  91 define void @scalable_alloca() #1 {
  92   %local0 = alloca <vscale x 16 x i8>
  93   load volatile <vscale x 16 x i8>, ptr %local0
  94   ret void
  95 }
  96
  97 ; FALLBACK-WITH-REPORT-ERR: remark: <unknown>:0:0: unable to translate instruction{{.*}}asm_indirect_output
  98 ; FALLBACK-WITH-REPORT-OUT-LABEL: asm_indirect_output
  99 define void @asm_indirect_output() {
 100 entry:
 101   %ap = alloca ptr, align 8
 102   %0 = load ptr, ptr %ap, align 8
 103   call void asm sideeffect "", "=*r|m,0,~{memory}"(ptr elementtype(ptr) %ap, ptr %0)
 104   ret void
 105 }
 106
 107 %struct.foo = type { [8 x i64] }
 108
 109 ; FALLBACK-WITH-REPORT-ERR: remark: <unknown>:0:0: unable to translate instruction:{{.*}}ld64b{{.*}}asm_output_ls64
 110 ; FALLBACK-WITH-REPORT-ERR: warning: Instruction selection used fallback path for asm_output_ls64
 111 ; FALLBACK-WITH-REPORT-OUT-LABEL: asm_output_ls64
 112 define void @asm_output_ls64(ptr %output, ptr %addr) #2 {
 113 entry:
 114   %val = call i512 asm sideeffect "ld64b $0,[$1]", "=r,r,~{memory}"(ptr %addr)
 115   store i512 %val, ptr %output, align 8
 116   ret void
 117 }
 118
 119 ; FALLBACK-WITH-REPORT-ERR: remark: <unknown>:0:0: unable to translate instruction:{{.*}}st64b{{.*}}asm_input_ls64
 120 ; FALLBACK-WITH-REPORT-ERR: warning: Instruction selection used fallback path for asm_input_ls64
 121 ; FALLBACK-WITH-REPORT-OUT-LABEL: asm_input_ls64
 122 define void @asm_input_ls64(ptr %input, ptr %addr) #2 {
 123 entry:
 124   %val = load i512, ptr %input, align 8
 125   call void asm sideeffect "st64b $0,[$1]", "r,r,~{memory}"(i512 %val, ptr %addr)
 126   ret void
 127 }
 128
 129 ; FALLBACK-WITH-REPORT-ERR: remark: <unknown>:0:0: unable to legalize instruction: %4:_(s128), %5:_(s1) = G_UMULO %0:_, %6:_ (in function: umul_s128)
 130 ; FALLBACK-WITH-REPORT-ERR: warning: Instruction selection used fallback path for umul_s128
 131 ; FALLBACK-WITH-REPORT-OUT-LABEL: umul_s128
 132 declare {i128, i1} @llvm.umul.with.overflow.i128(i128, i128) nounwind readnone
 133 define zeroext i1 @umul_s128(i128 %v1, ptr %res) {
 134 entry:
 135   %t = call {i128, i1} @llvm.umul.with.overflow.i128(i128 %v1, i128 2)
 136   %val = extractvalue {i128, i1} %t, 0
 137   %obit = extractvalue {i128, i1} %t, 1
 138   store i128 %val, ptr %res
 139   ret i1 %obit
 140 }
 141
 142 ; FALLBACK-WITH-REPORT-ERR: remark: <unknown>:0:0: unable to translate instruction: {{.*}}llvm.experimental.gc.statepoint{{.*}} (in function: gc_intr)
 143 ; FALLBACK-WITH-REPORT-ERR: warning: Instruction selection used fallback path for gc_intr
 144 ; FALLBACK-WITH-REPORT-OUT-LABEL: gc_intr
 145
 146 declare token @llvm.experimental.gc.statepoint.p0(i64 immarg, i32 immarg, ptr, i32 immarg, i32 immarg, ...)
 147 declare i32 @llvm.experimental.gc.result(token)
 148
 149 declare i32 @extern_returning_i32()
 150
 151 define i32 @gc_intr() gc "statepoint-example" {
 152    %statepoint_token = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(i32 ()) @extern_returning_i32, i32 0, i32 0, i32 0, i32 0) [ "deopt"() ]
 153    %ret = call i32 (token) @llvm.experimental.gc.result(token %statepoint_token)
 154    ret i32 %ret
 155 }
 156
 157 declare void @llvm.assume(i1)
 158
 159 ; FALLBACK-WITH-REPORT-ERR: <unknown>:0:0: unable to translate instruction: call: '  %0 = tail call { i64, i32 } asm "subs $0, $0, #3", "=r,={@cchi},0,~{dirflag},~{fpsr},~{flags}"(i64 %a)' (in function: inline_asm_with_output_constraint)
 160 ; FALLBACK-WITH-REPORT-ERR: warning: Instruction selection used fallback path for inline_asm_with_output_constraint
 161 ; FALLBACK-WITH-REPORT-OUT-LABEL: inline_asm_with_output_constraint
 162 define i32 @inline_asm_with_output_constraint(i64 %a) {
 163 entry:
 164   %0 = tail call { i64, i32 } asm "subs $0, $0, #3", "=r,={@cchi},0,~{dirflag},~{fpsr},~{flags}"(i64 %a)
 165   %asmresult1 = extractvalue { i64, i32 } %0, 1
 166   %1 = icmp ult i32 %asmresult1, 2
 167   tail call void @llvm.assume(i1 %1)
 168   ret i32 %asmresult1
 169 }
 170
 171 attributes #1 = { "target-features"="+sve" }
 172 attributes #2 = { "target-features"="+ls64" }
 173
 174 declare <vscale x 16 x i1> @llvm.aarch64.sve.ptrue.nxv16i1(i32 %pattern)
 175 declare <vscale x 16 x i8> @llvm.aarch64.sve.ld1.nxv16i8(<vscale x 16 x i1>, ptr)