flang/test/Lower/PowerPC/ppc-vec_abs.f90

   1 ! RUN: bbc -emit-fir %s -o - | FileCheck --check-prefixes="CHECK-FIR" %s
   2 ! RUN: %flang_fc1 -emit-fir %s -o - | fir-opt --fir-to-llvm-ir | FileCheck --check-prefixes="CHECK-LLVMIR" %s
   3 ! RUN: %flang_fc1 -emit-llvm %s -o - | FileCheck --check-prefixes="CHECK" %s
   4 ! REQUIRES: target=powerpc{{.*}}
   5
   6 !----------------------
   7 ! vec_abs
   8 !----------------------
   9
  10 ! CHECK-LABEL: vec_abs_i1
  11 subroutine vec_abs_i1(arg1)
  12   vector(integer(1)) :: arg1, r
  13   r = vec_abs(arg1)
  14
  15 ! CHECK-FIR: %[[arg1:.*]] = fir.load %{{.*}} : !fir.ref<!fir.vector<16:i8>>
  16 ! CHECK-FIR: %[[varg1:.*]] = fir.convert %[[arg1]] : (!fir.vector<16:i8>) -> vector<16xi8>
  17 ! CHECK-FIR: %[[zero:.*]] = arith.constant 0 : i8
  18 ! CHECK-FIR: %[[vzero:.*]] = vector.broadcast %[[zero]] : i8 to vector<16xi8>
  19 ! CHECK-FIR: %[[sub:.*]] = arith.subi %[[vzero]], %[[varg1]] : vector<16xi8>
  20 ! CHECK-FIR: %{{[0-9]+}} = fir.call @llvm.ppc.altivec.vmaxsb(%[[sub]], %[[varg1]]) fastmath<contract> : (vector<16xi8>, vector<16xi8>) -> !fir.vector<16:i8>
  21
  22 ! CHECK-LLVMIR: %[[arg1:.*]] = llvm.load %{{.*}} : !llvm.ptr<vector<16xi8>>
  23 ! CHECK-LLVMIR: %{{.*}} = llvm.mlir.constant(0 : i8) : i8
  24 ! CHECK-LLVMIR: %[[vzero:.*]] = llvm.mlir.constant(dense<0> : vector<16xi8>) : vector<16xi8>
  25 ! CHECK-LLVMIR: %[[sub:.*]] = llvm.sub %[[vzero]], %[[arg1]]  : vector<16xi8>
  26 ! CHECK-LLVMIR: %{{[0-9]+}} = llvm.call @llvm.ppc.altivec.vmaxsb(%[[sub]], %[[arg1]]) {fastmathFlags = #llvm.fastmath<contract>} : (vector<16xi8>, vector<16xi8>) -> vector<16xi8>
  27
  28 ! CHECK: %[[arg1:.*]] = load <16 x i8>, ptr %{{.*}}, align 16
  29 ! CHECK: %[[sub:.*]] = sub <16 x i8> zeroinitializer, %[[arg1]]
  30 ! CHECK: %{{[0-9]+}} = call <16 x i8> @llvm.ppc.altivec.vmaxsb(<16 x i8> %[[sub]], <16 x i8> %[[arg1]])
  31 end subroutine vec_abs_i1
  32
  33 ! CHECK-LABEL: vec_abs_i2
  34 subroutine vec_abs_i2(arg1)
  35   vector(integer(2)) :: arg1, r
  36   r = vec_abs(arg1)
  37
  38 ! CHECK-FIR: %[[arg1:.*]] = fir.load %{{.*}} : !fir.ref<!fir.vector<8:i16>>
  39 ! CHECK-FIR: %[[varg1:.*]] = fir.convert %[[arg1]] : (!fir.vector<8:i16>) -> vector<8xi16>
  40 ! CHECK-FIR: %[[zero:.*]] = arith.constant 0 : i16
  41 ! CHECK-FIR: %[[vzero:.*]] = vector.broadcast %[[zero]] : i16 to vector<8xi16>
  42 ! CHECK-FIR: %[[sub:.*]] = arith.subi %[[vzero]], %[[varg1]] : vector<8xi16>
  43 ! CHECK-FIR: %{{[0-9]+}} = fir.call @llvm.ppc.altivec.vmaxsh(%[[sub]], %[[varg1]]) fastmath<contract> : (vector<8xi16>, vector<8xi16>) -> !fir.vector<8:i16>
  44
  45 ! CHECK-LLVMIR: %[[arg1:.*]] = llvm.load %{{.*}} : !llvm.ptr<vector<8xi16>>
  46 ! CHECK-LLVMIR: %{{.*}} = llvm.mlir.constant(0 : i16) : i16
  47 ! CHECK-LLVMIR: %[[vzero:.*]] = llvm.mlir.constant(dense<0> : vector<8xi16>) : vector<8xi16>
  48 ! CHECK-LLVMIR: %[[sub:.*]] = llvm.sub %[[vzero]], %[[arg1]]  : vector<8xi16>
  49 ! CHECK-LLVMIR: %{{[0-9]+}} = llvm.call @llvm.ppc.altivec.vmaxsh(%[[sub]], %[[arg1]]) {fastmathFlags = #llvm.fastmath<contract>} : (vector<8xi16>, vector<8xi16>) -> vector<8xi16>
  50
  51 ! CHECK: %[[arg1:.*]] = load <8 x i16>, ptr %{{.*}}, align 16
  52 ! CHECK: %[[sub:.*]] = sub <8 x i16> zeroinitializer, %[[arg1]]
  53 ! CHECK: %{{[0-9]+}} = call <8 x i16> @llvm.ppc.altivec.vmaxsh(<8 x i16> %[[sub]], <8 x i16> %[[arg1]])
  54 end subroutine vec_abs_i2
  55
  56 ! CHECK-LABEL: vec_abs_i4
  57 subroutine vec_abs_i4(arg1)
  58   vector(integer(4)) :: arg1, r
  59   r = vec_abs(arg1)
  60
  61 ! CHECK-FIR: %[[arg1:.*]] = fir.load %{{.*}} : !fir.ref<!fir.vector<4:i32>>
  62 ! CHECK-FIR: %[[varg1:.*]] = fir.convert %[[arg1]] : (!fir.vector<4:i32>) -> vector<4xi32>
  63 ! CHECK-FIR: %[[zero:.*]] = arith.constant 0 : i32
  64 ! CHECK-FIR: %[[vzero:.*]] = vector.broadcast %[[zero]] : i32 to vector<4xi32>
  65 ! CHECK-FIR: %[[sub:.*]] = arith.subi %[[vzero]], %[[varg1]] : vector<4xi32>
  66 ! CHECK-FIR: %{{[0-9]+}} = fir.call @llvm.ppc.altivec.vmaxsw(%[[sub]], %[[varg1]]) fastmath<contract> : (vector<4xi32>, vector<4xi32>) -> !fir.vector<4:i32>
  67
  68 ! CHECK-LLVMIR: %[[arg1:.*]] = llvm.load %{{.*}} : !llvm.ptr<vector<4xi32>>
  69 ! CHECK-LLVMIR: %{{.*}} = llvm.mlir.constant(0 : i32) : i32
  70 ! CHECK-LLVMIR: %[[vzero:.*]] = llvm.mlir.constant(dense<0> : vector<4xi32>) : vector<4xi32>
  71 ! CHECK-LLVMIR: %[[sub:.*]] = llvm.sub %[[vzero]], %[[arg1]]  : vector<4xi32>
  72 ! CHECK-LLVMIR: %{{[0-9]+}} = llvm.call @llvm.ppc.altivec.vmaxsw(%[[sub]], %[[arg1]]) {fastmathFlags = #llvm.fastmath<contract>} : (vector<4xi32>, vector<4xi32>) -> vector<4xi32>
  73
  74 ! CHECK: %[[arg1:.*]] = load <4 x i32>, ptr %{{.*}}, align 16
  75 ! CHECK: %[[sub:.*]] = sub <4 x i32> zeroinitializer, %[[arg1]]
  76 ! CHECK: %{{[0-9]+}} = call <4 x i32> @llvm.ppc.altivec.vmaxsw(<4 x i32> %[[sub]], <4 x i32> %[[arg1]])
  77 end subroutine vec_abs_i4
  78
  79 ! CHECK-LABEL: vec_abs_i8
  80 subroutine vec_abs_i8(arg1)
  81   vector(integer(8)) :: arg1, r
  82   r = vec_abs(arg1)
  83
  84 ! CHECK-FIR: %[[arg1:.*]] = fir.load %{{.*}} : !fir.ref<!fir.vector<2:i64>>
  85 ! CHECK-FIR: %[[varg1:.*]] = fir.convert %[[arg1]] : (!fir.vector<2:i64>) -> vector<2xi64>
  86 ! CHECK-FIR: %[[zero:.*]] = arith.constant 0 : i64
  87 ! CHECK-FIR: %[[vzero:.*]] = vector.broadcast %[[zero]] : i64 to vector<2xi64>
  88 ! CHECK-FIR: %[[sub:.*]] = arith.subi %[[vzero]], %[[varg1]] : vector<2xi64>
  89 ! CHECK-FIR: %{{[0-9]+}} = fir.call @llvm.ppc.altivec.vmaxsd(%[[sub]], %[[varg1]]) fastmath<contract> : (vector<2xi64>, vector<2xi64>) -> !fir.vector<2:i64>
  90
  91 ! CHECK-LLVMIR: %[[arg1:.*]] = llvm.load %{{.*}} : !llvm.ptr<vector<2xi64>>
  92 ! CHECK-LLVMIR: %{{.*}} = llvm.mlir.constant(0 : i64) : i64
  93 ! CHECK-LLVMIR: %[[vzero:.*]] = llvm.mlir.constant(dense<0> : vector<2xi64>) : vector<2xi64>
  94 ! CHECK-LLVMIR: %[[sub:.*]] = llvm.sub %[[vzero]], %[[arg1]]  : vector<2xi64>
  95 ! CHECK-LLVMIR: %{{[0-9]+}} = llvm.call @llvm.ppc.altivec.vmaxsd(%[[sub]], %[[arg1]]) {fastmathFlags = #llvm.fastmath<contract>} : (vector<2xi64>, vector<2xi64>) -> vector<2xi64>
  96
  97 ! CHECK: %[[arg1:.*]] = load <2 x i64>, ptr %{{.*}}, align 16
  98 ! CHECK: %[[sub:.*]] = sub <2 x i64> zeroinitializer, %[[arg1]]
  99 ! CHECK: %{{[0-9]+}} = call <2 x i64> @llvm.ppc.altivec.vmaxsd(<2 x i64> %[[sub]], <2 x i64> %[[arg1]])
 100 end subroutine vec_abs_i8
 101
 102 ! CHECK-LABEL: vec_abs_r4
 103 subroutine vec_abs_r4(arg1)
 104   vector(real(4)) :: arg1, r
 105   r = vec_abs(arg1)
 106
 107 ! CHECK-FIR: %[[arg1:.*]] = fir.load %{{.*}} : !fir.ref<!fir.vector<4:f32>>
 108 ! CHECK-FIR: %{{[0-9]+}} = fir.call @llvm.fabs.v4f32(%[[arg1]]) fastmath<contract> : (!fir.vector<4:f32>) -> !fir.vector<4:f32>
 109
 110 ! CHECK-LLVMIR: %[[arg1:.*]] = llvm.load %{{.*}} : !llvm.ptr<vector<4xf32>>
 111 ! CHECK-LLVMIR: %{{[0-9]+}} = llvm.call @llvm.fabs.v4f32(%[[arg1]]) {fastmathFlags = #llvm.fastmath<contract>} : (vector<4xf32>) -> vector<4xf32>
 112
 113 ! CHECK: %[[arg1:.*]] = load <4 x float>, ptr %{{.*}}, align 16
 114 ! CHECK: %{{[0-9]+}} = call contract <4 x float> @llvm.fabs.v4f32(<4 x float> %[[arg1]])
 115 end subroutine vec_abs_r4
 116
 117 ! CHECK-LABEL: vec_abs_r8
 118 subroutine vec_abs_r8(arg1)
 119   vector(real(8)) :: arg1, r
 120   r = vec_abs(arg1)
 121
 122 ! CHECK-FIR: %[[arg1:.*]] = fir.load %{{.*}} : !fir.ref<!fir.vector<2:f64>>
 123 ! CHECK-FIR: %{{[0-9]+}} = fir.call @llvm.fabs.v2f64(%[[arg1]]) fastmath<contract> : (!fir.vector<2:f64>) -> !fir.vector<2:f64>
 124
 125 ! CHECK-LLVMIR: %[[arg1:.*]] = llvm.load %{{.*}} : !llvm.ptr<vector<2xf64>>
 126 ! CHECK-LLVMIR: %{{[0-9]+}} = llvm.call @llvm.fabs.v2f64(%[[arg1]]) {fastmathFlags = #llvm.fastmath<contract>} : (vector<2xf64>) -> vector<2xf64>
 127
 128 ! CHECK: %[[arg1:.*]] = load <2 x double>, ptr %{{.*}}, align 16
 129 ! CHECK: %{{[0-9]+}} = call contract <2 x double> @llvm.fabs.v2f64(<2 x double> %[[arg1]])
 130 end subroutine vec_abs_r8
 131