| // RUN: mlir-opt -test-int-range-inference -canonicalize %s | FileCheck %s |
| |
| // Most operations are covered by the `arith` tests, which use the same code |
| // Here, we add a few tests to ensure the "index can be 32- or 64-bit" handling |
| // code is operating as expected. |
| |
| // CHECK-LABEL: func @add_same_for_both |
| // CHECK: %[[true:.*]] = index.bool.constant true |
| // CHECK: return %[[true]] |
| func.func @add_same_for_both(%arg0 : index) -> i1 { |
| %c1 = index.constant 1 |
| %calmostBig = index.constant 0xfffffffe |
| %0 = index.minu %arg0, %calmostBig |
| %1 = index.add %0, %c1 |
| %2 = index.cmp uge(%1, %c1) |
| func.return %2 : i1 |
| } |
| |
| // CHECK-LABEL: func @add_unsigned_ov |
| // CHECK: %[[uge:.*]] = index.cmp uge |
| // CHECK: return %[[uge]] |
| func.func @add_unsigned_ov(%arg0 : index) -> i1 { |
| %c1 = index.constant 1 |
| %cu32_max = index.constant 0xffffffff |
| %0 = index.minu %arg0, %cu32_max |
| %1 = index.add %0, %c1 |
| // On 32-bit, the add could wrap, so the result doesn't have to be >= 1 |
| %2 = index.cmp uge(%1, %c1) |
| func.return %2 : i1 |
| } |
| |
| // CHECK-LABEL: func @add_signed_ov |
| // CHECK: %[[sge:.*]] = index.cmp sge |
| // CHECK: return %[[sge]] |
| func.func @add_signed_ov(%arg0 : index) -> i1 { |
| %c0 = index.constant 0 |
| %c1 = index.constant 1 |
| %ci32_max = index.constant 0x7fffffff |
| %0 = index.minu %arg0, %ci32_max |
| %1 = index.add %0, %c1 |
| // On 32-bit, the add could wrap, so the result doesn't have to be positive |
| %2 = index.cmp sge(%1, %c0) |
| func.return %2 : i1 |
| } |
| |
| // CHECK-LABEL: func @add_big |
| // CHECK: %[[true:.*]] = index.bool.constant true |
| // CHECK: return %[[true]] |
| func.func @add_big(%arg0 : index) -> i1 { |
| %c1 = index.constant 1 |
| %cmin = index.constant 0x300000000 |
| %cmax = index.constant 0x30000ffff |
| // Note: the order of the clamps matters. |
| // If you go max, then min, you infer the ranges [0x300...0, 0xff..ff] |
| // and then [0x30...0000, 0x30...ffff] |
| // If you switch the order of the below operations, you instead first infer |
| // the range [0,0x3...ffff]. Then, the min inference can't constraint |
| // this intermediate, since in the 32-bit case we could have, for example |
| // trunc(%arg0 = 0x2ffffffff) = 0xffffffff > trunc(0x30000ffff) = 0x0000ffff |
| // which means we can't do any inference. |
| %0 = index.maxu %arg0, %cmin |
| %1 = index.minu %0, %cmax |
| %2 = index.add %1, %c1 |
| %3 = index.cmp uge(%1, %cmin) |
| func.return %3 : i1 |
| } |