<table border="1" cellspacing="0" cellpadding="8">
    <tr>
        <th>Issue</th>
        <td>
            <a href=https://github.com/llvm/llvm-project/issues/59469>59469</a>
        </td>
    </tr>

    <tr>
        <th>Summary</th>
        <td>
            Incorrect indices after lowering
        </td>
    </tr>

    <tr>
      <th>Labels</th>
      <td>
      </td>
    </tr>

    <tr>
      <th>Assignees</th>
      <td>
      </td>
    </tr>

    <tr>
      <th>Reporter</th>
      <td>
          HahaLan97
      </td>
    </tr>
</table>

<pre>
    Hi everyone, I'm using MLIR to create something. I basiclly create a dialect, in which I let `i64` type to be `mydialect.mytype`, so that everyone who wants to use this dialect must use the `mytype`. Then I added a `typeConverter` to do some `unrealizedCast` to convert `mytype` into `i64` for scalar type and shaped type during lowering. So for the `affine.load/store` with `memref<!mytype>` I need to also create a pattern to use `i64` instead of `!mytype`. I'm doing the rewriting like following:
```
struct AffineLoadRewriting final : public OpConversionPattern<AffineLoadOp> {
public:
    using OpConversionPattern<AffineLoadOp>::OpConversionPattern;

 AffineLoadRewriting(
        TypeConverter &typeConverter,
 MLIRContext* context,
        PatternBenefit benefit)
            : OpConversionPattern<AffineLoadOp>(
                typeConverter,
 context,
                benefit){};

    LogicalResult matchAndRewrite(
        AffineLoadOp op,
        AffineLoadOpAdaptor adaptor,
        ConversionPatternRewriter &rewriter) const override
 {
        auto type = op.getResult().getType();
        if (!type.template isa<MyType>()) return failure();

 rewriter.replaceOpWithNewOp<AffineLoadOp>(
            op,
 adaptor.getMemref(),
            adaptor.getIndices());

 return success();
    }
};

struct AffineStoreRewriting final : public OpConversionPattern<AffineStoreOp> {
public:
    using OpConversionPattern<AffineStoreOp>::OpConversionPattern;

 AffineStoreRewriting(
        TypeConverter &typeConverter,
 MLIRContext* context,
        PatternBenefit benefit)
            : OpConversionPattern<AffineStoreOp>(
                typeConverter,
 context,
                benefit){};

    LogicalResult matchAndRewrite(
        AffineStoreOp op,
        AffineStoreOpAdaptor adaptor,
        ConversionPatternRewriter &rewriter) const override
 {
        auto type = op.getValue().getType();
        if (!type.template isa<MyType>()) return failure();

 rewriter.replaceOpWithNewOp<AffineStoreOp>(
            op,
 adaptor.getValue(),
            adaptor.getMemref(),
 adaptor.getIndices());

        return success();
 }
};
```
But when I'm tesing this pass I run into a problematic bug. The testbench is:
```
#le_3 = affine_set<(i): (3 - i >= 0)>
#ge_4 = affine_set<(i): (i - 4 >= 0)>
!scalar = !mydialect.mytype

module {
    func.func @kernel(%a : memref<8x!scalar>, %b : memref<8x!scalar>) attributes {llvm.emit_c_interface} {
        affine.for %c1 = 0 to 8 {
 affine.if #le_3(%c1) {
                %1 = affine.load %a[%c1 + 4] : memref<8x!scalar>
                affine.store %1, %b[%c1] : memref<8x!scalar>
            }
            affine.if #ge_4(%c1) {
 %1 = affine.load %a[%c1 - 4] : memref<8x!scalar>
 affine.store %1, %b[%c1] : memref<8x!scalar>
            }
 }

        return
    }
}
```
And the result of lowering is:
```
#map = affine_map<(d0) -> (d0)>
#set = affine_set<(d0) : (-d0 + 3 >= 0)>
#set1 = affine_set<(d0) : (d0 - 4 >= 0)>
module {
 func.func @kernel(%arg0: memref<8xi64>, %arg1: memref<8xi64>) attributes {llvm.emit_c_interface} {
    affine.for %arg2 = 0 to 8 {
 affine.if #set(%arg2) {
        %0 = affine.load %arg0[%arg2] : memref<8xi64>
        affine.store %0, %arg1[%arg2] : memref<8xi64>
 }
      affine.if #set1(%arg2) {
        %0 = affine.load %arg0[%arg2] : memref<8xi64>
        affine.store %0, %arg1[%arg2] : memref<8xi64>
      }
    }
    return
  }
}
```
This is definitely incorrect, there is incorrect affine_maps for the indices like [%c1 +/- 4]. Here is one piece of the debug info:
```
//===-------------------------------------------===//
Legalizing operation : 'affine.load'(0x55bdeb99be50) {
  %0 = "affine.load"(<<UNKNOWN SSA VALUE>>, %arg2) {map = affine_map<(d0) -> (d0 + 4)>} : (memref<8x!mydialect.mytype>, index) -> !mydialect.mytype

  * Fold {
  } -> FAILURE : unable to fold

  * Pattern : 'affine.load -> ()' {
    ** Insert  : 'affine.load'(0x55bdeb97bbc0)
    ** Replace : 'affine.load'(0x55bdeb99be50)

 //===-------------------------------------------===//
    Legalizing operation : 'affine.load'(0x55bdeb97bbc0) {
      %0 = "affine.load"(%arg0, %arg2) {map = affine_map<(d0) -> (d0)>} : (memref<8xi64>, index) -> i64

    } -> SUCCESS : operation marked legal by the target
 //===-------------------------------------------===//
  } -> SUCCESS : pattern applied successfully
} -> SUCCESS
//===-------------------------------------------===//
```
Could anybody tell me what is wrong with these rewriting patterns. And how exactly should I rewrite AffineLoad/StoreOp?
</pre>
<img width="1px" height="1px" alt="" src="http://email.email.llvm.org/o/eJzUWV9z2roS_zTKy04YY0MMDzwQCFPmpu2dpD3nMSPba6xbIXkkuYTz6e9Ilo3Nn4R2TmdalynY0v72j3Z_XilUa7YRiDMyvifj5Q2tTCHV7AMt6CMV0_gmkdl-9oEBfke1lwJJuIA1CeMtVJqJDXx8XD-BkZAqpAZByy2agonNANaQUM1SzvfNIIWMUY6psSBMwK5gaQFr4GiA3AXsbkTuAjD7Ei1igvbhdu9lBtu9HSF3gZXWEkxBTWsW7AoJOyqMtqKVRjAF040-2Fba-Kce1WMN4EuBAtZAswwzoHbQDi2k-I7KoHIWScikc80OV0Ih5ewfzBZUGz-e1vN72MCEkR3HcqlAp5RTVftIRQa6oCVm9X1WKRtRLneoXASfpZPxNtM8ZwIHXNKMhCttpHJKdswUTi1uFeYkWpBw6E2IHuyENQi0KiRQruVhLUpqDCrRxOtgJxPaIM1A5uCiPexEq176TFpDrV0Kd4oZZzb7hpBLzuWOiQ2J5iRYkmBuEeqPu9VGVamBufPlUdLsqQXImaAcSDSHsko4S-FzWa-CZlL8tzaWRIuD6OeSRA9A4vsaupZqFQOAT9GrcKxcND871eN72DOmk3By0GmvL90MAhLe9VMqXPjptngWUhh8NSSc2ySqfy76cN6SexSYMwNJ_U3CaX-avWz4rvP32ObmumDqJduaq2NUfE_i5XHYAOBRblhK-RPqihvYUpMWc-GjiCf2dO0FWZ4o7o7PM1oaqYDW3ydzT-Lhlbq1Uf43CafWS21AfkelWIYepM2wBo5WRtYlS6IlyHKwQVN7Zb0Ip_bepkB910aiEWc5uJGhhRgY3JbcViTTlESLj_svvnRr4XAKCk2lBOSU8Uodg3roxomBwpLTFD-XfzNTfMKdXeyr1r4bYh9H68fHmla8MWcWvzN3LTKWom4tPzXSOaKrNEWtz0TH5k0tcJJAPeJ4tuT3k8zhZP8N6jgA_SB39K3_g8ij4_GfwR7e4Mv04Sf8BvzxF-UV_tb08c7qX-CPjl_v0cd5qvkBfvHX2zRznmP6Xcp9ZWDn-kLX7hjUdb_DNJRUa1iDqkTd3lEolUw4bqlhKSTVxnWUVsQkKNICmL7UC5Ew4vgSuSSom7sXjcZ1cBPmbJ7blY7gFhg4mllC4J4_tAAbfBm9B8DgFkYXAIa-IbVDrtM76rY74d3KrOLYz-a8EunA_gdkFHxDJZC7eI-pI5O2J528tqpc_iyAhOPk7TlToMYollQGtdXK-fftALfMvKQvTBhUOU2RxMsz9VV3yrZ3JuE4HTrvXJs-6Uz2s1w5uYWoLU-HVvUJZsuR4XjYCbhrx-1DajdQtbLwHkZkvHzTu7PYHtK19k5RE6gG-4dR22Q_o6Z23CbQecff9_T2Wj9_pWOHej5DAhdai3PVOBeZ39G4F4zM243Y2yW8pWW3ALe0rAsws5UGt67P8HfdwtV2z3umbmsxX7m3WeDSKbpU_hrN8H2YLLjIACdFfbmi1SY4WiK7X2yrmarN8ML4z1Vyv4qp2oRX1LENQGNueLaQSTgOzqa19c-loxM9TUjvzTmmaRM76AbjarCjKj12aPjneXRKPr2bfnG-W5pf7IuXacgwZ4IZ5HtgIpVK-aMkU6CyDdDhaacadXuGwur2oT6p6NI1CVc1lQ3gg0eSAqFkmKIlAiucYVJtgIlcXuaClf1Ey_pze_3VyngIB_eIG8rZP5Z_ZImKGiaFL-i4dxQUk3ASvI7HSYbJdJrgODjKkjY_SBj2JEObWNGCRIuvn_7z6fPfn-D5eQ5_zR-_Pjiu6JR2k3nXsp1_C9ZMEy8bJurz-0m3UWtkIsPXDtybXYl1bw4rybOey_Gyll7N149fnx6c_krQhLujxVzy7BTE9_Zngtw65vrOuF-CJJxb6bXQqAy8v0RxkqRBb__lEZ7q3vv6Re658C-nn7Xr51Kw8e-YqN5OQ09XP51wb6Xa4T3VTy37_Kh1aBPn-eti8fD87NAOzm-p-oYZcBsYSPaOGQxVGzS_ahXOGtQc3dKy5AyzZquTV5zvWyrtif0SijoiwIWseAZU7BOZ7cEg57BF2BXUWEbdKSk29Wm1KVB3j469O3oAtgkr5A7wlaaG70EXDnPdbFA7p34kXLU70tVNNouyaTSlNzgb3sXBZBxMotFNMQunaRJOcjrK4nAa5sNgMpyOsnF8h6O7PI7pDZuFQRgO7b9oGI1HgynF6QgneRrjGDGeklGAW8r4wHUtUm1umNYVzsbT0d30htMEuW7-eqJmdtJtUm00GQWcaaMPYoYZjrN1-4pqXkc0N6jaZvOmUnxWGFO6ntMFe8NMUSWDVG5JuLJw_uu2VPJ_7hW4ciZpEq6cVf8PAAD___6xTU4">