test/CodeGen/AArch64/fp16-fmla.ll

   1 ; RUN: llc < %s -mtriple=aarch64-none-linux-gnu -mattr=+v8.2a,+fullfp16 -fp-contract=fast  | FileCheck %s
   2
   3 define half @test_FMULADDH_OP1(half %a, half %b, half %c) {
   4 ; CHECK-LABEL: test_FMULADDH_OP1:
   5 ; CHECK: fmadd    {{h[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}}
   6 entry:
   7   %mul = fmul fast half %c, %b
   8   %add = fadd fast half %mul, %a
   9   ret half %add
  10 }
  11
  12 define half @test_FMULADDH_OP2(half %a, half %b, half %c) {
  13 ; CHECK-LABEL: test_FMULADDH_OP2:
  14 ; CHECK: fmadd    {{h[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}}
  15 entry:
  16   %mul = fmul fast half %c, %b
  17   %add = fadd fast half %a, %mul
  18   ret half %add
  19 }
  20
  21 define half @test_FMULSUBH_OP1(half %a, half %b, half %c) {
  22 ; CHECK-LABEL: test_FMULSUBH_OP1:
  23 ; CHECK: fnmsub    {{h[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}}
  24 entry:
  25   %mul = fmul fast half %c, %b
  26   %sub = fsub fast half %mul, %a
  27   ret half %sub
  28 }
  29
  30 define half @test_FMULSUBH_OP2(half %a, half %b, half %c) {
  31 ; CHECK-LABEL: test_FMULSUBH_OP2:
  32 ; CHECK: fmsub    {{h[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}}
  33 entry:
  34   %mul = fmul fast half %c, %b
  35   %add = fsub fast half %a, %mul
  36   ret half %add
  37 }
  38
  39 define half @test_FNMULSUBH_OP1(half %a, half %b, half %c) {
  40 ; CHECK-LABEL: test_FNMULSUBH_OP1:
  41 ; CHECK: fnmadd    {{h[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}}
  42 entry:
  43   %mul = fmul fast half %c, %b
  44   %neg = fsub fast half -0.0, %mul
  45   %add = fsub fast half %neg, %a
  46   ret half %add
  47 }
  48
  49 define <4 x half> @test_FMLAv4f16_OP1(<4 x half> %a, <4 x half> %b, <4 x half> %c) {
  50 ; CHECK-LABEL: test_FMLAv4f16_OP1:
  51 ; CHECK: fmla    {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
  52 entry:
  53   %mul = fmul fast <4 x half> %c, %b
  54   %add = fadd fast <4 x half> %mul, %a
  55   ret <4 x half> %add
  56 }
  57
  58 define <4 x half> @test_FMLAv4f16_OP2(<4 x half> %a, <4 x half> %b, <4 x half> %c) {
  59 ; CHECK-LABEL: test_FMLAv4f16_OP2:
  60 ; CHECK: fmla    {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
  61 entry:
  62   %mul = fmul fast <4 x half> %c, %b
  63   %add = fadd fast <4 x half> %a, %mul
  64   ret <4 x half> %add
  65 }
  66
  67 define <8 x half> @test_FMLAv8f16_OP1(<8 x half> %a, <8 x half> %b, <8 x half> %c) {
  68 ; CHECK-LABEL: test_FMLAv8f16_OP1:
  69 ; CHECK: fmla    {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
  70 entry:
  71   %mul = fmul fast <8 x half> %c, %b
  72   %add = fadd fast <8 x half> %mul, %a
  73   ret <8 x half> %add
  74 }
  75
  76 define <8 x half> @test_FMLAv8f16_OP2(<8 x half> %a, <8 x half> %b, <8 x half> %c) {
  77 ; CHECK-LABEL: test_FMLAv8f16_OP2:
  78 ; CHECK: fmla    {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
  79 entry:
  80   %mul = fmul fast <8 x half> %c, %b
  81   %add = fadd fast <8 x half> %a, %mul
  82   ret <8 x half> %add
  83 }
  84
  85 define <4 x half> @test_FMLAv4i16_indexed_OP1(<4 x half> %a, <4 x i16> %b, <4 x i16> %c) {
  86 ; CHECK-LABEL: test_FMLAv4i16_indexed_OP1:
  87 ; CHECK-FIXME: Currently LLVM produces inefficient code:
  88 ; CHECK: mul
  89 ; CHECK: fadd
  90 ; CHECK-FIXME: It should instead produce the following instruction:
  91 ; CHECK-FIXME: fmla    {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
  92 entry:
  93   %mul = mul <4 x i16> %c, %b
  94   %m = bitcast <4 x i16> %mul to <4 x half>
  95   %add = fadd fast <4 x half> %m, %a
  96   ret <4 x half> %add
  97 }
  98
  99 define <4 x half> @test_FMLAv4i16_indexed_OP2(<4 x half> %a, <4 x i16> %b, <4 x i16> %c) {
 100 ; CHECK-LABEL: test_FMLAv4i16_indexed_OP2:
 101 ; CHECK-FIXME: Currently LLVM produces inefficient code:
 102 ; CHECK: mul
 103 ; CHECK: fadd
 104 ; CHECK-FIXME: It should instead produce the following instruction:
 105 ; CHECK-FIXME: fmla    {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 106 entry:
 107   %mul = mul <4 x i16> %c, %b
 108   %m = bitcast <4 x i16> %mul to <4 x half>
 109   %add = fadd fast <4 x half> %a, %m
 110   ret <4 x half> %add
 111 }
 112
 113 define <8 x half> @test_FMLAv8i16_indexed_OP1(<8 x half> %a, <8 x i16> %b, <8 x i16> %c) {
 114 ; CHECK-LABEL: test_FMLAv8i16_indexed_OP1:
 115 ; CHECK-FIXME: Currently LLVM produces inefficient code:
 116 ; CHECK: mul
 117 ; CHECK: fadd
 118 ; CHECK-FIXME: It should instead produce the following instruction:
 119 ; CHECK-FIXME: fmla    {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 120 entry:
 121   %mul = mul <8 x i16> %c, %b
 122   %m = bitcast <8 x i16> %mul to <8 x half>
 123   %add = fadd fast <8 x half> %m, %a
 124   ret <8 x half> %add
 125 }
 126
 127 define <8 x half> @test_FMLAv8i16_indexed_OP2(<8 x half> %a, <8 x i16> %b, <8 x i16> %c) {
 128 ; CHECK-LABEL: test_FMLAv8i16_indexed_OP2:
 129 ; CHECK-FIXME: Currently LLVM produces inefficient code:
 130 ; CHECK: mul
 131 ; CHECK: fadd
 132 ; CHECK-FIXME: It should instead produce the following instruction:
 133 ; CHECK-FIXME: fmla    {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 134 entry:
 135   %mul = mul <8 x i16> %c, %b
 136   %m = bitcast <8 x i16> %mul to <8 x half>
 137   %add = fadd fast <8 x half> %a, %m
 138   ret <8 x half> %add
 139 }
 140
 141 define <4 x half> @test_FMLSv4f16_OP2(<4 x half> %a, <4 x half> %b, <4 x half> %c) {
 142 ; CHECK-LABEL: test_FMLSv4f16_OP2:
 143 ; CHECK: fmls    {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 144 entry:
 145   %mul = fmul fast <4 x half> %c, %b
 146   %sub = fsub fast <4 x half> %a, %mul
 147   ret <4 x half> %sub
 148 }
 149
 150 define <8 x half> @test_FMLSv8f16_OP1(<8 x half> %a, <8 x half> %b, <8 x half> %c) {
 151 ; CHECK-LABEL: test_FMLSv8f16_OP1:
 152 ; CHECK: fmls    {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 153 entry:
 154   %mul = fmul fast <8 x half> %c, %b
 155   %sub = fsub fast <8 x half> %mul, %a
 156   ret <8 x half> %sub
 157 }
 158
 159 define <8 x half> @test_FMLSv8f16_OP2(<8 x half> %a, <8 x half> %b, <8 x half> %c) {
 160 ; CHECK-LABEL: test_FMLSv8f16_OP2:
 161 ; CHECK: fmls    {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 162 entry:
 163   %mul = fmul fast <8 x half> %c, %b
 164   %sub = fsub fast <8 x half> %a, %mul
 165   ret <8 x half> %sub
 166 }
 167
 168 define <4 x half> @test_FMLSv4i16_indexed_OP2(<4 x half> %a, <4 x i16> %b, <4 x i16> %c) {
 169 ; CHECK-LABEL: test_FMLSv4i16_indexed_OP2:
 170 ; CHECK-FIXME: Currently LLVM produces inefficient code:
 171 ; CHECK: mul
 172 ; CHECK: fsub
 173 ; CHECK-FIXME: It should instead produce the following instruction:
 174 ; CHECK-FIXME: fmls    {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h
 175 entry:
 176   %mul = mul <4 x i16> %c, %b
 177   %m = bitcast <4 x i16> %mul to <4 x half>
 178   %sub = fsub fast <4 x half> %a, %m
 179   ret <4 x half> %sub
 180 }
 181
 182 define <8 x half> @test_FMLSv8i16_indexed_OP1(<8 x half> %a, <8 x i16> %b, <8 x i16> %c) {
 183 ; CHECK-LABEL: test_FMLSv8i16_indexed_OP1:
 184 ; CHECK-FIXME: Currently LLVM produces inefficient code:
 185 ; CHECK: mul
 186 ; CHECK: fsub
 187 ; CHECK-FIXME: It should instead produce the following instruction:
 188 ; CHECK-FIXME: fmls    {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 189 entry:
 190   %mul = mul <8 x i16> %c, %b
 191   %m = bitcast <8 x i16> %mul to <8 x half>
 192   %sub = fsub fast <8 x half> %m, %a
 193   ret <8 x half> %sub
 194 }
 195
 196 define <8 x half> @test_FMLSv8i16_indexed_OP2(<8 x half> %a, <8 x i16> %b, <8 x i16> %c) {
 197 ; CHECK-LABEL: test_FMLSv8i16_indexed_OP2:
 198 ; CHECK-FIXME: Currently LLVM produces inefficient code:
 199 ; CHECK: mul
 200 ; CHECK: fsub
 201 ; CHECK-FIXME: It should instead produce the following instruction:
 202 ; CHECK-FIXME: fmls    {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h
 203 entry:
 204   %mul = mul <8 x i16> %c, %b
 205   %m = bitcast <8 x i16> %mul to <8 x half>
 206   %sub = fsub fast <8 x half> %a, %m
 207   ret <8 x half> %sub
 208 }