1// RUN: mlir-opt %s -convert-index-to-llvm | FileCheck %s 2// RUN: mlir-opt %s -convert-index-to-llvm=index-bitwidth=32 | FileCheck %s --check-prefix=INDEX32 3// RUN: mlir-opt %s -convert-index-to-llvm=index-bitwidth=64 | FileCheck %s --check-prefix=INDEX64 4 5// Same below, but using the `ConvertToLLVMPatternInterface` entry point 6// and the generic `convert-to-llvm` pass. 7// RUN: mlir-opt --convert-to-llvm="filter-dialects=index" --split-input-file %s | FileCheck %s 8 9// CHECK-LABEL: @trivial_ops 10func.func @trivial_ops(%a: index, %b: index) { 11 // CHECK: llvm.add 12 %0 = index.add %a, %b 13 // CHECK: llvm.sub 14 %1 = index.sub %a, %b 15 // CHECK: llvm.mul 16 %2 = index.mul %a, %b 17 // CHECK: llvm.sdiv 18 %3 = index.divs %a, %b 19 // CHECK: llvm.udiv 20 %4 = index.divu %a, %b 21 // CHECK: llvm.srem 22 %5 = index.rems %a, %b 23 // CHECK: llvm.urem 24 %6 = index.remu %a, %b 25 // CHECK: llvm.intr.smax 26 %7 = index.maxs %a, %b 27 // CHECK: llvm.intr.umax 28 %8 = index.maxu %a, %b 29 // CHECK: llvm.intr.smin 30 %9 = index.mins %a, %b 31 // CHECK: llvm.intr.umin 32 %10 = index.minu %a, %b 33 // CHECK: llvm.shl 34 %11 = index.shl %a, %b 35 // CHECK: llvm.ashr 36 %12 = index.shrs %a, %b 37 // CHECK: llvm.lshr 38 %13 = index.shru %a, %b 39 // CHECK: llvm.add 40 %14 = index.add %a, %b 41 // CHECK: llvm.or 42 %15 = index.or %a, %b 43 // CHECK: llvm.xor 44 %16 = index.xor %a, %b 45 // CHECK: llvm.mlir.constant(true 46 %17 = index.bool.constant true 47 return 48} 49 50// CHECK-LABEL: @ceildivs 51// CHECK-SAME: %[[NI:.*]]: index, %[[MI:.*]]: index 52func.func @ceildivs(%n: index, %m: index) -> index { 53 // CHECK-DAG: %[[N:.*]] = builtin.unrealized_conversion_cast %[[NI]] 54 // CHECK-DAG: %[[M:.*]] = builtin.unrealized_conversion_cast %[[MI]] 55 // CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : 56 // CHECK: %[[POS_ONE:.*]] = llvm.mlir.constant(1 : 57 // CHECK: %[[NEG_ONE:.*]] = llvm.mlir.constant(-1 : 58 59 // CHECK: %[[M_POS:.*]] = llvm.icmp "sgt" %[[M]], %[[ZERO]] 60 // CHECK: %[[X:.*]] = llvm.select %[[M_POS]], %[[NEG_ONE]], %[[POS_ONE]] 61 62 // CHECK: %[[N_PLUS_X:.*]] = llvm.add %[[N]], %[[X]] 63 // CHECK: %[[N_PLUS_X_DIV_M:.*]] = llvm.sdiv %[[N_PLUS_X]], %[[M]] 64 // CHECK: %[[POS_RES:.*]] = llvm.add %[[N_PLUS_X_DIV_M]], %[[POS_ONE]] 65 66 // CHECK: %[[NEG_N:.*]] = llvm.sub %[[ZERO]], %[[N]] 67 // CHECK: %[[NEG_N_DIV_M:.*]] = llvm.sdiv %[[NEG_N]], %[[M]] 68 // CHECK: %[[NEG_RES:.*]] = llvm.sub %[[ZERO]], %[[NEG_N_DIV_M]] 69 70 // CHECK: %[[N_POS:.*]] = llvm.icmp "sgt" %[[N]], %[[ZERO]] 71 // CHECK: %[[SAME_SIGN:.*]] = llvm.icmp "eq" %[[N_POS]], %[[M_POS]] 72 // CHECK: %[[N_NON_ZERO:.*]] = llvm.icmp "ne" %[[N]], %[[ZERO]] 73 // CHECK: %[[CMP:.*]] = llvm.and %[[SAME_SIGN]], %[[N_NON_ZERO]] 74 // CHECK: %[[RESULT:.*]] = llvm.select %[[CMP]], %[[POS_RES]], %[[NEG_RES]] 75 %result = index.ceildivs %n, %m 76 77 // CHECK: %[[RESULTI:.*]] = builtin.unrealized_conversion_cast %[[RESULT]] 78 // CHECK: return %[[RESULTI]] 79 return %result : index 80} 81 82// CHECK-LABEL: @ceildivu 83// CHECK-SAME: %[[NI:.*]]: index, %[[MI:.*]]: index 84func.func @ceildivu(%n: index, %m: index) -> index { 85 // CHECK-DAG: %[[N:.*]] = builtin.unrealized_conversion_cast %[[NI]] 86 // CHECK-DAG: %[[M:.*]] = builtin.unrealized_conversion_cast %[[MI]] 87 // CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : 88 // CHECK: %[[ONE:.*]] = llvm.mlir.constant(1 : 89 90 // CHECK: %[[MINUS_ONE:.*]] = llvm.sub %[[N]], %[[ONE]] 91 // CHECK: %[[QUOTIENT:.*]] = llvm.udiv %[[MINUS_ONE]], %[[M]] 92 // CHECK: %[[PLUS_ONE:.*]] = llvm.add %[[QUOTIENT]], %[[ONE]] 93 94 // CHECK: %[[CMP:.*]] = llvm.icmp "eq" %[[N]], %[[ZERO]] 95 // CHECK: %[[RESULT:.*]] = llvm.select %[[CMP]], %[[ZERO]], %[[PLUS_ONE]] 96 %result = index.ceildivu %n, %m 97 98 // CHECK: %[[RESULTI:.*]] = builtin.unrealized_conversion_cast %[[RESULT]] 99 // CHECK: return %[[RESULTI]] 100 return %result : index 101} 102 103// CHECK-LABEL: @floordivs 104// CHECK-SAME: %[[NI:.*]]: index, %[[MI:.*]]: index 105func.func @floordivs(%n: index, %m: index) -> index { 106 // CHECK-DAG: %[[N:.*]] = builtin.unrealized_conversion_cast %[[NI]] 107 // CHECK-DAG: %[[M:.*]] = builtin.unrealized_conversion_cast %[[MI]] 108 // CHECK-DAG: %[[ZERO:.*]] = llvm.mlir.constant(0 : 109 // CHECK-DAG: %[[POS_ONE:.*]] = llvm.mlir.constant(1 : 110 // CHECK-DAG: %[[NEG_ONE:.*]] = llvm.mlir.constant(-1 : 111 112 // CHECK: %[[M_NEG:.*]] = llvm.icmp "slt" %[[M]], %[[ZERO]] 113 // CHECK: %[[X:.*]] = llvm.select %[[M_NEG]], %[[POS_ONE]], %[[NEG_ONE]] 114 115 // CHECK: %[[X_MINUS_N:.*]] = llvm.sub %[[X]], %[[N]] 116 // CHECK: %[[X_MINUS_N_DIV_M:.*]] = llvm.sdiv %[[X_MINUS_N]], %[[M]] 117 // CHECK: %[[NEG_RES:.*]] = llvm.sub %[[NEG_ONE]], %[[X_MINUS_N_DIV_M]] 118 119 // CHECK: %[[POS_RES:.*]] = llvm.sdiv %[[N]], %[[M]] 120 121 // CHECK: %[[N_NEG:.*]] = llvm.icmp "slt" %[[N]], %[[ZERO]] 122 // CHECK: %[[DIFF_SIGN:.*]] = llvm.icmp "ne" %[[N_NEG]], %[[M_NEG]] 123 // CHECK: %[[N_NON_ZERO:.*]] = llvm.icmp "ne" %[[N]], %[[ZERO]] 124 // CHECK: %[[CMP:.*]] = llvm.and %[[DIFF_SIGN]], %[[N_NON_ZERO]] 125 // CHECK: %[[RESULT:.*]] = llvm.select %[[CMP]], %[[NEG_RES]], %[[POS_RES]] 126 %result = index.floordivs %n, %m 127 128 // CHECK: %[[RESULTI:.*]] = builtin.unrealized_conversion_cast %[[RESULT]] 129 // CHECK: return %[[RESULTI]] 130 return %result : index 131} 132 133// INDEX32-LABEL: @index_cast_from 134// INDEX64-LABEL: @index_cast_from 135// INDEX32-SAME: %[[AI:.*]]: index 136// INDEX64-SAME: %[[AI:.*]]: index 137func.func @index_cast_from(%a: index) -> (i64, i32, i64, i32) { 138 // INDEX32: %[[A:.*]] = builtin.unrealized_conversion_cast %[[AI]] : index to i32 139 // INDEX64: %[[A:.*]] = builtin.unrealized_conversion_cast %[[AI]] : index to i64 140 141 // INDEX32: %[[V0:.*]] = llvm.sext %[[A]] : i32 to i64 142 %0 = index.casts %a : index to i64 143 // INDEX64: %[[V1:.*]] = llvm.trunc %[[A]] : i64 to i32 144 %1 = index.casts %a : index to i32 145 // INDEX32: %[[V2:.*]] = llvm.zext %[[A]] : i32 to i64 146 %2 = index.castu %a : index to i64 147 // INDEX64: %[[V3:.*]] = llvm.trunc %[[A]] : i64 to i32 148 %3 = index.castu %a : index to i32 149 150 // INDEX32: return %[[V0]], %[[A]], %[[V2]], %[[A]] 151 // INDEX64: return %[[A]], %[[V1]], %[[A]], %[[V3]] 152 return %0, %1, %2, %3 : i64, i32, i64, i32 153} 154 155// INDEX32-LABEL: @index_cast_to 156// INDEX64-LABEL: @index_cast_to 157// INDEX32-SAME: %[[A:.*]]: i32, %[[B:.*]]: i64 158// INDEX64-SAME: %[[A:.*]]: i32, %[[B:.*]]: i64 159func.func @index_cast_to(%a: i32, %b: i64) -> (index, index, index, index) { 160 // INDEX64: %[[V0:.*]] = llvm.sext %[[A]] : i32 to i64 161 %0 = index.casts %a : i32 to index 162 // INDEX32: %[[V1:.*]] = llvm.trunc %[[B]] : i64 to i32 163 %1 = index.casts %b : i64 to index 164 // INDEX64: %[[V2:.*]] = llvm.zext %[[A]] : i32 to i64 165 %2 = index.castu %a : i32 to index 166 // INDEX32: %[[V3:.*]] = llvm.trunc %[[B]] : i64 to i32 167 %3 = index.castu %b : i64 to index 168 return %0, %1, %2, %3 : index, index, index, index 169} 170 171// INDEX32-LABEL: @index_sizeof 172// INDEX64-LABEL: @index_sizeof 173func.func @index_sizeof() { 174 // INDEX32-NEXT: llvm.mlir.constant(32 : i32) 175 // INDEX64-NEXT: llvm.mlir.constant(64 : i64) 176 %0 = index.sizeof 177 return 178} 179 180// INDEX32-LABEL: @index_constant 181// INDEX64-LABEL: @index_constant 182func.func @index_constant() { 183 // INDEX32: llvm.mlir.constant(-2100000000 : i32) : i32 184 // INDEX64: llvm.mlir.constant(-2100000000 : i64) : i64 185 %0 = index.constant -2100000000 186 // INDEX32: llvm.mlir.constant(2100000000 : i32) : i32 187 // INDEX64: llvm.mlir.constant(2100000000 : i64) : i64 188 %1 = index.constant 2100000000 189 // INDEX32: llvm.mlir.constant(1294967296 : i32) : i32 190 // INDEX64: llvm.mlir.constant(-3000000000 : i64) : i64 191 %2 = index.constant -3000000000 192 // INDEX32: llvm.mlir.constant(-1294967296 : i32) : i32 193 // INDEX64: llvm.mlir.constant(3000000000 : i64) : i64 194 %3 = index.constant 3000000000 195 return 196} 197