1158 lines · plain
1// RUN: mlir-opt --arith-emulate-wide-int="widest-int-supported=32" %s | FileCheck %s2 3// Expect no conversions, i32 is supported.4// CHECK-LABEL: func @addi_same_i325// CHECK-SAME: ([[ARG:%.+]]: i32) -> i326// CHECK-NEXT: [[X:%.+]] = arith.addi [[ARG]], [[ARG]] : i327// CHECK-NEXT: return [[X]] : i328func.func @addi_same_i32(%a : i32) -> i32 {9 %x = arith.addi %a, %a : i3210 return %x : i3211}12 13// Expect no conversions, index is not sized.14// CHECK-LABEL: func @addi_same_index15// CHECK-SAME: ([[ARG:%.+]]: index) -> index16// CHECK-NEXT: [[X:%.+]] = arith.addi [[ARG]], [[ARG]] : index17// CHECK-NEXT: return [[X]] : index18func.func @addi_same_index(%a : index) -> index {19 %x = arith.addi %a, %a : index20 return %x : index21}22 23// Expect no conversions, f64 is not an integer type.24// CHECK-LABEL: func @identity_f6425// CHECK-SAME: ([[ARG:%.+]]: f64) -> f6426// CHECK-NEXT: return [[ARG]] : f6427func.func @identity_f64(%a : f64) -> f64 {28 return %a : f6429}30 31// Expect no conversions, i32 is supported.32// CHECK-LABEL: func @addi_same_vector_i3233// CHECK-SAME: ([[ARG:%.+]]: vector<2xi32>) -> vector<2xi32>34// CHECK-NEXT: [[X:%.+]] = arith.addi [[ARG]], [[ARG]] : vector<2xi32>35// CHECK-NEXT: return [[X]] : vector<2xi32>36func.func @addi_same_vector_i32(%a : vector<2xi32>) -> vector<2xi32> {37 %x = arith.addi %a, %a : vector<2xi32>38 return %x : vector<2xi32>39}40 41// CHECK-LABEL: func @identity_scalar42// CHECK-SAME: ([[ARG:%.+]]: vector<2xi32>) -> vector<2xi32>43// CHECK-NEXT: return [[ARG]] : vector<2xi32>44func.func @identity_scalar(%x : i64) -> i64 {45 return %x : i6446}47 48// CHECK-LABEL: func @identity_vector49// CHECK-SAME: ([[ARG:%.+]]: vector<4x2xi32>) -> vector<4x2xi32>50// CHECK-NEXT: return [[ARG]] : vector<4x2xi32>51func.func @identity_vector(%x : vector<4xi64>) -> vector<4xi64> {52 return %x : vector<4xi64>53}54 55// CHECK-LABEL: func @identity_vector2d56// CHECK-SAME: ([[ARG:%.+]]: vector<3x4x2xi32>) -> vector<3x4x2xi32>57// CHECK-NEXT: return [[ARG]] : vector<3x4x2xi32>58func.func @identity_vector2d(%x : vector<3x4xi64>) -> vector<3x4xi64> {59 return %x : vector<3x4xi64>60}61 62// CHECK-LABEL: func @call63// CHECK-SAME: ([[ARG:%.+]]: vector<4x2xi32>) -> vector<4x2xi32>64// CHECK-NEXT: [[RES:%.+]] = call @identity_vector([[ARG]]) : (vector<4x2xi32>) -> vector<4x2xi32>65// CHECK-NEXT: return [[RES]] : vector<4x2xi32>66func.func @call(%a : vector<4xi64>) -> vector<4xi64> {67 %res = func.call @identity_vector(%a) : (vector<4xi64>) -> vector<4xi64>68 return %res : vector<4xi64>69}70 71// CHECK-LABEL: func @constant_scalar72// CHECK-SAME: () -> vector<2xi32>73// CHECK-NEXT: [[C0:%.+]] = arith.constant dense<0> : vector<2xi32>74// CHECK-NEXT: [[C1:%.+]] = arith.constant dense<[0, 1]> : vector<2xi32>75// CHECK-NEXT: [[C2:%.+]] = arith.constant dense<[-7, -1]> : vector<2xi32>76// CHECK-NEXT: return [[C0]] : vector<2xi32>77func.func @constant_scalar() -> i64 {78 %c0 = arith.constant 0 : i6479 %c1 = arith.constant 4294967296 : i6480 %c2 = arith.constant -7 : i6481 return %c0 : i6482}83 84// CHECK-LABEL: func @constant_vector85// CHECK-SAME: () -> vector<3x2xi32>86// CHECK-NEXT: [[C0:%.+]] = arith.constant dense87// CHECK-SAME{LITERAL}: <[[0, 1], [0, 1], [0, 1]]> : vector<3x2xi32>88// CHECK-NEXT: [[C1:%.+]] = arith.constant dense89// CHECK-SAME{LITERAL}: <[[0, 0], [1, 0], [-2, -1]]> : vector<3x2xi32>90// CHECK-NEXT: return [[C0]] : vector<3x2xi32>91func.func @constant_vector() -> vector<3xi64> {92 %c0 = arith.constant dense<4294967296> : vector<3xi64>93 %c1 = arith.constant dense<[0, 1, -2]> : vector<3xi64>94 return %c0 : vector<3xi64>95}96 97// CHECK-LABEL: func @addi_scalar_a_b98// CHECK-SAME: ([[ARG0:%.+]]: vector<2xi32>, [[ARG1:%.+]]: vector<2xi32>) -> vector<2xi32>99// CHECK-NEXT: [[LOW0:%.+]] = vector.extract [[ARG0]][0] : i32 from vector<2xi32>100// CHECK-NEXT: [[HIGH0:%.+]] = vector.extract [[ARG0]][1] : i32 from vector<2xi32>101// CHECK-NEXT: [[LOW1:%.+]] = vector.extract [[ARG1]][0] : i32 from vector<2xi32>102// CHECK-NEXT: [[HIGH1:%.+]] = vector.extract [[ARG1]][1] : i32 from vector<2xi32>103// CHECK-NEXT: [[SUM_L:%.+]], [[CB:%.+]] = arith.addui_extended [[LOW0]], [[LOW1]] : i32, i1104// CHECK-NEXT: [[CARRY:%.+]] = arith.extui [[CB]] : i1 to i32105// CHECK-NEXT: [[SUM_H0:%.+]] = arith.addi [[CARRY]], [[HIGH0]] : i32106// CHECK-NEXT: [[SUM_H1:%.+]] = arith.addi [[SUM_H0]], [[HIGH1]] : i32107// CHECK: [[INS0:%.+]] = vector.insert [[SUM_L]], {{%.+}} [0] : i32 into vector<2xi32>108// CHECK-NEXT: [[INS1:%.+]] = vector.insert [[SUM_H1]], [[INS0]] [1] : i32 into vector<2xi32>109// CHECK-NEXT: return [[INS1]] : vector<2xi32>110func.func @addi_scalar_a_b(%a : i64, %b : i64) -> i64 {111 %x = arith.addi %a, %b : i64112 return %x : i64113}114 115// CHECK-LABEL: func @addi_vector_a_b116// CHECK-SAME: ([[ARG0:%.+]]: vector<4x2xi32>, [[ARG1:%.+]]: vector<4x2xi32>) -> vector<4x2xi32>117// CHECK-NEXT: [[LOW0:%.+]] = vector.extract_strided_slice [[ARG0]] {offsets = [0, 0], sizes = [4, 1], strides = [1, 1]} : vector<4x2xi32> to vector<4x1xi32>118// CHECK-NEXT: [[HIGH0:%.+]] = vector.extract_strided_slice [[ARG0]] {offsets = [0, 1], sizes = [4, 1], strides = [1, 1]} : vector<4x2xi32> to vector<4x1xi32>119// CHECK-NEXT: [[LOW1:%.+]] = vector.extract_strided_slice [[ARG1]] {offsets = [0, 0], sizes = [4, 1], strides = [1, 1]} : vector<4x2xi32> to vector<4x1xi32>120// CHECK-NEXT: [[HIGH1:%.+]] = vector.extract_strided_slice [[ARG1]] {offsets = [0, 1], sizes = [4, 1], strides = [1, 1]} : vector<4x2xi32> to vector<4x1xi32>121// CHECK-NEXT: [[SUM_L:%.+]], [[CB:%.+]] = arith.addui_extended [[LOW0]], [[LOW1]] : vector<4x1xi32>, vector<4x1xi1>122// CHECK-NEXT: [[CARRY:%.+]] = arith.extui [[CB]] : vector<4x1xi1> to vector<4x1xi32>123// CHECK-NEXT: [[SUM_H0:%.+]] = arith.addi [[CARRY]], [[HIGH0]] : vector<4x1xi32>124// CHECK-NEXT: [[SUM_H1:%.+]] = arith.addi [[SUM_H0]], [[HIGH1]] : vector<4x1xi32>125// CHECK: [[INS0:%.+]] = vector.insert_strided_slice [[SUM_L]], {{%.+}} {offsets = [0, 0], strides = [1, 1]} : vector<4x1xi32> into vector<4x2xi32>126// CHECK-NEXT: [[INS1:%.+]] = vector.insert_strided_slice [[SUM_H1]], [[INS0]] {offsets = [0, 1], strides = [1, 1]} : vector<4x1xi32> into vector<4x2xi32>127// CHECK-NEXT: return [[INS1]] : vector<4x2xi32>128func.func @addi_vector_a_b(%a : vector<4xi64>, %b : vector<4xi64>) -> vector<4xi64> {129 %x = arith.addi %a, %b : vector<4xi64>130 return %x : vector<4xi64>131}132 133// CHECK-LABEL: func @subi_scalar134// CHECK-SAME: ([[ARG0:%.+]]: vector<2xi32>, [[ARG1:%.+]]: vector<2xi32>) -> vector<2xi32>135// CHECK-NEXT: [[LOW0:%.+]] = vector.extract [[ARG0]][0] : i32 from vector<2xi32>136// CHECK-NEXT: [[HIGH0:%.+]] = vector.extract [[ARG0]][1] : i32 from vector<2xi32>137// CHECK-NEXT: [[LOW1:%.+]] = vector.extract [[ARG1]][0] : i32 from vector<2xi32>138// CHECK-NEXT: [[HIGH1:%.+]] = vector.extract [[ARG1]][1] : i32 from vector<2xi32>139// CHECK-NEXT: [[SUB_L:%.+]] = arith.subi [[LOW0]], [[LOW1]] : i32140// CHECK-NEXT: [[ULT:%.+]] = arith.cmpi ult, [[LOW0]], [[LOW1]] : i32141// CHECK-NEXT: [[CARRY:%.+]] = arith.extui [[ULT]] : i1 to i32142// CHECK-NEXT: [[SUB_H0:%.+]] = arith.subi [[HIGH0]], [[CARRY]] : i32143// CHECK-NEXT: [[SUB_H1:%.+]] = arith.subi [[SUB_H0]], [[HIGH1]] : i32144// CHECK: [[INS0:%.+]] = vector.insert [[SUB_L]], {{%.+}} [0] : i32 into vector<2xi32>145// CHECK-NEXT: [[INS1:%.+]] = vector.insert [[SUB_H1]], [[INS0]] [1] : i32 into vector<2xi32>146// CHECK-NEXT: return [[INS1]] : vector<2xi32>147func.func @subi_scalar(%a : i64, %b : i64) -> i64 {148 %x = arith.subi %a, %b : i64149 return %x : i64150}151 152// CHECK-LABEL: func @subi_vector153// CHECK-SAME: ([[ARG0:%.+]]: vector<4x2xi32>, [[ARG1:%.+]]: vector<4x2xi32>) -> vector<4x2xi32>154// CHECK-NEXT: [[LOW0:%.+]] = vector.extract_strided_slice [[ARG0]] {offsets = [0, 0], sizes = [4, 1], strides = [1, 1]} : vector<4x2xi32> to vector<4x1xi32>155// CHECK-NEXT: [[HIGH0:%.+]] = vector.extract_strided_slice [[ARG0]] {offsets = [0, 1], sizes = [4, 1], strides = [1, 1]} : vector<4x2xi32> to vector<4x1xi32>156// CHECK-NEXT: [[LOW1:%.+]] = vector.extract_strided_slice [[ARG1]] {offsets = [0, 0], sizes = [4, 1], strides = [1, 1]} : vector<4x2xi32> to vector<4x1xi32>157// CHECK-NEXT: [[HIGH1:%.+]] = vector.extract_strided_slice [[ARG1]] {offsets = [0, 1], sizes = [4, 1], strides = [1, 1]} : vector<4x2xi32> to vector<4x1xi32>158// CHECK-NEXT: [[SUB_L:%.+]] = arith.subi [[LOW0]], [[LOW1]] : vector<4x1xi32>159// CHECK-NEXT: [[ULT:%.+]] = arith.cmpi ult, [[LOW0]], [[LOW1]] : vector<4x1xi32>160// CHECK-NEXT: [[CARRY:%.+]] = arith.extui [[ULT]] : vector<4x1xi1> to vector<4x1xi32>161// CHECK-NEXT: [[SUB_H0:%.+]] = arith.subi [[HIGH0]], [[CARRY]] : vector<4x1xi32>162// CHECK-NEXT: [[SUB_H1:%.+]] = arith.subi [[SUB_H0]], [[HIGH1]] : vector<4x1xi32>163// CHECK: [[INS0:%.+]] = vector.insert_strided_slice [[SUB_L]], {{%.+}} {offsets = [0, 0], strides = [1, 1]} : vector<4x1xi32> into vector<4x2xi32>164// CHECK-NEXT: [[INS1:%.+]] = vector.insert_strided_slice [[SUB_H1]], [[INS0]] {offsets = [0, 1], strides = [1, 1]} : vector<4x1xi32> into vector<4x2xi32>165// CHECK-NEXT: return [[INS1]] : vector<4x2xi32>166func.func @subi_vector(%a : vector<4xi64>, %b : vector<4xi64>) -> vector<4xi64> {167 %x = arith.subi %a, %b : vector<4xi64>168 return %x : vector<4xi64>169}170 171// CHECK-LABEL: func.func @cmpi_eq_scalar172// CHECK-SAME: ([[LHS:%.+]]: vector<2xi32>, [[RHS:%.+]]: vector<2xi32>)173// CHECK-NEXT: [[LHSLOW:%.+]] = vector.extract [[LHS]][0] : i32 from vector<2xi32>174// CHECK-NEXT: [[LHSHIGH:%.+]] = vector.extract [[LHS]][1] : i32 from vector<2xi32>175// CHECK-NEXT: [[RHSLOW:%.+]] = vector.extract [[RHS]][0] : i32 from vector<2xi32>176// CHECK-NEXT: [[RHSHIGH:%.+]] = vector.extract [[RHS]][1] : i32 from vector<2xi32>177// CHECK-NEXT: [[CLOW:%.+]] = arith.cmpi eq, [[LHSLOW]], [[RHSLOW]] : i32178// CHECK-NEXT: [[CHIGH:%.+]] = arith.cmpi eq, [[LHSHIGH]], [[RHSHIGH]] : i32179// CHECK-NEXT: [[RES:%.+]] = arith.andi [[CLOW]], [[CHIGH]] : i1180// CHECK: return [[RES]] : i1181func.func @cmpi_eq_scalar(%a : i64, %b : i64) -> i1 {182 %r = arith.cmpi eq, %a, %b : i64183 return %r : i1184}185 186// CHECK-LABEL: func.func @cmpi_eq_vector187// CHECK-SAME: ([[ARG0:%.+]]: vector<3x2xi32>, [[ARG1:%.+]]: vector<3x2xi32>) -> vector<3xi1>188// CHECK-NEXT: [[LOW0:%.+]] = vector.extract_strided_slice [[ARG0]] {offsets = [0, 0], sizes = [3, 1], strides = [1, 1]} : vector<3x2xi32> to vector<3x1xi32>189// CHECK-NEXT: [[HIGH0:%.+]] = vector.extract_strided_slice [[ARG0]] {offsets = [0, 1], sizes = [3, 1], strides = [1, 1]} : vector<3x2xi32> to vector<3x1xi32>190// CHECK-NEXT: [[LOW1:%.+]] = vector.extract_strided_slice [[ARG1]] {offsets = [0, 0], sizes = [3, 1], strides = [1, 1]} : vector<3x2xi32> to vector<3x1xi32>191// CHECK-NEXT: [[HIGH1:%.+]] = vector.extract_strided_slice [[ARG1]] {offsets = [0, 1], sizes = [3, 1], strides = [1, 1]} : vector<3x2xi32> to vector<3x1xi32>192// CHECK-NEXT: [[CLOW:%.+]] = arith.cmpi eq, [[LOW0]], [[LOW1]] : vector<3x1xi32>193// CHECK-NEXT: [[CHIGH:%.+]] = arith.cmpi eq, [[HIGH0]], [[HIGH1]] : vector<3x1xi32>194// CHECK-NEXT: [[RES:%.+]] = arith.andi [[CLOW]], [[CHIGH]] : vector<3x1xi1>195// CHECK-NEXT: [[CAST:%.+]] = vector.shape_cast [[RES]] : vector<3x1xi1> to vector<3xi1>196// CHECK: return [[CAST]] : vector<3xi1>197func.func @cmpi_eq_vector(%a : vector<3xi64>, %b : vector<3xi64>) -> vector<3xi1> {198 %r = arith.cmpi eq, %a, %b : vector<3xi64>199 return %r : vector<3xi1>200}201 202// CHECK-LABEL: func.func @cmpi_ne_scalar203// CHECK-SAME: ([[LHS:%.+]]: vector<2xi32>, [[RHS:%.+]]: vector<2xi32>)204// CHECK-NEXT: [[LHSLOW:%.+]] = vector.extract [[LHS]][0] : i32 from vector<2xi32>205// CHECK-NEXT: [[LHSHIGH:%.+]] = vector.extract [[LHS]][1] : i32 from vector<2xi32>206// CHECK-NEXT: [[RHSLOW:%.+]] = vector.extract [[RHS]][0] : i32 from vector<2xi32>207// CHECK-NEXT: [[RHSHIGH:%.+]] = vector.extract [[RHS]][1] : i32 from vector<2xi32>208// CHECK-NEXT: [[CLOW:%.+]] = arith.cmpi ne, [[LHSLOW]], [[RHSLOW]] : i32209// CHECK-NEXT: [[CHIGH:%.+]] = arith.cmpi ne, [[LHSHIGH]], [[RHSHIGH]] : i32210// CHECK-NEXT: [[RES:%.+]] = arith.ori [[CLOW]], [[CHIGH]] : i1211// CHECK: return [[RES]] : i1212func.func @cmpi_ne_scalar(%a : i64, %b : i64) -> i1 {213 %r = arith.cmpi ne, %a, %b : i64214 return %r : i1215}216 217// CHECK-LABEL: func.func @cmpi_ne_vector218// CHECK-SAME: ([[ARG0:%.+]]: vector<3x2xi32>, [[ARG1:%.+]]: vector<3x2xi32>) -> vector<3xi1>219// CHECK: [[CLOW:%.+]] = arith.cmpi ne, {{%.+}}, {{%.+}} : vector<3x1xi32>220// CHECK-NEXT: [[CHIGH:%.+]] = arith.cmpi ne, {{%.+}}, {{%.+}} : vector<3x1xi32>221// CHECK-NEXT: [[RES:%.+]] = arith.ori [[CLOW]], [[CHIGH]] : vector<3x1xi1>222// CHECK-NEXT: [[CAST:%.+]] = vector.shape_cast [[RES]] : vector<3x1xi1> to vector<3xi1>223// CHECK: return [[CAST]] : vector<3xi1>224func.func @cmpi_ne_vector(%a : vector<3xi64>, %b : vector<3xi64>) -> vector<3xi1> {225 %r = arith.cmpi ne, %a, %b : vector<3xi64>226 return %r : vector<3xi1>227}228 229// CHECK-LABEL: func.func @cmpi_sge_scalar230// CHECK-SAME: ([[LHS:%.+]]: vector<2xi32>, [[RHS:%.+]]: vector<2xi32>)231// CHECK-NEXT: [[LHSLOW:%.+]] = vector.extract [[LHS]][0] : i32 from vector<2xi32>232// CHECK-NEXT: [[LHSHIGH:%.+]] = vector.extract [[LHS]][1] : i32 from vector<2xi32>233// CHECK-NEXT: [[RHSLOW:%.+]] = vector.extract [[RHS]][0] : i32 from vector<2xi32>234// CHECK-NEXT: [[RHSHIGH:%.+]] = vector.extract [[RHS]][1] : i32 from vector<2xi32>235// CHECK-NEXT: [[CLOW:%.+]] = arith.cmpi uge, [[LHSLOW]], [[RHSLOW]] : i32236// CHECK-NEXT: [[CHIGH:%.+]] = arith.cmpi sge, [[LHSHIGH]], [[RHSHIGH]] : i32237// CHECK-NEXT: [[HIGHEQ:%.+]] = arith.cmpi eq, [[LHSHIGH]], [[RHSHIGH]] : i32238// CHECK-NEXT: [[RES:%.+]] = arith.select [[HIGHEQ]], [[CLOW]], [[CHIGH]] : i1239// CHECK: return [[RES]] : i1240func.func @cmpi_sge_scalar(%a : i64, %b : i64) -> i1 {241 %r = arith.cmpi sge, %a, %b : i64242 return %r : i1243}244 245// CHECK-LABEL: func.func @cmpi_sge_vector246// CHECK-SAME: ([[ARG0:%.+]]: vector<3x2xi32>, [[ARG1:%.+]]: vector<3x2xi32>) -> vector<3xi1>247// CHECK: [[CLOW:%.+]] = arith.cmpi uge, {{%.+}}, {{%.+}} : vector<3x1xi32>248// CHECK: [[CHIGH:%.+]] = arith.cmpi sge, {{%.+}}, {{%.+}} : vector<3x1xi32>249// CHECK-NEXT: [[HIGHEQ:%.+]] = arith.cmpi eq, {{%.+}}, {{%.+}} : vector<3x1xi32>250// CHECK-NEXT: [[RES:%.+]] = arith.select [[HIGHEQ]], [[CLOW]], [[CHIGH]] : vector<3x1xi1>251// CHECK-NEXT: [[CAST:%.+]] = vector.shape_cast [[RES]] : vector<3x1xi1> to vector<3xi1>252// CHECK: return [[CAST]] : vector<3xi1>253func.func @cmpi_sge_vector(%a : vector<3xi64>, %b : vector<3xi64>) -> vector<3xi1> {254 %r = arith.cmpi sge, %a, %b : vector<3xi64>255 return %r : vector<3xi1>256}257 258// CHECK-LABEL: func.func @cmpi_sgt_scalar259// CHECK-SAME: ([[LHS:%.+]]: vector<2xi32>, [[RHS:%.+]]: vector<2xi32>)260// CHECK: [[CLOW:%.+]] = arith.cmpi ugt, {{%.+}}, {{%.+}} : i32261// CHECK-NEXT: [[CHIGH:%.+]] = arith.cmpi sgt, [[LHSHIGH:%.+]], [[RHSHIGH:%.+]] : i32262// CHECK-NEXT: [[HIGHEQ:%.+]] = arith.cmpi eq, [[LHSHIGH]], [[RHSHIGH]] : i32263// CHECK-NEXT: [[RES:%.+]] = arith.select [[HIGHEQ]], [[CLOW]], [[CHIGH]] : i1264// CHECK: return [[RES]] : i1265func.func @cmpi_sgt_scalar(%a : i64, %b : i64) -> i1 {266 %r = arith.cmpi sgt, %a, %b : i64267 return %r : i1268}269 270// CHECK-LABEL: func.func @cmpi_sle_scalar271// CHECK-SAME: ([[LHS:%.+]]: vector<2xi32>, [[RHS:%.+]]: vector<2xi32>)272// CHECK: [[CLOW:%.+]] = arith.cmpi ule, {{%.+}}, {{%.+}} : i32273// CHECK-NEXT: [[CHIGH:%.+]] = arith.cmpi sle, [[LHSHIGH:%.+]], [[RHSHIGH:%.+]] : i32274// CHECK-NEXT: [[HIGHEQ:%.+]] = arith.cmpi eq, [[LHSHIGH]], [[RHSHIGH]] : i32275// CHECK-NEXT: [[RES:%.+]] = arith.select [[HIGHEQ]], [[CLOW]], [[CHIGH]] : i1276// CHECK: return [[RES]] : i1277func.func @cmpi_sle_scalar(%a : i64, %b : i64) -> i1 {278 %r = arith.cmpi sle, %a, %b : i64279 return %r : i1280}281 282// CHECK-LABEL: func.func @cmpi_slt_scalar283// CHECK-SAME: ([[LHS:%.+]]: vector<2xi32>, [[RHS:%.+]]: vector<2xi32>)284// CHECK: [[CLOW:%.+]] = arith.cmpi ult, {{%.+}}, {{%.+}} : i32285// CHECK-NEXT: [[CHIGH:%.+]] = arith.cmpi slt, [[LHSHIGH:%.+]], [[RHSHIGH:%.+]] : i32286// CHECK-NEXT: [[HIGHEQ:%.+]] = arith.cmpi eq, [[LHSHIGH]], [[RHSHIGH]] : i32287// CHECK-NEXT: [[RES:%.+]] = arith.select [[HIGHEQ]], [[CLOW]], [[CHIGH]] : i1288// CHECK: return [[RES]] : i1289func.func @cmpi_slt_scalar(%a : i64, %b : i64) -> i1 {290 %r = arith.cmpi slt, %a, %b : i64291 return %r : i1292}293 294// CHECK-LABEL: func.func @cmpi_uge_scalar295// CHECK-SAME: ([[LHS:%.+]]: vector<2xi32>, [[RHS:%.+]]: vector<2xi32>)296// CHECK: [[CLOW:%.+]] = arith.cmpi uge, {{%.+}}, {{%.+}} : i32297// CHECK-NEXT: [[CHIGH:%.+]] = arith.cmpi uge, [[LHSHIGH:%.+]], [[RHSHIGH:%.+]] : i32298// CHECK-NEXT: [[HIGHEQ:%.+]] = arith.cmpi eq, [[LHSHIGH]], [[RHSHIGH]] : i32299// CHECK-NEXT: [[RES:%.+]] = arith.select [[HIGHEQ]], [[CLOW]], [[CHIGH]] : i1300// CHECK: return [[RES]] : i1301func.func @cmpi_uge_scalar(%a : i64, %b : i64) -> i1 {302 %r = arith.cmpi uge, %a, %b : i64303 return %r : i1304}305 306// CHECK-LABEL: func.func @cmpi_ugt_scalar307// CHECK-SAME: ([[LHS:%.+]]: vector<2xi32>, [[RHS:%.+]]: vector<2xi32>)308// CHECK: [[CLOW:%.+]] = arith.cmpi ugt, {{%.+}}, {{%.+}} : i32309// CHECK-NEXT: [[CHIGH:%.+]] = arith.cmpi ugt, [[LHSHIGH:%.+]], [[RHSHIGH:%.+]] : i32310// CHECK-NEXT: [[HIGHEQ:%.+]] = arith.cmpi eq, [[LHSHIGH]], [[RHSHIGH]] : i32311// CHECK-NEXT: [[RES:%.+]] = arith.select [[HIGHEQ]], [[CLOW]], [[CHIGH]] : i1312// CHECK: return [[RES]] : i1313func.func @cmpi_ugt_scalar(%a : i64, %b : i64) -> i1 {314 %r = arith.cmpi ugt, %a, %b : i64315 return %r : i1316}317 318// CHECK-LABEL: func.func @cmpi_ule_scalar319// CHECK-SAME: ([[LHS:%.+]]: vector<2xi32>, [[RHS:%.+]]: vector<2xi32>)320// CHECK: [[CLOW:%.+]] = arith.cmpi ule, {{%.+}}, {{%.+}} : i32321// CHECK-NEXT: [[CHIGH:%.+]] = arith.cmpi ule, [[LHSHIGH:%.+]], [[RHSHIGH:%.+]] : i32322// CHECK-NEXT: [[HIGHEQ:%.+]] = arith.cmpi eq, [[LHSHIGH]], [[RHSHIGH]] : i32323// CHECK-NEXT: [[RES:%.+]] = arith.select [[HIGHEQ]], [[CLOW]], [[CHIGH]] : i1324// CHECK: return [[RES]] : i1325func.func @cmpi_ule_scalar(%a : i64, %b : i64) -> i1 {326 %r = arith.cmpi ule, %a, %b : i64327 return %r : i1328}329 330// CHECK-LABEL: func.func @cmpi_ult_scalar331// CHECK-SAME: ([[LHS:%.+]]: vector<2xi32>, [[RHS:%.+]]: vector<2xi32>)332// CHECK: [[CLOW:%.+]] = arith.cmpi ult, {{%.+}}, {{%.+}} : i32333// CHECK-NEXT: [[CHIGH:%.+]] = arith.cmpi ult, [[LHSHIGH:%.+]], [[RHSHIGH:%.+]] : i32334// CHECK-NEXT: [[HIGHEQ:%.+]] = arith.cmpi eq, [[LHSHIGH]], [[RHSHIGH]] : i32335// CHECK-NEXT: [[RES:%.+]] = arith.select [[HIGHEQ]], [[CLOW]], [[CHIGH]] : i1336// CHECK: return [[RES]] : i1337func.func @cmpi_ult_scalar(%a : i64, %b : i64) -> i1 {338 %r = arith.cmpi ult, %a, %b : i64339 return %r : i1340}341 342// CHECK-LABEL: func @extsi_scalar343// CHECK-SAME: ([[ARG:%.+]]: i16) -> vector<2xi32>344// CHECK-NEXT: [[EXT:%.+]] = arith.extsi [[ARG]] : i16 to i32345// CHECK-NEXT: [[SZ:%.+]] = arith.constant 0 : i32346// CHECK-NEXT: [[SB:%.+]] = arith.cmpi slt, [[EXT]], [[SZ]] : i32347// CHECK-NEXT: [[SV:%.+]] = arith.extsi [[SB]] : i1 to i32348// CHECK-NEXT: [[VZ:%.+]] = arith.constant dense<0> : vector<2xi32>349// CHECK-NEXT: [[INS0:%.+]] = vector.insert [[EXT]], [[VZ]] [0] : i32 into vector<2xi32>350// CHECK-NEXT: [[INS1:%.+]] = vector.insert [[SV]], [[INS0]] [1] : i32 into vector<2xi32>351// CHECK: return [[INS1]] : vector<2xi32>352func.func @extsi_scalar(%a : i16) -> i64 {353 %r = arith.extsi %a : i16 to i64354 return %r : i64355}356 357// CHECK-LABEL: func @extsi_vector358// CHECK-SAME: ([[ARG:%.+]]: vector<3xi16>) -> vector<3x2xi32>359// CHECK-NEXT: [[SHAPE:%.+]] = vector.shape_cast [[ARG]] : vector<3xi16> to vector<3x1xi16>360// CHECK-NEXT: [[EXT:%.+]] = arith.extsi [[SHAPE]] : vector<3x1xi16> to vector<3x1xi32>361// CHECK-NEXT: [[CSTE:%.+]] = arith.constant dense<0> : vector<3x1xi32>362// CHECK-NEXT: [[CMP:%.+]] = arith.cmpi slt, [[EXT]], [[CSTE]] : vector<3x1xi32>363// CHECK-NEXT: [[HIGH:%.+]] = arith.extsi [[CMP]] : vector<3x1xi1> to vector<3x1xi32>364// CHECK-NEXT: [[CSTZ:%.+]] = arith.constant dense<0> : vector<3x2xi32>365// CHECK-NEXT: [[INS0:%.+]] = vector.insert_strided_slice [[EXT]], [[CSTZ]] {offsets = [0, 0], strides = [1, 1]} : vector<3x1xi32> into vector<3x2xi32>366// CHECK-NEXT: [[INS1:%.+]] = vector.insert_strided_slice [[HIGH]], [[INS0]] {offsets = [0, 1], strides = [1, 1]} : vector<3x1xi32> into vector<3x2xi32>367// CHECK-NEXT: return [[INS1]] : vector<3x2xi32>368func.func @extsi_vector(%a : vector<3xi16>) -> vector<3xi64> {369 %r = arith.extsi %a : vector<3xi16> to vector<3xi64>370 return %r : vector<3xi64>371}372 373// CHECK-LABEL: func @extui_scalar1374// CHECK-SAME: ([[ARG:%.+]]: i16) -> vector<2xi32>375// CHECK-NEXT: [[EXT:%.+]] = arith.extui [[ARG]] : i16 to i32376// CHECK-NEXT: [[VZ:%.+]] = arith.constant dense<0> : vector<2xi32>377// CHECK-NEXT: [[INS0:%.+]] = vector.insert [[EXT]], [[VZ]] [0] : i32 into vector<2xi32>378// CHECK: return [[INS0]] : vector<2xi32>379func.func @extui_scalar1(%a : i16) -> i64 {380 %r = arith.extui %a : i16 to i64381 return %r : i64382}383 384// CHECK-LABEL: func @extui_scalar2385// CHECK-SAME: ([[ARG:%.+]]: i32) -> vector<2xi32>386// CHECK-NEXT: [[VZ:%.+]] = arith.constant dense<0> : vector<2xi32>387// CHECK-NEXT: [[INS0:%.+]] = vector.insert [[ARG]], [[VZ]] [0] : i32 into vector<2xi32>388// CHECK: return [[INS0]] : vector<2xi32>389func.func @extui_scalar2(%a : i32) -> i64 {390 %r = arith.extui %a : i32 to i64391 return %r : i64392}393 394// CHECK-LABEL: func @extui_vector395// CHECK-SAME: ([[ARG:%.+]]: vector<3xi16>) -> vector<3x2xi32>396// CHECK-NEXT: [[SHAPE:%.+]] = vector.shape_cast [[ARG]] : vector<3xi16> to vector<3x1xi16>397// CHECK-NEXT: [[EXT:%.+]] = arith.extui [[SHAPE]] : vector<3x1xi16> to vector<3x1xi32>398// CHECK-NEXT: [[CST:%.+]] = arith.constant dense<0> : vector<3x2xi32>399// CHECK-NEXT: [[INS0:%.+]] = vector.insert_strided_slice [[EXT]], [[CST]] {offsets = [0, 0], strides = [1, 1]} : vector<3x1xi32> into vector<3x2xi32>400// CHECK: return [[INS0]] : vector<3x2xi32>401func.func @extui_vector(%a : vector<3xi16>) -> vector<3xi64> {402 %r = arith.extui %a : vector<3xi16> to vector<3xi64>403 return %r : vector<3xi64>404}405 406// CHECK-LABEL: func @index_cast_int_to_index_scalar407// CHECK-SAME: ([[ARG:%.+]]: vector<2xi32>) -> index408// CHECK-NEXT: [[EXT:%.+]] = vector.extract [[ARG]][0] : i32 from vector<2xi32>409// CHECK-NEXT: [[RES:%.+]] = arith.index_cast [[EXT]] : i32 to index410// CHECK-NEXT: return [[RES]] : index411func.func @index_cast_int_to_index_scalar(%a : i64) -> index {412 %r = arith.index_cast %a : i64 to index413 return %r : index414}415 416// CHECK-LABEL: func @index_cast_int_to_index_vector417// CHECK-SAME: ([[ARG:%.+]]: vector<3x2xi32>) -> vector<3xindex>418// CHECK-NEXT: [[EXT:%.+]] = vector.extract_strided_slice [[ARG]] {offsets = [0, 0], sizes = [3, 1], strides = [1, 1]} : vector<3x2xi32> to vector<3x1xi32>419// CHECK-NEXT: [[SHAPE:%.+]] = vector.shape_cast [[EXT]] : vector<3x1xi32> to vector<3xi32>420// CHECK-NEXT: [[RES:%.+]] = arith.index_cast [[SHAPE]] : vector<3xi32> to vector<3xindex>421// CHECK-NEXT: return [[RES]] : vector<3xindex>422func.func @index_cast_int_to_index_vector(%a : vector<3xi64>) -> vector<3xindex> {423 %r = arith.index_cast %a : vector<3xi64> to vector<3xindex>424 return %r : vector<3xindex>425}426 427// CHECK-LABEL: func @index_castui_int_to_index_scalar428// CHECK-SAME: ([[ARG:%.+]]: vector<2xi32>) -> index429// CHECK-NEXT: [[EXT:%.+]] = vector.extract [[ARG]][0] : i32 from vector<2xi32>430// CHECK-NEXT: [[RES:%.+]] = arith.index_castui [[EXT]] : i32 to index431// CHECK-NEXT: return [[RES]] : index432func.func @index_castui_int_to_index_scalar(%a : i64) -> index {433 %r = arith.index_castui %a : i64 to index434 return %r : index435}436 437// CHECK-LABEL: func @index_castui_int_to_index_vector438// CHECK-SAME: ([[ARG:%.+]]: vector<3x2xi32>) -> vector<3xindex>439// CHECK-NEXT: [[EXT:%.+]] = vector.extract_strided_slice [[ARG]] {offsets = [0, 0], sizes = [3, 1], strides = [1, 1]} : vector<3x2xi32> to vector<3x1xi32>440// CHECK-NEXT: [[SHAPE:%.+]] = vector.shape_cast [[EXT]] : vector<3x1xi32> to vector<3xi32>441// CHECK-NEXT: [[RES:%.+]] = arith.index_castui [[SHAPE]] : vector<3xi32> to vector<3xindex>442// CHECK-NEXT: return [[RES]] : vector<3xindex>443func.func @index_castui_int_to_index_vector(%a : vector<3xi64>) -> vector<3xindex> {444 %r = arith.index_castui %a : vector<3xi64> to vector<3xindex>445 return %r : vector<3xindex>446}447 448// CHECK-LABEL: func @index_cast_index_to_int_scalar449// CHECK-SAME: ([[ARG:%.+]]: index) -> vector<2xi32>450// CHECK-NEXT: [[CAST:%.+]] = arith.index_cast [[ARG]] : index to i32451// CHECK-NEXT: [[C0I32:%.+]] = arith.constant 0 : i32452// CHECK-NEXT: [[NEG:%.+]] = arith.cmpi slt, [[CAST]], [[C0I32]] : i32453// CHECK-NEXT: [[EXT:%.+]] = arith.extsi [[NEG]] : i1 to i32454// CHECK-NEXT: [[VZ:%.+]] = arith.constant dense<0> : vector<2xi32>455// CHECK-NEXT: [[INS0:%.+]] = vector.insert [[CAST]], [[VZ]] [0] : i32 into vector<2xi32>456// CHECK-NEXT: [[INS1:%.+]] = vector.insert [[EXT]], [[INS0]] [1] : i32 into vector<2xi32>457// CHECK-NEXT: return [[INS1]] : vector<2xi32>458func.func @index_cast_index_to_int_scalar(%a : index) -> i64 {459 %r = arith.index_cast %a : index to i64460 return %r : i64461}462 463// CHECK-LABEL: func @index_cast_index_to_int_vector464// CHECK-SAME: ([[ARG:%.+]]: vector<3xindex>) -> vector<3x2xi32>465// CHECK-NEXT: arith.index_cast [[ARG]] : vector<3xindex> to vector<3xi32>466// CHECK-NEXT: vector.shape_cast467// CHECK-NEXT: arith.constant dense<0> : vector<3x1xi32>468// CHECK-NEXT: arith.cmpi slt469// CHECK-NEXT: arith.extsi470// CHECK-NEXT: arith.constant dense<0> : vector<3x2xi32>471// CHECK-NEXT: vector.insert_strided_slice472// CHECK-NEXT: vector.insert_strided_slice473// CHECK-NEXT: return {{%.+}} : vector<3x2xi32>474func.func @index_cast_index_to_int_vector(%a : vector<3xindex>) -> vector<3xi64> {475 %r = arith.index_cast %a : vector<3xindex> to vector<3xi64>476 return %r : vector<3xi64>477}478 479// CHECK-LABEL: func @index_castui_index_to_int_scalar480// CHECK-SAME: ([[ARG:%.+]]: index) -> vector<2xi32>481// CHECK-NEXT: [[CAST:%.+]] = arith.index_castui [[ARG]] : index to i32482// CHECK-NEXT: [[VZ:%.+]] = arith.constant dense<0> : vector<2xi32>483// CHECK-NEXT: [[RES:%.+]] = vector.insert [[CAST]], [[VZ]] [0] : i32 into vector<2xi32>484// CHECK-NEXT: return [[RES]] : vector<2xi32>485func.func @index_castui_index_to_int_scalar(%a : index) -> i64 {486 %r = arith.index_castui %a : index to i64487 return %r : i64488}489 490// CHECK-LABEL: func @index_castui_index_to_int_vector491// CHECK-SAME: ([[ARG:%.+]]: vector<3xindex>) -> vector<3x2xi32>492// CHECK-NEXT: [[CAST:%.+]] = arith.index_castui [[ARG]] : vector<3xindex> to vector<3xi32>493// CHECK-NEXT: [[SHAPE:%.+]] = vector.shape_cast [[CAST]] : vector<3xi32> to vector<3x1xi32>494// CHECK-NEXT: [[CST:%.+]] = arith.constant dense<0> : vector<3x2xi32>495// CHECK-NEXT: [[RES:%.+]] = vector.insert_strided_slice [[SHAPE]], [[CST]] {offsets = [0, 0], strides = [1, 1]} : vector<3x1xi32> into vector<3x2xi32>496// CHECK-NEXT: return [[RES]] : vector<3x2xi32>497func.func @index_castui_index_to_int_vector(%a : vector<3xindex>) -> vector<3xi64> {498 %r = arith.index_castui %a : vector<3xindex> to vector<3xi64>499 return %r : vector<3xi64>500}501 502// CHECK-LABEL: func @trunci_scalar1503// CHECK-SAME: ([[ARG:%.+]]: vector<2xi32>) -> i32504// CHECK-NEXT: [[EXT:%.+]] = vector.extract [[ARG]][0] : i32 from vector<2xi32>505// CHECK-NEXT: return [[EXT]] : i32506func.func @trunci_scalar1(%a : i64) -> i32 {507 %b = arith.trunci %a : i64 to i32508 return %b : i32509}510 511// CHECK-LABEL: func @trunci_scalar2512// CHECK-SAME: ([[ARG:%.+]]: vector<2xi32>) -> i16513// CHECK-NEXT: [[EXTR:%.+]] = vector.extract [[ARG]][0] : i32 from vector<2xi32>514// CHECK-NEXT: [[TRNC:%.+]] = arith.trunci [[EXTR]] : i32 to i16515// CHECK-NEXT: return [[TRNC]] : i16516func.func @trunci_scalar2(%a : i64) -> i16 {517 %b = arith.trunci %a : i64 to i16518 return %b : i16519}520 521// CHECK-LABEL: func @trunci_vector522// CHECK-SAME: ([[ARG:%.+]]: vector<3x2xi32>) -> vector<3xi16>523// CHECK-NEXT: [[EXTR:%.+]] = vector.extract_strided_slice [[ARG]] {offsets = [0, 0], sizes = [3, 1], strides = [1, 1]} : vector<3x2xi32> to vector<3x1xi32>524// CHECK-NEXT: [[SHAPE:%.+]] = vector.shape_cast [[EXTR]] : vector<3x1xi32> to vector<3xi32>525// CHECK-NEXT: [[TRNC:%.+]] = arith.trunci [[SHAPE]] : vector<3xi32> to vector<3xi16>526// CHECK-NEXT: return [[TRNC]] : vector<3xi16>527func.func @trunci_vector(%a : vector<3xi64>) -> vector<3xi16> {528 %b = arith.trunci %a : vector<3xi64> to vector<3xi16>529 return %b : vector<3xi16>530}531 532// CHECK-LABEL: func @maxui_scalar533// CHECK-SAME: ([[ARG0:%.+]]: vector<2xi32>, [[ARG1:%.+]]: vector<2xi32>) -> vector<2xi32>534// CHECK-NEXT: vector.extract [[ARG0]][0] : i32 from vector<2xi32>535// CHECK-NEXT: vector.extract [[ARG0]][1] : i32 from vector<2xi32>536// CHECK-NEXT: vector.extract [[ARG1]][0] : i32 from vector<2xi32>537// CHECK-NEXT: vector.extract [[ARG1]][1] : i32 from vector<2xi32>538// CHECK: arith.cmpi ugt539// CHECK: arith.cmpi ugt540// CHECK: arith.cmpi eq541// CHECK: arith.select542// CHECK: arith.select543// CHECK: [[INS0:%.+]] = vector.insert {{%.+}}, {{%.+}} [0] : i32 into vector<2xi32>544// CHECK-NEXT: [[INS1:%.+]] = vector.insert {{%.+}}, [[INS0]] [1] : i32 into vector<2xi32>545// CHECK-NEXT: return [[INS1]] : vector<2xi32>546func.func @maxui_scalar(%a : i64, %b : i64) -> i64 {547 %x = arith.maxui %a, %b : i64548 return %x : i64549}550 551// CHECK-LABEL: func @maxui_vector552// CHECK-SAME: ([[ARG0:%.+]]: vector<3x2xi32>, [[ARG1:%.+]]: vector<3x2xi32>) -> vector<3x2xi32>553// CHECK: arith.cmpi ugt554// CHECK: arith.cmpi ugt555// CHECK: arith.cmpi eq556// CHECK: arith.select557// CHECK: arith.select558// CHECK: return {{.+}} : vector<3x2xi32>559func.func @maxui_vector(%a : vector<3xi64>, %b : vector<3xi64>) -> vector<3xi64> {560 %x = arith.maxui %a, %b : vector<3xi64>561 return %x : vector<3xi64>562}563 564// CHECK-LABEL: func @maxsi_scalar565// CHECK-SAME: ([[ARG0:%.+]]: vector<2xi32>, [[ARG1:%.+]]: vector<2xi32>) -> vector<2xi32>566// CHECK-NEXT: vector.extract [[ARG0]][0] : i32 from vector<2xi32>567// CHECK-NEXT: vector.extract [[ARG0]][1] : i32 from vector<2xi32>568// CHECK-NEXT: vector.extract [[ARG1]][0] : i32 from vector<2xi32>569// CHECK-NEXT: vector.extract [[ARG1]][1] : i32 from vector<2xi32>570// CHECK: arith.cmpi ugt571// CHECK: arith.cmpi sgt572// CHECK: arith.cmpi eq573// CHECK: arith.select574// CHECK: arith.select575// CHECK: [[INS0:%.+]] = vector.insert {{%.+}}, {{%.+}} [0] : i32 into vector<2xi32>576// CHECK-NEXT: [[INS1:%.+]] = vector.insert {{%.+}}, [[INS0]] [1] : i32 into vector<2xi32>577// CHECK-NEXT: return [[INS1]] : vector<2xi32>578func.func @maxsi_scalar(%a : i64, %b : i64) -> i64 {579 %x = arith.maxsi %a, %b : i64580 return %x : i64581}582 583// CHECK-LABEL: func @maxsi_vector584// CHECK-SAME: ([[ARG0:%.+]]: vector<3x2xi32>, [[ARG1:%.+]]: vector<3x2xi32>) -> vector<3x2xi32>585// CHECK: arith.cmpi ugt586// CHECK: arith.cmpi sgt587// CHECK: arith.cmpi eq588// CHECK: arith.select589// CHECK: arith.select590// CHECK: return {{.+}} : vector<3x2xi32>591func.func @maxsi_vector(%a : vector<3xi64>, %b : vector<3xi64>) -> vector<3xi64> {592 %x = arith.maxsi %a, %b : vector<3xi64>593 return %x : vector<3xi64>594}595 596// CHECK-LABEL: func @minui_scalar597// CHECK-SAME: ([[ARG0:%.+]]: vector<2xi32>, [[ARG1:%.+]]: vector<2xi32>) -> vector<2xi32>598// CHECK-NEXT: vector.extract [[ARG0]][0] : i32 from vector<2xi32>599// CHECK-NEXT: vector.extract [[ARG0]][1] : i32 from vector<2xi32>600// CHECK-NEXT: vector.extract [[ARG1]][0] : i32 from vector<2xi32>601// CHECK-NEXT: vector.extract [[ARG1]][1] : i32 from vector<2xi32>602// CHECK: arith.cmpi ult603// CHECK: arith.cmpi ult604// CHECK: arith.cmpi eq605// CHECK: arith.select606// CHECK: arith.select607// CHECK: [[INS0:%.+]] = vector.insert {{%.+}}, {{%.+}} [0] : i32 into vector<2xi32>608// CHECK-NEXT: [[INS1:%.+]] = vector.insert {{%.+}}, [[INS0]] [1] : i32 into vector<2xi32>609// CHECK-NEXT: return [[INS1]] : vector<2xi32>610func.func @minui_scalar(%a : i64, %b : i64) -> i64 {611 %x = arith.minui %a, %b : i64612 return %x : i64613}614 615// CHECK-LABEL: func @minui_vector616// CHECK-SAME: ([[ARG0:%.+]]: vector<3x2xi32>, [[ARG1:%.+]]: vector<3x2xi32>) -> vector<3x2xi32>617// CHECK: arith.cmpi ult618// CHECK: arith.cmpi ult619// CHECK: arith.cmpi eq620// CHECK: arith.select621// CHECK: arith.select622// CHECK: return {{.+}} : vector<3x2xi32>623func.func @minui_vector(%a : vector<3xi64>, %b : vector<3xi64>) -> vector<3xi64> {624 %x = arith.minui %a, %b : vector<3xi64>625 return %x : vector<3xi64>626}627 628// CHECK-LABEL: func @minsi_scalar629// CHECK-SAME: ([[ARG0:%.+]]: vector<2xi32>, [[ARG1:%.+]]: vector<2xi32>) -> vector<2xi32>630// CHECK-NEXT: vector.extract [[ARG0]][0] : i32 from vector<2xi32>631// CHECK-NEXT: vector.extract [[ARG0]][1] : i32 from vector<2xi32>632// CHECK-NEXT: vector.extract [[ARG1]][0] : i32 from vector<2xi32>633// CHECK-NEXT: vector.extract [[ARG1]][1] : i32 from vector<2xi32>634// CHECK: arith.cmpi ult635// CHECK: arith.cmpi slt636// CHECK: arith.cmpi eq637// CHECK: arith.select638// CHECK: arith.select639// CHECK: [[INS0:%.+]] = vector.insert {{%.+}}, {{%.+}} [0] : i32 into vector<2xi32>640// CHECK-NEXT: [[INS1:%.+]] = vector.insert {{%.+}}, [[INS0]] [1] : i32 into vector<2xi32>641// CHECK-NEXT: return [[INS1]] : vector<2xi32>642func.func @minsi_scalar(%a : i64, %b : i64) -> i64 {643 %x = arith.minsi %a, %b : i64644 return %x : i64645}646 647// CHECK-LABEL: func @minsi_vector648// CHECK-SAME: ([[ARG0:%.+]]: vector<3x2xi32>, [[ARG1:%.+]]: vector<3x2xi32>) -> vector<3x2xi32>649// CHECK: arith.cmpi ult650// CHECK: arith.cmpi slt651// CHECK: arith.cmpi eq652// CHECK: arith.select653// CHECK: arith.select654// CHECK: return {{.+}} : vector<3x2xi32>655func.func @minsi_vector(%a : vector<3xi64>, %b : vector<3xi64>) -> vector<3xi64> {656 %x = arith.minsi %a, %b : vector<3xi64>657 return %x : vector<3xi64>658}659 660// CHECK-LABEL: func.func @select_scalar661// CHECK-SAME: ([[ARG0:%.+]]: vector<2xi32>, [[ARG1:%.+]]: vector<2xi32>, [[ARG2:%.+]]: i1)662// CHECK-SAME: -> vector<2xi32>663// CHECK-NEXT: [[TLOW:%.+]] = vector.extract [[ARG0]][0] : i32 from vector<2xi32>664// CHECK-NEXT: [[THIGH:%.+]] = vector.extract [[ARG0]][1] : i32 from vector<2xi32>665// CHECK-NEXT: [[FLOW:%.+]] = vector.extract [[ARG1]][0] : i32 from vector<2xi32>666// CHECK-NEXT: [[FHIGH:%.+]] = vector.extract [[ARG1]][1] : i32 from vector<2xi32>667// CHECK-NEXT: [[SLOW:%.+]] = arith.select [[ARG2]], [[TLOW]], [[FLOW]] : i32668// CHECK-NEXT: [[SHIGH:%.+]] = arith.select [[ARG2]], [[THIGH]], [[FHIGH]] : i32669// CHECK-NEXT: [[VZ:%.+]] = arith.constant dense<0> : vector<2xi32>670// CHECK-NEXT: [[INS0:%.+]] = vector.insert [[SLOW]], [[VZ]] [0] : i32 into vector<2xi32>671// CHECK-NEXT: [[INS1:%.+]] = vector.insert [[SHIGH]], [[INS0]] [1] : i32 into vector<2xi32>672// CHECK: return [[INS1]] : vector<2xi32>673func.func @select_scalar(%a : i64, %b : i64, %c : i1) -> i64 {674 %r = arith.select %c, %a, %b : i64675 return %r : i64676}677 678// CHECK-LABEL: func.func @select_vector_whole679// CHECK-SAME: ([[ARG0:%.+]]: vector<3x2xi32>, [[ARG1:%.+]]: vector<3x2xi32>, [[ARG2:%.+]]: i1)680// CHECK-SAME: -> vector<3x2xi32>681// CHECK: arith.select {{%.+}}, {{%.+}}, {{%.+}} : vector<3x1xi32>682// CHECK-NEXT: arith.select {{%.+}}, {{%.+}}, {{%.+}} : vector<3x1xi32>683// CHECK: return {{%.+}} : vector<3x2xi32>684func.func @select_vector_whole(%a : vector<3xi64>, %b : vector<3xi64>, %c : i1) -> vector<3xi64> {685 %r = arith.select %c, %a, %b : vector<3xi64>686 return %r : vector<3xi64>687}688 689// CHECK-LABEL: func.func @select_vector_elementwise690// CHECK-SAME: ([[ARG0:%.+]]: vector<3x2xi32>, [[ARG1:%.+]]: vector<3x2xi32>, [[ARG2:%.+]]: vector<3xi1>)691// CHECK-SAME: -> vector<3x2xi32>692// CHECK: arith.select {{%.+}}, {{%.+}}, {{%.+}} : vector<3x1xi1>, vector<3x1xi32>693// CHECK-NEXT: arith.select {{%.+}}, {{%.+}}, {{%.+}} : vector<3x1xi1>, vector<3x1xi32>694// CHECK: return {{%.+}} : vector<3x2xi32>695func.func @select_vector_elementwise(%a : vector<3xi64>, %b : vector<3xi64>, %c : vector<3xi1>) -> vector<3xi64> {696 %r = arith.select %c, %a, %b : vector<3xi1>, vector<3xi64>697 return %r : vector<3xi64>698}699 700// CHECK-LABEL: func.func @muli_scalar701// CHECK-SAME: ([[ARG0:%.+]]: vector<2xi32>, [[ARG1:%.+]]: vector<2xi32>) -> vector<2xi32>702// CHECK-NEXT: [[LOW0:%.+]] = vector.extract [[ARG0]][0] : i32 from vector<2xi32>703// CHECK-NEXT: [[HIGH0:%.+]] = vector.extract [[ARG0]][1] : i32 from vector<2xi32>704// CHECK-NEXT: [[LOW1:%.+]] = vector.extract [[ARG1]][0] : i32 from vector<2xi32>705// CHECK-NEXT: [[HIGH1:%.+]] = vector.extract [[ARG1]][1] : i32 from vector<2xi32>706//707// CHECK-DAG: [[RESLOW:%.+]], [[HI0:%.+]] = arith.mului_extended [[LOW0]], [[LOW1]] : i32708// CHECK-DAG: [[HI1:%.+]] = arith.muli [[LOW0]], [[HIGH1]] : i32709// CHECK-DAG: [[HI2:%.+]] = arith.muli [[HIGH0]], [[LOW1]] : i32710// CHECK-NEXT: [[RESHI1:%.+]] = arith.addi [[HI0]], [[HI1]] : i32711// CHECK-NEXT: [[RESHI2:%.+]] = arith.addi [[RESHI1]], [[HI2]] : i32712//713// CHECK-NEXT: [[VZ:%.+]] = arith.constant dense<0> : vector<2xi32>714// CHECK-NEXT: [[INS0:%.+]] = vector.insert [[RESLOW]], [[VZ]] [0] : i32 into vector<2xi32>715// CHECK-NEXT: [[INS1:%.+]] = vector.insert [[RESHI2]], [[INS0]] [1] : i32 into vector<2xi32>716// CHECK-NEXT: return [[INS1]] : vector<2xi32>717func.func @muli_scalar(%a : i64, %b : i64) -> i64 {718 %m = arith.muli %a, %b : i64719 return %m : i64720}721 722// CHECK-LABEL: func.func @muli_vector723// CHECK-SAME: ({{%.+}}: vector<3x2xi32>, {{%.+}}: vector<3x2xi32>) -> vector<3x2xi32>724// CHECK-DAG: arith.mului_extended725// CHECK-DAG: arith.muli726// CHECK-DAG: arith.muli727// CHECK-NEXT: arith.addi728// CHECK-NEXT: arith.addi729// CHECK: return {{%.+}} : vector<3x2xi32>730func.func @muli_vector(%a : vector<3xi64>, %b : vector<3xi64>) -> vector<3xi64> {731 %m = arith.muli %a, %b : vector<3xi64>732 return %m : vector<3xi64>733}734 735// CHECK-LABEL: func.func @shli_scalar736// CHECK-SAME: ([[ARG0:%.+]]: vector<2xi32>, [[ARG1:%.+]]: vector<2xi32>) -> vector<2xi32>737// CHECK-NEXT: [[LOW0:%.+]] = vector.extract [[ARG0]][0] : i32 from vector<2xi32>738// CHECK-NEXT: [[HIGH0:%.+]] = vector.extract [[ARG0]][1] : i32 from vector<2xi32>739// CHECK-NEXT: [[LOW1:%.+]] = vector.extract [[ARG1]][0] : i32 from vector<2xi32>740// CHECK-NEXT: [[CST0:%.+]] = arith.constant 0 : i32741// CHECK-NEXT: [[CST32:%.+]] = arith.constant 32 : i32742// CHECK-NEXT: [[OOB:%.+]] = arith.cmpi uge, [[LOW1]], [[CST32]] : i32743// CHECK-NEXT: [[SHLOW0:%.+]] = arith.shli [[LOW0]], [[LOW1]] : i32744// CHECK-NEXT: [[RES0:%.+]] = arith.select [[OOB]], [[CST0]], [[SHLOW0]] : i32745// CHECK-NEXT: [[SHAMT:%.+]] = arith.select [[OOB]], [[CST32]], [[LOW1]] : i32746// CHECK-NEXT: [[RSHAMT:%.+]] = arith.subi [[CST32]], [[SHAMT]] : i32747// CHECK-NEXT: [[SHRHIGH0:%.+]] = arith.shrui [[LOW0]], [[RSHAMT]] : i32748// CHECK-NEXT: [[LSHAMT:%.+]] = arith.subi [[LOW1]], [[CST32]] : i32749// CHECK-NEXT: [[SHLHIGH0:%.+]] = arith.shli [[LOW0]], [[LSHAMT]] : i32750// CHECK-NEXT: [[SHLHIGH1:%.+]] = arith.shli [[HIGH0]], [[LOW1]] : i32751// CHECK-NEXT: [[RES1HIGH:%.+]] = arith.select [[OOB]], [[CST0]], [[SHLHIGH1]] : i32752// CHECK-NEXT: [[RES1LOW:%.+]] = arith.select [[OOB]], [[SHLHIGH0]], [[SHRHIGH0]] : i32753// CHECK-NEXT: [[RES1:%.+]] = arith.ori [[RES1LOW]], [[RES1HIGH]] : i32754// CHECK-NEXT: [[VZ:%.+]] = arith.constant dense<0> : vector<2xi32>755// CHECK-NEXT: [[INS0:%.+]] = vector.insert [[RES0]], [[VZ]] [0] : i32 into vector<2xi32>756// CHECK-NEXT: [[INS1:%.+]] = vector.insert [[RES1]], [[INS0]] [1] : i32 into vector<2xi32>757// CHECK-NEXT: return [[INS1]] : vector<2xi32>758func.func @shli_scalar(%a : i64, %b : i64) -> i64 {759 %c = arith.shli %a, %b : i64760 return %c : i64761}762 763// CHECK-LABEL: func.func @shli_vector764// CHECK-SAME: ({{%.+}}: vector<3x2xi32>, {{%.+}}: vector<3x2xi32>) -> vector<3x2xi32>765// CHECK: {{%.+}} = arith.shli {{%.+}}, {{%.+}} : vector<3x1xi32>766// CHECK: {{%.+}} = arith.shrui {{%.+}}, {{%.+}} : vector<3x1xi32>767// CHECK: {{%.+}} = arith.shli {{%.+}}, {{%.+}} : vector<3x1xi32>768// CHECK: {{%.+}} = arith.shli {{%.+}}, {{%.+}} : vector<3x1xi32>769// CHECK: return {{%.+}} : vector<3x2xi32>770func.func @shli_vector(%a : vector<3xi64>, %b : vector<3xi64>) -> vector<3xi64> {771 %m = arith.shli %a, %b : vector<3xi64>772 return %m : vector<3xi64>773}774 775// CHECK-LABEL: func.func @shrui_scalar776// CHECK-SAME: ([[ARG0:%.+]]: vector<2xi32>, [[ARG1:%.+]]: vector<2xi32>) -> vector<2xi32>777// CHECK-NEXT: [[LOW0:%.+]] = vector.extract [[ARG0]][0] : i32 from vector<2xi32>778// CHECK-NEXT: [[HIGH0:%.+]] = vector.extract [[ARG0]][1] : i32 from vector<2xi32>779// CHECK-NEXT: [[LOW1:%.+]] = vector.extract [[ARG1]][0] : i32 from vector<2xi32>780// CHECK-NEXT: [[CST0:%.+]] = arith.constant 0 : i32781// CHECK-NEXT: [[CST32:%.+]] = arith.constant 32 : i32782// CHECK-DAG: [[OOB:%.+]] = arith.cmpi uge, [[LOW1]], [[CST32]] : i32783// CHECK-DAG: [[SHLOW0:%.+]] = arith.shrui [[LOW0]], [[LOW1]] : i32784// CHECK-NEXT: [[RES0LOW:%.+]] = arith.select [[OOB]], [[CST0]], [[SHLOW0]] : i32785// CHECK-NEXT: [[SHRHIGH0:%.+]] = arith.shrui [[HIGH0]], [[LOW1]] : i32786// CHECK-NEXT: [[RESLOW1:%.+]] = arith.select [[OOB]], [[CST0]], [[SHRHIGH0]] : i32787// CHECK-NEXT: [[SHAMT:%.+]] = arith.select [[OOB]], [[CST32]], [[LOW1]] : i32788// CHECK-NEXT: [[LSHAMT:%.+]] = arith.subi [[CST32]], [[SHAMT]] : i32789// CHECK-NEXT: [[SHLHIGH0:%.+]] = arith.shli [[HIGH0]], [[LSHAMT]] : i32790// CHECK-NEXT: [[RSHAMT:%.+]] = arith.subi [[LOW1]], [[CST32]] : i32791// CHECK-NEXT: [[SHRHIGH0:%.+]] = arith.shrui [[HIGH0]], [[RSHAMT]] : i32792// CHECK-NEXT: [[RES0HIGH:%.+]] = arith.select [[OOB]], [[SHRHIGH0]], [[SHLHIGH0]] : i32793// CHECK-NEXT: [[RES0:%.+]] = arith.ori [[RES0LOW]], [[RES0HIGH]] : i32794// CHECK-NEXT: [[VZ:%.+]] = arith.constant dense<0> : vector<2xi32>795// CHECK-NEXT: [[INS0:%.+]] = vector.insert [[RES0]], [[VZ]] [0] : i32 into vector<2xi32>796// CHECK-NEXT: [[INS1:%.+]] = vector.insert [[RESLOW1]], [[INS0]] [1] : i32 into vector<2xi32>797// CHECK-NEXT: return [[INS1]] : vector<2xi32>798func.func @shrui_scalar(%a : i64, %b : i64) -> i64 {799 %c = arith.shrui %a, %b : i64800 return %c : i64801}802 803// CHECK-LABEL: func.func @shrui_scalar_cst_2804// CHECK-SAME: ({{%.+}}: vector<2xi32>) -> vector<2xi32>805// CHECK: return {{%.+}} : vector<2xi32>806func.func @shrui_scalar_cst_2(%a : i64) -> i64 {807 %b = arith.constant 2 : i64808 %c = arith.shrui %a, %b : i64809 return %c : i64810}811 812// CHECK-LABEL: func.func @shrui_scalar_cst_36813// CHECK-SAME: ({{%.+}}: vector<2xi32>) -> vector<2xi32>814// CHECK: return {{%.+}} : vector<2xi32>815func.func @shrui_scalar_cst_36(%a : i64) -> i64 {816 %b = arith.constant 36 : i64817 %c = arith.shrui %a, %b : i64818 return %c : i64819}820 821// CHECK-LABEL: func.func @shrui_vector822// CHECK-SAME: ({{%.+}}: vector<3x2xi32>, {{%.+}}: vector<3x2xi32>) -> vector<3x2xi32>823// CHECK: {{%.+}} = arith.shrui {{%.+}}, {{%.+}} : vector<3x1xi32>824// CHECK: {{%.+}} = arith.shrui {{%.+}}, {{%.+}} : vector<3x1xi32>825// CHECK: {{%.+}} = arith.shli {{%.+}}, {{%.+}} : vector<3x1xi32>826// CHECK: {{%.+}} = arith.shrui {{%.+}}, {{%.+}} : vector<3x1xi32>827// CHECK: return {{%.+}} : vector<3x2xi32>828func.func @shrui_vector(%a : vector<3xi64>, %b : vector<3xi64>) -> vector<3xi64> {829 %m = arith.shrui %a, %b : vector<3xi64>830 return %m : vector<3xi64>831}832 833// CHECK-LABEL: func.func @shrsi_scalar834// CHECK-SAME: ([[ARG0:%.+]]: vector<2xi32>, [[ARG1:%.+]]: vector<2xi32>) -> vector<2xi32>835// CHECK-NEXT: [[HIGH0:%.+]] = vector.extract [[ARG0]][1] : i32 from vector<2xi32>836// CHECK-NEXT: [[LOW1:%.+]] = vector.extract [[ARG1]][0] : i32 from vector<2xi32>837// CHECK-NEXT: [[CST0:%.+]] = arith.constant 0 : i32838// CHECK-NEXT: [[NEG:%.+]] = arith.cmpi slt, [[HIGH0]], [[CST0]] : i32839// CHECK-NEXT: [[NEGEXT:%.+]] = arith.extsi [[NEG]] : i1 to i32840// CHECK: [[CST64:%.+]] = arith.constant 64 : i32841// CHECK-NEXT: [[SIGNBITS:%.+]] = arith.subi [[CST64]], [[LOW1]] : i32842// CHECK: arith.shli843// CHECK: arith.shrui844// CHECK: arith.shli845// CHECK: arith.shli846// CHECK: arith.shrui847// CHECK: arith.shrui848// CHECK: arith.shli849// CHECK: arith.shrui850// CHECK: return {{%.+}} : vector<2xi32>851func.func @shrsi_scalar(%a : i64, %b : i64) -> i64 {852 %c = arith.shrsi %a, %b : i64853 return %c : i64854}855 856// CHECK-LABEL: func.func @shrsi_vector857// CHECK-SAME: ({{%.+}}: vector<3x2xi32>, {{%.+}}: vector<3x2xi32>) -> vector<3x2xi32>858// CHECK: arith.shli {{%.+}}, {{%.+}} : vector<3x1xi32>859// CHECK: arith.shrui {{%.+}}, {{%.+}} : vector<3x1xi32>860// CHECK: arith.shli {{%.+}}, {{%.+}} : vector<3x1xi32>861// CHECK: arith.shli {{%.+}}, {{%.+}} : vector<3x1xi32>862// CHECK: arith.shrui {{%.+}}, {{%.+}} : vector<3x1xi32>863// CHECK: arith.shrui {{%.+}}, {{%.+}} : vector<3x1xi32>864// CHECK: arith.shli {{%.+}}, {{%.+}} : vector<3x1xi32>865// CHECK: arith.shrui {{%.+}}, {{%.+}} : vector<3x1xi32>866// CHECK: return {{%.+}} : vector<3x2xi32>867func.func @shrsi_vector(%a : vector<3xi64>, %b : vector<3xi64>) -> vector<3xi64> {868 %m = arith.shrsi %a, %b : vector<3xi64>869 return %m : vector<3xi64>870}871 872// CHECK-LABEL: func @andi_scalar_a_b873// CHECK-SAME: ([[ARG0:%.+]]: vector<2xi32>, [[ARG1:%.+]]: vector<2xi32>) -> vector<2xi32>874// CHECK-NEXT: [[LOW0:%.+]] = vector.extract [[ARG0]][0] : i32 from vector<2xi32>875// CHECK-NEXT: [[HIGH0:%.+]] = vector.extract [[ARG0]][1] : i32 from vector<2xi32>876// CHECK-NEXT: [[LOW1:%.+]] = vector.extract [[ARG1]][0] : i32 from vector<2xi32>877// CHECK-NEXT: [[HIGH1:%.+]] = vector.extract [[ARG1]][1] : i32 from vector<2xi32>878// CHECK-NEXT: [[RES0:%.+]] = arith.andi [[LOW0]], [[LOW1]] : i32879// CHECK-NEXT: [[RES1:%.+]] = arith.andi [[HIGH0]], [[HIGH1]] : i32880// CHECK: [[INS0:%.+]] = vector.insert [[RES0]], {{%.+}} [0] : i32 into vector<2xi32>881// CHECK-NEXT: [[INS1:%.+]] = vector.insert [[RES1]], [[INS0]] [1] : i32 into vector<2xi32>882// CHECK-NEXT: return [[INS1]] : vector<2xi32>883func.func @andi_scalar_a_b(%a : i64, %b : i64) -> i64 {884 %x = arith.andi %a, %b : i64885 return %x : i64886}887 888// CHECK-LABEL: func @andi_vector_a_b889// CHECK-SAME: ([[ARG0:%.+]]: vector<3x2xi32>, [[ARG1:%.+]]: vector<3x2xi32>) -> vector<3x2xi32>890// CHECK: {{%.+}} = arith.andi {{%.+}}, {{%.+}} : vector<3x1xi32>891// CHECK-NEXT: {{%.+}} = arith.andi {{%.+}}, {{%.+}} : vector<3x1xi32>892// CHECK: return {{.+}} : vector<3x2xi32>893func.func @andi_vector_a_b(%a : vector<3xi64>, %b : vector<3xi64>) -> vector<3xi64> {894 %x = arith.andi %a, %b : vector<3xi64>895 return %x : vector<3xi64>896}897 898// CHECK-LABEL: func @ori_scalar_a_b899// CHECK-SAME: ([[ARG0:%.+]]: vector<2xi32>, [[ARG1:%.+]]: vector<2xi32>) -> vector<2xi32>900// CHECK-NEXT: [[LOW0:%.+]] = vector.extract [[ARG0]][0] : i32 from vector<2xi32>901// CHECK-NEXT: [[HIGH0:%.+]] = vector.extract [[ARG0]][1] : i32 from vector<2xi32>902// CHECK-NEXT: [[LOW1:%.+]] = vector.extract [[ARG1]][0] : i32 from vector<2xi32>903// CHECK-NEXT: [[HIGH1:%.+]] = vector.extract [[ARG1]][1] : i32 from vector<2xi32>904// CHECK-NEXT: [[RES0:%.+]] = arith.ori [[LOW0]], [[LOW1]] : i32905// CHECK-NEXT: [[RES1:%.+]] = arith.ori [[HIGH0]], [[HIGH1]] : i32906// CHECK: [[INS0:%.+]] = vector.insert [[RES0]], {{%.+}} [0] : i32 into vector<2xi32>907// CHECK-NEXT: [[INS1:%.+]] = vector.insert [[RES1]], [[INS0]] [1] : i32 into vector<2xi32>908// CHECK-NEXT: return [[INS1]] : vector<2xi32>909func.func @ori_scalar_a_b(%a : i64, %b : i64) -> i64 {910 %x = arith.ori %a, %b : i64911 return %x : i64912}913 914// CHECK-LABEL: func @ori_vector_a_b915// CHECK-SAME: ([[ARG0:%.+]]: vector<3x2xi32>, [[ARG1:%.+]]: vector<3x2xi32>) -> vector<3x2xi32>916// CHECK: {{%.+}} = arith.ori {{%.+}}, {{%.+}} : vector<3x1xi32>917// CHECK-NEXT: {{%.+}} = arith.ori {{%.+}}, {{%.+}} : vector<3x1xi32>918// CHECK: return {{.+}} : vector<3x2xi32>919func.func @ori_vector_a_b(%a : vector<3xi64>, %b : vector<3xi64>) -> vector<3xi64> {920 %x = arith.ori %a, %b : vector<3xi64>921 return %x : vector<3xi64>922}923 924// CHECK-LABEL: func @xori_scalar_a_b925// CHECK-SAME: ([[ARG0:%.+]]: vector<2xi32>, [[ARG1:%.+]]: vector<2xi32>) -> vector<2xi32>926// CHECK-NEXT: [[LOW0:%.+]] = vector.extract [[ARG0]][0] : i32 from vector<2xi32>927// CHECK-NEXT: [[HIGH0:%.+]] = vector.extract [[ARG0]][1] : i32 from vector<2xi32>928// CHECK-NEXT: [[LOW1:%.+]] = vector.extract [[ARG1]][0] : i32 from vector<2xi32>929// CHECK-NEXT: [[HIGH1:%.+]] = vector.extract [[ARG1]][1] : i32 from vector<2xi32>930// CHECK-NEXT: [[RES0:%.+]] = arith.xori [[LOW0]], [[LOW1]] : i32931// CHECK-NEXT: [[RES1:%.+]] = arith.xori [[HIGH0]], [[HIGH1]] : i32932// CHECK: [[INS0:%.+]] = vector.insert [[RES0]], {{%.+}} [0] : i32 into vector<2xi32>933// CHECK-NEXT: [[INS1:%.+]] = vector.insert [[RES1]], [[INS0]] [1] : i32 into vector<2xi32>934// CHECK-NEXT: return [[INS1]] : vector<2xi32>935func.func @xori_scalar_a_b(%a : i64, %b : i64) -> i64 {936 %x = arith.xori %a, %b : i64937 return %x : i64938}939 940// CHECK-LABEL: func @xori_vector_a_b941// CHECK-SAME: ([[ARG0:%.+]]: vector<3x2xi32>, [[ARG1:%.+]]: vector<3x2xi32>) -> vector<3x2xi32>942// CHECK: {{%.+}} = arith.xori {{%.+}}, {{%.+}} : vector<3x1xi32>943// CHECK-NEXT: {{%.+}} = arith.xori {{%.+}}, {{%.+}} : vector<3x1xi32>944// CHECK: return {{.+}} : vector<3x2xi32>945func.func @xori_vector_a_b(%a : vector<3xi64>, %b : vector<3xi64>) -> vector<3xi64> {946 %x = arith.xori %a, %b : vector<3xi64>947 return %x : vector<3xi64>948}949 950// CHECK-LABEL: func @uitofp_i64_f64951// CHECK-SAME: ([[ARG:%.+]]: vector<2xi32>) -> f64952// CHECK-NEXT: [[LOW:%.+]] = vector.extract [[ARG]][0] : i32 from vector<2xi32>953// CHECK-NEXT: [[HI:%.+]] = vector.extract [[ARG]][1] : i32 from vector<2xi32>954// CHECK-NEXT: [[CST0:%.+]] = arith.constant 0 : i32955// CHECK-NEXT: [[HIEQ0:%.+]] = arith.cmpi eq, [[HI]], [[CST0]] : i32956// CHECK-NEXT: [[LOWFP:%.+]] = arith.uitofp [[LOW]] : i32 to f64957// CHECK-NEXT: [[HIFP:%.+]] = arith.uitofp [[HI]] : i32 to f64958// CHECK-NEXT: [[POW:%.+]] = arith.constant 0x41F0000000000000 : f64959// CHECK-NEXT: [[RESHI:%.+]] = arith.mulf [[HIFP]], [[POW]] : f64960// CHECK-NEXT: [[RES:%.+]] = arith.addf [[LOWFP]], [[RESHI]] : f64961// CHECK-NEXT: [[SEL:%.+]] = arith.select [[HIEQ0]], [[LOWFP]], [[RES]] : f64962// CHECK-NEXT: return [[SEL]] : f64963func.func @uitofp_i64_f64(%a : i64) -> f64 {964 %r = arith.uitofp %a : i64 to f64965 return %r : f64966}967 968// CHECK-LABEL: func @uitofp_i64_f64_vector969// CHECK-SAME: ([[ARG:%.+]]: vector<3x2xi32>) -> vector<3xf64>970// CHECK-NEXT: [[EXTLOW:%.+]] = vector.extract_strided_slice [[ARG]] {offsets = [0, 0], sizes = [3, 1], strides = [1, 1]} : vector<3x2xi32> to vector<3x1xi32>971// CHECK-NEXT: [[EXTHI:%.+]] = vector.extract_strided_slice [[ARG]] {offsets = [0, 1], sizes = [3, 1], strides = [1, 1]} : vector<3x2xi32> to vector<3x1xi32>972// CHECK-NEXT: [[LOW:%.+]] = vector.shape_cast [[EXTLOW]] : vector<3x1xi32> to vector<3xi32>973// CHECK-NEXT: [[HI:%.+]] = vector.shape_cast [[EXTHI]] : vector<3x1xi32> to vector<3xi32>974// CHECK-NEXT: [[CST0:%.+]] = arith.constant dense<0> : vector<3xi32>975// CHECK-NEXT: [[HIEQ0:%.+]] = arith.cmpi eq, [[HI]], [[CST0]] : vector<3xi32>976// CHECK-NEXT: [[LOWFP:%.+]] = arith.uitofp [[LOW]] : vector<3xi32> to vector<3xf64>977// CHECK-NEXT: [[HIFP:%.+]] = arith.uitofp [[HI]] : vector<3xi32> to vector<3xf64>978// CHECK-NEXT: [[POW:%.+]] = arith.constant dense<0x41F0000000000000> : vector<3xf64>979// CHECK-NEXT: [[RESHI:%.+]] = arith.mulf [[HIFP]], [[POW]] : vector<3xf64>980// CHECK-NEXT: [[RES:%.+]] = arith.addf [[LOWFP]], [[RESHI]] : vector<3xf64>981// CHECK-NEXT: [[SEL:%.+]] = arith.select [[HIEQ0]], [[LOWFP]], [[RES]] : vector<3xi1>, vector<3xf64>982// CHECK-NEXT: return [[SEL]] : vector<3xf64>983func.func @uitofp_i64_f64_vector(%a : vector<3xi64>) -> vector<3xf64> {984 %r = arith.uitofp %a : vector<3xi64> to vector<3xf64>985 return %r : vector<3xf64>986}987 988// CHECK-LABEL: func @uitofp_i64_f16989// CHECK-SAME: ([[ARG:%.+]]: vector<2xi32>) -> f16990// CHECK-NEXT: [[LOW:%.+]] = vector.extract [[ARG]][0] : i32 from vector<2xi32>991// CHECK-NEXT: [[HI:%.+]] = vector.extract [[ARG]][1] : i32 from vector<2xi32>992// CHECK-NEXT: [[CST0:%.+]] = arith.constant 0 : i32993// CHECK-NEXT: [[HIEQ0:%.+]] = arith.cmpi eq, [[HI]], [[CST0]] : i32994// CHECK-NEXT: [[LOWFP:%.+]] = arith.uitofp [[LOW]] : i32 to f16995// CHECK-NEXT: [[HIFP:%.+]] = arith.uitofp [[HI]] : i32 to f16996// CHECK-NEXT: [[POW:%.+]] = arith.constant 0x7C00 : f16997// CHECK-NEXT: [[RESHI:%.+]] = arith.mulf [[HIFP]], [[POW]] : f16998// CHECK-NEXT: [[RES:%.+]] = arith.addf [[LOWFP]], [[RESHI]] : f16999// CHECK-NEXT: [[SEL:%.+]] = arith.select [[HIEQ0]], [[LOWFP]], [[RES]] : f161000// CHECK-NEXT: return [[SEL]] : f161001func.func @uitofp_i64_f16(%a : i64) -> f16 {1002 %r = arith.uitofp %a : i64 to f161003 return %r : f161004}1005 1006// CHECK-LABEL: func @sitofp_i64_f641007// CHECK-SAME: ([[ARG:%.+]]: vector<2xi32>) -> f641008// CHECK: [[VZERO:%.+]] = arith.constant dense<0> : vector<2xi32>1009// CHECK: vector.extract [[VZERO]][0] : i32 from vector<2xi32>1010// CHECK: [[ZERO1:%.+]] = vector.extract [[VZERO]][0] : i32 from vector<2xi32>1011// CHECK-NEXT: [[ZERO2:%.+]] = vector.extract [[VZERO]][1] : i32 from vector<2xi32>1012// CHECK: arith.subi [[ZERO1]], {{%.+}} : i321013// CHECK: arith.subi [[ZERO2]], {{%.+}} : i321014// CHECK: [[CST0:%.+]] = arith.constant 0 : i321015// CHECK: [[HIEQ0:%.+]] = arith.cmpi eq, [[HI:%.+]], [[CST0]] : i321016// CHECK-NEXT: [[LOWFP:%.+]] = arith.uitofp [[LOW:%.+]] : i32 to f641017// CHECK-NEXT: [[HIFP:%.+]] = arith.uitofp [[HI]] : i32 to f641018// CHECK-NEXT: [[POW:%.+]] = arith.constant 0x41F0000000000000 : f641019// CHECK-NEXT: [[RESHI:%.+]] = arith.mulf [[HIFP]], [[POW]] : f641020// CHECK-NEXT: [[RES:%.+]] = arith.addf [[LOWFP]], [[RESHI]] : f641021// CHECK-NEXT: [[SEL:%.+]] = arith.select [[HIEQ0]], [[LOWFP]], [[RES]] : f641022// CHECK-NEXT: [[NEG:%.+]] = arith.negf [[SEL]] : f641023// CHECK-NEXT: [[FINAL:%.+]] = arith.select %{{.+}}, [[NEG]], [[SEL]] : f641024// CHECK-NEXT: return [[FINAL]] : f641025func.func @sitofp_i64_f64(%a : i64) -> f64 {1026 %r = arith.sitofp %a : i64 to f641027 return %r : f641028}1029 1030// CHECK-LABEL: func @sitofp_i64_f64_vector1031// CHECK-SAME: ([[ARG:%.+]]: vector<3x2xi32>) -> vector<3xf64>1032// CHECK: [[VZERO:%.+]] = arith.constant dense<0> : vector<3x2xi32>1033// CHECK: arith.subi1034// CHECK: arith.subi1035// CHECK: [[HIEQ0:%.+]] = arith.cmpi eq, [[HI:%.+]], [[CST0:%.+]] : vector<3xi32>1036// CHECK-NEXT: [[LOWFP:%.+]] = arith.uitofp [[LOW:%.+]] : vector<3xi32> to vector<3xf64>1037// CHECK-NEXT: [[HIFP:%.+]] = arith.uitofp [[HI:%.+]] : vector<3xi32> to vector<3xf64>1038// CHECK-NEXT: [[POW:%.+]] = arith.constant dense<0x41F0000000000000> : vector<3xf64>1039// CHECK-NEXT: [[RESHI:%.+]] = arith.mulf [[HIFP]], [[POW]] : vector<3xf64>1040// CHECK-NEXT: [[RES:%.+]] = arith.addf [[LOWFP]], [[RESHI]] : vector<3xf64>1041// CHECK-NEXT: [[SEL:%.+]] = arith.select [[HIEQ0]], [[LOWFP]], [[RES]] : vector<3xi1>, vector<3xf64>1042// CHECK-NEXT: [[NEG:%.+]] = arith.negf [[SEL]] : vector<3xf64>1043// CHECK-NEXT: [[FINAL:%.+]] = arith.select %{{.+}}, [[NEG]], [[SEL]] : vector<3xi1>, vector<3xf64>1044// CHECK-NEXT: return [[FINAL]] : vector<3xf64>1045func.func @sitofp_i64_f64_vector(%a : vector<3xi64>) -> vector<3xf64> {1046 %r = arith.sitofp %a : vector<3xi64> to vector<3xf64>1047 return %r : vector<3xf64>1048}1049 1050// CHECK-LABEL: func @fptoui_i64_f641051// CHECK-SAME: ([[ARG:%.+]]: f64) -> vector<2xi32>1052// CHECK-NEXT: [[POW:%.+]] = arith.constant 0x41F0000000000000 : f641053// CHECK-NEXT: [[DIV:%.+]] = arith.divf [[ARG]], [[POW]] : f641054// CHECK-NEXT: [[HIGHHALF:%.+]] = arith.fptoui [[DIV]] : f64 to i321055// CHECK-NEXT: [[REM:%.+]] = arith.remf [[ARG]], [[POW]] : f641056// CHECK-NEXT: [[LOWHALF:%.+]] = arith.fptoui [[REM]] : f64 to i321057// CHECK: %{{.+}} = vector.insert [[LOWHALF]], %{{.+}} [0]1058// CHECK-NEXT: [[RESVEC:%.+]] = vector.insert [[HIGHHALF]], %{{.+}} [1]1059// CHECK: return [[RESVEC]] : vector<2xi32>1060func.func @fptoui_i64_f64(%a : f64) -> i64 {1061 %r = arith.fptoui %a : f64 to i641062 return %r : i641063}1064 1065// CHECK-LABEL: func @fptoui_i64_f64_vector1066// CHECK-SAME: ([[ARG:%.+]]: vector<3xf64>) -> vector<3x2xi32>1067// CHECK-NEXT: [[POW:%.+]] = arith.constant dense<0x41F0000000000000> : vector<3xf64>1068// CHECK-NEXT: [[DIV:%.+]] = arith.divf [[ARG]], [[POW]] : vector<3xf64>1069// CHECK-NEXT: [[HIGHHALF:%.+]] = arith.fptoui [[DIV]] : vector<3xf64> to vector<3xi32>1070// CHECK-NEXT: [[REM:%.+]] = arith.remf [[ARG]], [[POW]] : vector<3xf64>1071// CHECK-NEXT: [[LOWHALF:%.+]] = arith.fptoui [[REM]] : vector<3xf64> to vector<3xi32>1072// CHECK-DAG: [[HIGHHALFX1:%.+]] = vector.shape_cast [[HIGHHALF]] : vector<3xi32> to vector<3x1xi32>1073// CHECK-DAG: [[LOWHALFX1:%.+]] = vector.shape_cast [[LOWHALF]] : vector<3xi32> to vector<3x1xi32>1074// CHECK: %{{.+}} = vector.insert_strided_slice [[LOWHALFX1]], %{{.+}} {offsets = [0, 0], strides = [1, 1]}1075// CHECK-NEXT: [[RESVEC:%.+]] = vector.insert_strided_slice [[HIGHHALFX1]], %{{.+}} {offsets = [0, 1], strides = [1, 1]}1076// CHECK: return [[RESVEC]] : vector<3x2xi32>1077func.func @fptoui_i64_f64_vector(%a : vector<3xf64>) -> vector<3xi64> {1078 %r = arith.fptoui %a : vector<3xf64> to vector<3xi64>1079 return %r : vector<3xi64>1080}1081 1082// This generates lines that are already verified by other patterns.1083// We do not re-verify these and just check for the wrapper around fptoui by following its low part.1084// CHECK-LABEL: func @fptosi_i64_f641085// CHECK-SAME: ([[ARG:%.+]]: f64) -> vector<2xi32>1086// CHECK: [[ZEROCST:%.+]] = arith.constant 0.000000e+00 : f641087// CHECK: [[ZEROCSTINT:%.+]] = arith.constant dense<0> : vector<2xi32>1088// CHECK-NEXT: [[ISNEGATIVE:%.+]] = arith.cmpf olt, [[ARG]], [[ZEROCST]] : f641089// CHECK-NEXT: [[NEGATED:%.+]] = arith.negf [[ARG]] : f641090// CHECK-NEXT: [[ABSVALUE:%.+]] = arith.select [[ISNEGATIVE]], [[NEGATED]], [[ARG]] : f641091// CHECK-NEXT: [[POW:%.+]] = arith.constant 0x41F0000000000000 : f641092// CHECK-NEXT: [[DIV:%.+]] = arith.divf [[ABSVALUE]], [[POW]] : f641093// CHECK-NEXT: [[HIGHHALF:%.+]] = arith.fptoui [[DIV]] : f64 to i321094// CHECK-NEXT: [[REM:%.+]] = arith.remf [[ABSVALUE]], [[POW]] : f641095// CHECK-NEXT: [[LOWHALF:%.+]] = arith.fptoui [[REM]] : f64 to i321096// CHECK: vector.insert [[LOWHALF]], %{{.+}} [0] : i32 into vector<2xi32>1097// CHECK-NEXT: [[FPTOUIRESVEC:%.+]] = vector.insert [[HIGHHALF]]1098// CHECK: [[ZEROCSTINTHALF:%.+]] = vector.extract [[ZEROCSTINT]][0] : i32 from vector<2xi32>1099// CHECK: [[SUB:%.+]] = arith.subi [[ZEROCSTINTHALF]], %{{.+}} : i321100// CHECK-NEXT: arith.cmpi ult, [[ZEROCSTINTHALF]], %{{.+}} : i321101// CHECK-NEXT: arith.extui1102// CHECK-NEXT: arith.subi1103// CHECK-NEXT: arith.subi1104// CHECK: vector.insert [[SUB]]1105// CHECK: [[SUBVEC:%.+]] = vector.insert1106// CHECK: [[SUB:%.+]] = vector.extract [[SUBVEC]][0] : i32 from vector<2xi32>1107// CHECK: [[LOWRES:%.+]] = vector.extract [[FPTOUIRESVEC]][0] : i32 from vector<2xi32>1108// CHECK: [[ABSRES:%.+]] = arith.select [[ISNEGATIVE]], [[SUB]], [[LOWRES]] : i321109// CHECK-NEXT: arith.select [[ISNEGATIVE]]1110// CHECK: vector.insert [[ABSRES]]1111// CHECK-NEXT: [[ABSRESVEC:%.+]] = vector.insert1112// CHECK-NEXT: return [[ABSRESVEC]] : vector<2xi32>1113func.func @fptosi_i64_f64(%a : f64) -> i64 {1114 %r = arith.fptosi %a : f64 to i641115 return %r : i641116}1117 1118// Same as the non-vector one, we don't re-verify.1119// CHECK-LABEL: func @fptosi_i64_f64_vector1120// CHECK-SAME: ([[ARG:%.+]]: vector<3xf64>) -> vector<3x2xi32>1121// CHECK-NEXT: [[ZEROCST:%.+]] = arith.constant dense<0.000000e+00> : vector<3xf64>1122// CHECK-NEXT: [[ZEROCSTINT:%.+]] = arith.constant dense<0> : vector<3x2xi32>1123// CHECK-NEXT: [[ISNEGATIVE:%.+]] = arith.cmpf olt, [[ARG]], [[ZEROCST]] : vector<3xf64>1124// CHECK-NEXT: [[NEGATED:%.+]] = arith.negf [[ARG]] : vector<3xf64>1125// CHECK-NEXT: [[ABSVALUE:%.+]] = arith.select [[ISNEGATIVE]], [[NEGATED]], [[ARG]] : vector<3xi1>, vector<3xf64>1126// CHECK-NEXT: [[POW:%.+]] = arith.constant dense<0x41F0000000000000> : vector<3xf64>1127// CHECK-NEXT: [[DIV:%.+]] = arith.divf [[ABSVALUE]], [[POW]] : vector<3xf64>1128// CHECK-NEXT: [[HIGHHALF:%.+]] = arith.fptoui [[DIV]] : vector<3xf64> to vector<3xi32>1129// CHECK-NEXT: [[REM:%.+]] = arith.remf [[ABSVALUE]], [[POW]] : vector<3xf64>1130// CHECK-NEXT: [[LOWHALF:%.+]] = arith.fptoui [[REM]] : vector<3xf64> to vector<3xi32>1131// CHECK-NEXT: [[HIGHHALFX1:%.+]] = vector.shape_cast [[HIGHHALF]] : vector<3xi32> to vector<3x1xi32>1132// CHECK-NEXT: [[LOWHALFX1:%.+]] = vector.shape_cast [[LOWHALF]] : vector<3xi32> to vector<3x1xi32>1133// CHECK: vector.insert_strided_slice [[LOWHALFX1]], %{{.+}} {offsets = [0, 0], strides = [1, 1]} : vector<3x1xi32> into vector<3x2xi32>1134// CHECK-NEXT: [[FPTOUIRESVEC:%.+]] = vector.insert_strided_slice [[HIGHHALFX1]]1135// CHECK: [[ZEROCSTINTHALF:%.+]] = vector.extract_strided_slice [[ZEROCSTINT]]1136// CHECK-SAME: {offsets = [0, 0], sizes = [3, 1], strides = [1, 1]} : vector<3x2xi32> to vector<3x1xi32>1137// CHECK: [[SUB:%.+]] = arith.subi [[ZEROCSTINTHALF]], %{{.+}} : vector<3x1xi32>1138// CHECK-NEXT: arith.cmpi ult, [[ZEROCSTINTHALF]], %{{.+}} : vector<3x1xi32>1139// CHECK-NEXT: arith.extui1140// CHECK-NEXT: arith.subi1141// CHECK-NEXT: arith.subi1142// CHECK: vector.insert_strided_slice [[SUB]]1143// CHECK-NEXT: [[SUBVEC:%.+]] = vector.insert_strided_slice1144// CHECK: [[SUB:%.+]] = vector.extract_strided_slice [[SUBVEC]]1145// CHECK-SAME: {offsets = [0, 0], sizes = [3, 1], strides = [1, 1]} : vector<3x2xi32> to vector<3x1xi32>1146// CHECK: [[LOWRES:%.+]] = vector.extract_strided_slice [[FPTOUIRESVEC]]1147// CHECK-SAME: {offsets = [0, 0], sizes = [3, 1], strides = [1, 1]} : vector<3x2xi32> to vector<3x1xi32>1148// CHECK: [[ISNEGATIVEX1:%.+]] = vector.shape_cast [[ISNEGATIVE]] : vector<3xi1> to vector<3x1xi1>1149// CHECK: [[ABSRES:%.+]] = arith.select [[ISNEGATIVEX1]], [[SUB]], [[LOWRES]] : vector<3x1xi1>, vector<3x1xi32>1150// CHECK-NEXT: arith.select [[ISNEGATIVEX1]]1151// CHECK: vector.insert_strided_slice [[ABSRES]]1152// CHECK-NEXT: [[ABSRESVEC:%.+]] = vector.insert_strided_slice1153// CHECK-NEXT: return [[ABSRESVEC]] : vector<3x2xi32>1154func.func @fptosi_i64_f64_vector(%a : vector<3xf64>) -> vector<3xi64> {1155 %r = arith.fptosi %a : vector<3xf64> to vector<3xi64>1156 return %r : vector<3xi64>1157}1158