Code for RunJIT of my model with an argument

My model has a 1x1x4x4 input matrix as an argument, and it returns 1x1x2x2 result matrix.
I don’t know how to run JIT of my model after transforming it to LLVM IR.
My runJIT function is as follows, and it returns segmentation fault.
Could you please help me to write a code for runJIT?


double input[16];
for (int i = 0 ; i < 16 ; i++){
input[i] = (double)i;
}
double result[4];
void *args[2] = {&input, &result};

auto invocationResult = engine->invokePacked(“test”, args);


[History: Lowering Process]
Through slight modification of lexer and parser, I dumped myIR consisting of myIR Dialect.


builtin.func @test(%arg0: tensor<1x1x4x4xf64>) -> tensor<1x1x2x2xf64> {
  %0 = myIR.constant dense<2.737000e-01> : tensor<1xf64>
  %1 = myIR.constant dense<[[[[2.878000e-01, -2.072000e-01, 4.040000e-02], [8.530000e-02, -1.880000e-01, 2.081000e-01], [2.921000e-01, -3.161000e-01, 1.276000e-01]]]]> : tensor<1x1x3x3xf64>
  %2 = "myIR.convolution"(%arg0, %1, %0) {allow_tf32 = true, benchmark = false, cudnn_enabled = true, deterministic = false, dilation = [1, 1], groups = 1 : i64, output_padding = [0, 0], output_shape = [1, 1, 2, 2], padding = [0, 0, 0, 0], stride = [1, 1], transposed = false} : (tensor<1x1x4x4xf64>, tensor<1x1x3x3xf64>, tensor<1xf64>) -> tensor<1x1x2x2xf64>
  myIR.return %2 : tensor<1x1x2x2xf64>
}

And also I transformed myIR to another IR using affine, standard, memref dialects as follows.



builtin.func @test(%arg0: memref<1x1x4x4xf64>) -> memref<1x1x2x2xf64> {
  %0 = memref.alloc() : memref<1x1x4x4xf64>
  %1 = memref.alloc() : memref<1x1x2x2xf64>
  %2 = memref.alloc() : memref<1x1x3x3xf64>
  %3 = memref.alloc() : memref<1xf64>
  %c0 = constant 0 : index
  %cst = constant 2.737000e-01 : f64
  affine.store %cst, %3[%c0] : memref<1xf64>
  %c0_0 = constant 0 : index
  %c1 = constant 1 : index
  %c2 = constant 2 : index
  %cst_1 = constant 2.878000e-01 : f64
  affine.store %cst_1, %2[%c0_0, %c0_0, %c0_0, %c0_0] : memref<1x1x3x3xf64>
  %cst_2 = constant -2.072000e-01 : f64
  affine.store %cst_2, %2[%c0_0, %c0_0, %c0_0, %c1] : memref<1x1x3x3xf64>
  %cst_3 = constant 4.040000e-02 : f64
  affine.store %cst_3, %2[%c0_0, %c0_0, %c0_0, %c2] : memref<1x1x3x3xf64>
  %cst_4 = constant 8.530000e-02 : f64
  affine.store %cst_4, %2[%c0_0, %c0_0, %c1, %c0_0] : memref<1x1x3x3xf64>
  %cst_5 = constant -1.880000e-01 : f64
  affine.store %cst_5, %2[%c0_0, %c0_0, %c1, %c1] : memref<1x1x3x3xf64>
  %cst_6 = constant 2.081000e-01 : f64
  affine.store %cst_6, %2[%c0_0, %c0_0, %c1, %c2] : memref<1x1x3x3xf64>
  %cst_7 = constant 2.921000e-01 : f64
  affine.store %cst_7, %2[%c0_0, %c0_0, %c2, %c0_0] : memref<1x1x3x3xf64>
  %cst_8 = constant -3.161000e-01 : f64
  affine.store %cst_8, %2[%c0_0, %c0_0, %c2, %c1] : memref<1x1x3x3xf64>
  %cst_9 = constant 1.276000e-01 : f64
  affine.store %cst_9, %2[%c0_0, %c0_0, %c2, %c2] : memref<1x1x3x3xf64>
  affine.for %arg1 = 0 to 1 {
    affine.for %arg2 = 0 to 1 {
      affine.for %arg3 = 0 to 2 {
        affine.for %arg4 = 0 to 2 {
          %cst_10 = constant 0.000000e+00 : f64
          affine.store %cst_10, %1[%arg1, %arg2, %arg3, %arg4] : memref<1x1x2x2xf64>
          affine.for %arg5 = 0 to 1 {
            affine.for %arg6 = 0 to 1 {
              affine.for %arg7 = 0 to 3 {
                affine.for %arg8 = 0 to 3 {
                  %7 = affine.apply affine_map<(d0, d1, d2, d3) -> (d0)>(%arg1, %arg2, %arg3, %arg4)
                  %8 = affine.apply affine_map<(d0, d1, d2, d3) -> (d1)>(%arg1, %arg2, %arg3, %arg4)
                  %9 = affine.apply affine_map<(d0, d1, d2, d3) -> (d2)>(%arg1, %arg2, %arg3, %arg4)
                  %10 = affine.apply affine_map<(d0, d1, d2, d3) -> (d3)>(%arg1, %arg2, %arg3, %arg4)
                  %11 = affine.load %0[%arg5 + %arg1, %arg6 + %arg2, %arg7 + %arg3, %arg8 + %arg4] : memref<1x1x4x4xf64>
                  %12 = affine.load %2[%arg5, %arg6, %arg7, %arg8] : memref<1x1x3x3xf64>
                  %13 = mulf %11, %12 : f64
                  %14 = affine.load %1[%arg1, %arg2, %arg3, %arg4] : memref<1x1x2x2xf64>
                  %15 = addf %14, %13 : f64
                  affine.store %15, %1[%arg1, %arg2, %arg3, %arg4] : memref<1x1x2x2xf64>
                }
              }
            }
          }
          %4 = affine.load %1[%arg1, %arg2, %arg3, %arg4] : memref<1x1x2x2xf64>
          %5 = affine.load %3[%arg2] : memref<1xf64>
          %6 = addf %4, %5 : f64
          affine.store %6, %1[%arg1, %arg2, %arg3, %arg4] : memref<1x1x2x2xf64>
        }
      }
    }
  }
  memref.dealloc %3 : memref<1xf64>
  memref.dealloc %2 : memref<1x1x3x3xf64>
  memref.dealloc %1 : memref<1x1x2x2xf64>
  memref.dealloc %0 : memref<1x1x4x4xf64>
  return %1 : memref<1x1x2x2xf64>
}

Finally, I have the following LLVM IR.



builtin.module  {
  llvm.func @free(!llvm.ptr<i8>)
  llvm.func @malloc(i64) -> !llvm.ptr<i8>
  llvm.func @test(%arg0: !llvm.ptr<f64>, %arg1: !llvm.ptr<f64>, %arg2: i64, %arg3: i64, %arg4: i64, %arg5: i64, %arg6: i64, %arg7: i64, %arg8: i64, %arg9: i64, %arg10: i64) -> !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)> {
    %0 = llvm.mlir.undef : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %1 = llvm.insertvalue %arg0, %0[0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %2 = llvm.insertvalue %arg1, %1[1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %3 = llvm.insertvalue %arg2, %2[2] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %4 = llvm.insertvalue %arg3, %3[3, 0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %5 = llvm.insertvalue %arg7, %4[4, 0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %6 = llvm.insertvalue %arg4, %5[3, 1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %7 = llvm.insertvalue %arg8, %6[4, 1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %8 = llvm.insertvalue %arg5, %7[3, 2] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %9 = llvm.insertvalue %arg9, %8[4, 2] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %10 = llvm.insertvalue %arg6, %9[3, 3] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %11 = llvm.insertvalue %arg10, %10[4, 3] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %12 = llvm.mlir.constant(0.000000e+00 : f64) : f64
    %13 = llvm.mlir.constant(1.276000e-01 : f64) : f64
    %14 = llvm.mlir.constant(-3.161000e-01 : f64) : f64
    %15 = llvm.mlir.constant(2.921000e-01 : f64) : f64
    %16 = llvm.mlir.constant(2.081000e-01 : f64) : f64
    %17 = llvm.mlir.constant(-1.880000e-01 : f64) : f64
    %18 = llvm.mlir.constant(8.530000e-02 : f64) : f64
    %19 = llvm.mlir.constant(4.040000e-02 : f64) : f64
    %20 = llvm.mlir.constant(-2.072000e-01 : f64) : f64
    %21 = llvm.mlir.constant(2.878000e-01 : f64) : f64
    %22 = llvm.mlir.constant(2.737000e-01 : f64) : f64
    %23 = llvm.mlir.constant(1 : index) : i64
    %24 = llvm.mlir.constant(1 : index) : i64
    %25 = llvm.mlir.constant(4 : index) : i64
    %26 = llvm.mlir.constant(4 : index) : i64
    %27 = llvm.mlir.constant(1 : index) : i64
    %28 = llvm.mlir.constant(16 : index) : i64
    %29 = llvm.mlir.constant(16 : index) : i64
    %30 = llvm.mlir.constant(16 : index) : i64
    %31 = llvm.mlir.null : !llvm.ptr<f64>
    %32 = llvm.getelementptr %31[%30] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64>
    %33 = llvm.ptrtoint %32 : !llvm.ptr<f64> to i64
    %34 = llvm.call @malloc(%33) : (i64) -> !llvm.ptr<i8>
    %35 = llvm.bitcast %34 : !llvm.ptr<i8> to !llvm.ptr<f64>
    %36 = llvm.mlir.undef : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %37 = llvm.insertvalue %35, %36[0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %38 = llvm.insertvalue %35, %37[1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %39 = llvm.mlir.constant(0 : index) : i64
    %40 = llvm.insertvalue %39, %38[2] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %41 = llvm.insertvalue %23, %40[3, 0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %42 = llvm.insertvalue %24, %41[3, 1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %43 = llvm.insertvalue %25, %42[3, 2] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %44 = llvm.insertvalue %26, %43[3, 3] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %45 = llvm.insertvalue %29, %44[4, 0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %46 = llvm.insertvalue %28, %45[4, 1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %47 = llvm.insertvalue %26, %46[4, 2] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %48 = llvm.insertvalue %27, %47[4, 3] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %49 = llvm.mlir.constant(1 : index) : i64
    %50 = llvm.mlir.constant(1 : index) : i64
    %51 = llvm.mlir.constant(2 : index) : i64
    %52 = llvm.mlir.constant(2 : index) : i64
    %53 = llvm.mlir.constant(1 : index) : i64
    %54 = llvm.mlir.constant(4 : index) : i64
    %55 = llvm.mlir.constant(4 : index) : i64
    %56 = llvm.mlir.constant(4 : index) : i64
    %57 = llvm.mlir.null : !llvm.ptr<f64>
    %58 = llvm.getelementptr %57[%56] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64>
    %59 = llvm.ptrtoint %58 : !llvm.ptr<f64> to i64
    %60 = llvm.call @malloc(%59) : (i64) -> !llvm.ptr<i8>
    %61 = llvm.bitcast %60 : !llvm.ptr<i8> to !llvm.ptr<f64>
    %62 = llvm.mlir.undef : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %63 = llvm.insertvalue %61, %62[0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %64 = llvm.insertvalue %61, %63[1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %65 = llvm.mlir.constant(0 : index) : i64
    %66 = llvm.insertvalue %65, %64[2] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %67 = llvm.insertvalue %49, %66[3, 0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %68 = llvm.insertvalue %50, %67[3, 1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %69 = llvm.insertvalue %51, %68[3, 2] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %70 = llvm.insertvalue %52, %69[3, 3] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %71 = llvm.insertvalue %55, %70[4, 0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %72 = llvm.insertvalue %54, %71[4, 1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %73 = llvm.insertvalue %52, %72[4, 2] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %74 = llvm.insertvalue %53, %73[4, 3] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %75 = llvm.mlir.constant(1 : index) : i64
    %76 = llvm.mlir.constant(1 : index) : i64
    %77 = llvm.mlir.constant(3 : index) : i64
    %78 = llvm.mlir.constant(3 : index) : i64
    %79 = llvm.mlir.constant(1 : index) : i64
    %80 = llvm.mlir.constant(9 : index) : i64
    %81 = llvm.mlir.constant(9 : index) : i64
    %82 = llvm.mlir.constant(9 : index) : i64
    %83 = llvm.mlir.null : !llvm.ptr<f64>
    %84 = llvm.getelementptr %83[%82] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64>
    %85 = llvm.ptrtoint %84 : !llvm.ptr<f64> to i64
    %86 = llvm.call @malloc(%85) : (i64) -> !llvm.ptr<i8>
    %87 = llvm.bitcast %86 : !llvm.ptr<i8> to !llvm.ptr<f64>
    %88 = llvm.mlir.undef : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %89 = llvm.insertvalue %87, %88[0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %90 = llvm.insertvalue %87, %89[1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %91 = llvm.mlir.constant(0 : index) : i64
    %92 = llvm.insertvalue %91, %90[2] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %93 = llvm.insertvalue %75, %92[3, 0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %94 = llvm.insertvalue %76, %93[3, 1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %95 = llvm.insertvalue %77, %94[3, 2] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %96 = llvm.insertvalue %78, %95[3, 3] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %97 = llvm.insertvalue %81, %96[4, 0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %98 = llvm.insertvalue %80, %97[4, 1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %99 = llvm.insertvalue %78, %98[4, 2] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %100 = llvm.insertvalue %79, %99[4, 3] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %101 = llvm.mlir.constant(1 : index) : i64
    %102 = llvm.mlir.constant(1 : index) : i64
    %103 = llvm.mlir.null : !llvm.ptr<f64>
    %104 = llvm.getelementptr %103[%101] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64>
    %105 = llvm.ptrtoint %104 : !llvm.ptr<f64> to i64
    %106 = llvm.call @malloc(%105) : (i64) -> !llvm.ptr<i8>
    %107 = llvm.bitcast %106 : !llvm.ptr<i8> to !llvm.ptr<f64>
    %108 = llvm.mlir.undef : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<1 x i64>, array<1 x i64>)>
    %109 = llvm.insertvalue %107, %108[0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<1 x i64>, array<1 x i64>)>
    %110 = llvm.insertvalue %107, %109[1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<1 x i64>, array<1 x i64>)>
    %111 = llvm.mlir.constant(0 : index) : i64
    %112 = llvm.insertvalue %111, %110[2] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<1 x i64>, array<1 x i64>)>
    %113 = llvm.insertvalue %101, %112[3, 0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<1 x i64>, array<1 x i64>)>
    %114 = llvm.insertvalue %102, %113[4, 0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<1 x i64>, array<1 x i64>)>
    %115 = llvm.mlir.constant(0 : index) : i64
    %116 = llvm.extractvalue %114[1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<1 x i64>, array<1 x i64>)>
    %117 = llvm.getelementptr %116[%115] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64>
    llvm.store %22, %117 : !llvm.ptr<f64>
    %118 = llvm.mlir.constant(0 : index) : i64
    %119 = llvm.mlir.constant(0 : index) : i64
    %120 = llvm.mlir.constant(0 : index) : i64
    %121 = llvm.mlir.constant(0 : index) : i64
    %122 = llvm.extractvalue %100[1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %123 = llvm.mlir.constant(9 : index) : i64
    %124 = llvm.mul %118, %123  : i64
    %125 = llvm.mlir.constant(9 : index) : i64
    %126 = llvm.mul %119, %125  : i64
    %127 = llvm.add %124, %126  : i64
    %128 = llvm.mlir.constant(3 : index) : i64
    %129 = llvm.mul %120, %128  : i64
    %130 = llvm.add %127, %129  : i64
    %131 = llvm.add %130, %121  : i64
    %132 = llvm.getelementptr %122[%131] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64>
    llvm.store %21, %132 : !llvm.ptr<f64>
    %133 = llvm.mlir.constant(0 : index) : i64
    %134 = llvm.mlir.constant(0 : index) : i64
    %135 = llvm.mlir.constant(0 : index) : i64
    %136 = llvm.mlir.constant(1 : index) : i64
    %137 = llvm.extractvalue %100[1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %138 = llvm.mlir.constant(9 : index) : i64
    %139 = llvm.mul %133, %138  : i64
    %140 = llvm.mlir.constant(9 : index) : i64
    %141 = llvm.mul %134, %140  : i64
    %142 = llvm.add %139, %141  : i64
    %143 = llvm.mlir.constant(3 : index) : i64
    %144 = llvm.mul %135, %143  : i64
    %145 = llvm.add %142, %144  : i64
    %146 = llvm.add %145, %136  : i64
    %147 = llvm.getelementptr %137[%146] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64>
    llvm.store %20, %147 : !llvm.ptr<f64>
    %148 = llvm.mlir.constant(0 : index) : i64
    %149 = llvm.mlir.constant(0 : index) : i64
    %150 = llvm.mlir.constant(0 : index) : i64
    %151 = llvm.mlir.constant(2 : index) : i64
    %152 = llvm.extractvalue %100[1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %153 = llvm.mlir.constant(9 : index) : i64
    %154 = llvm.mul %148, %153  : i64
    %155 = llvm.mlir.constant(9 : index) : i64
    %156 = llvm.mul %149, %155  : i64
    %157 = llvm.add %154, %156  : i64
    %158 = llvm.mlir.constant(3 : index) : i64
    %159 = llvm.mul %150, %158  : i64
    %160 = llvm.add %157, %159  : i64
    %161 = llvm.add %160, %151  : i64
    %162 = llvm.getelementptr %152[%161] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64>
    llvm.store %19, %162 : !llvm.ptr<f64>
    %163 = llvm.mlir.constant(0 : index) : i64
    %164 = llvm.mlir.constant(0 : index) : i64
    %165 = llvm.mlir.constant(1 : index) : i64
    %166 = llvm.mlir.constant(0 : index) : i64
    %167 = llvm.extractvalue %100[1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %168 = llvm.mlir.constant(9 : index) : i64
    %169 = llvm.mul %163, %168  : i64
    %170 = llvm.mlir.constant(9 : index) : i64
    %171 = llvm.mul %164, %170  : i64
    %172 = llvm.add %169, %171  : i64
    %173 = llvm.mlir.constant(3 : index) : i64
    %174 = llvm.mul %165, %173  : i64
    %175 = llvm.add %172, %174  : i64
    %176 = llvm.add %175, %166  : i64
    %177 = llvm.getelementptr %167[%176] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64>
    llvm.store %18, %177 : !llvm.ptr<f64>
    %178 = llvm.mlir.constant(0 : index) : i64
    %179 = llvm.mlir.constant(0 : index) : i64
    %180 = llvm.mlir.constant(1 : index) : i64
    %181 = llvm.mlir.constant(1 : index) : i64
    %182 = llvm.extractvalue %100[1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %183 = llvm.mlir.constant(9 : index) : i64
    %184 = llvm.mul %178, %183  : i64
    %185 = llvm.mlir.constant(9 : index) : i64
    %186 = llvm.mul %179, %185  : i64
    %187 = llvm.add %184, %186  : i64
    %188 = llvm.mlir.constant(3 : index) : i64
    %189 = llvm.mul %180, %188  : i64
    %190 = llvm.add %187, %189  : i64
    %191 = llvm.add %190, %181  : i64
    %192 = llvm.getelementptr %182[%191] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64>
    llvm.store %17, %192 : !llvm.ptr<f64>
    %193 = llvm.mlir.constant(0 : index) : i64
    %194 = llvm.mlir.constant(0 : index) : i64
    %195 = llvm.mlir.constant(1 : index) : i64
    %196 = llvm.mlir.constant(2 : index) : i64
    %197 = llvm.extractvalue %100[1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %198 = llvm.mlir.constant(9 : index) : i64
    %199 = llvm.mul %193, %198  : i64
    %200 = llvm.mlir.constant(9 : index) : i64
    %201 = llvm.mul %194, %200  : i64
    %202 = llvm.add %199, %201  : i64
    %203 = llvm.mlir.constant(3 : index) : i64
    %204 = llvm.mul %195, %203  : i64
    %205 = llvm.add %202, %204  : i64
    %206 = llvm.add %205, %196  : i64
    %207 = llvm.getelementptr %197[%206] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64>
    llvm.store %16, %207 : !llvm.ptr<f64>
    %208 = llvm.mlir.constant(0 : index) : i64
    %209 = llvm.mlir.constant(0 : index) : i64
    %210 = llvm.mlir.constant(2 : index) : i64
    %211 = llvm.mlir.constant(0 : index) : i64
    %212 = llvm.extractvalue %100[1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %213 = llvm.mlir.constant(9 : index) : i64
    %214 = llvm.mul %208, %213  : i64
    %215 = llvm.mlir.constant(9 : index) : i64
    %216 = llvm.mul %209, %215  : i64
    %217 = llvm.add %214, %216  : i64
    %218 = llvm.mlir.constant(3 : index) : i64
    %219 = llvm.mul %210, %218  : i64
    %220 = llvm.add %217, %219  : i64
    %221 = llvm.add %220, %211  : i64
    %222 = llvm.getelementptr %212[%221] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64>
    llvm.store %15, %222 : !llvm.ptr<f64>
    %223 = llvm.mlir.constant(0 : index) : i64
    %224 = llvm.mlir.constant(0 : index) : i64
    %225 = llvm.mlir.constant(2 : index) : i64
    %226 = llvm.mlir.constant(1 : index) : i64
    %227 = llvm.extractvalue %100[1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %228 = llvm.mlir.constant(9 : index) : i64
    %229 = llvm.mul %223, %228  : i64
    %230 = llvm.mlir.constant(9 : index) : i64
    %231 = llvm.mul %224, %230  : i64
    %232 = llvm.add %229, %231  : i64
    %233 = llvm.mlir.constant(3 : index) : i64
    %234 = llvm.mul %225, %233  : i64
    %235 = llvm.add %232, %234  : i64
    %236 = llvm.add %235, %226  : i64
    %237 = llvm.getelementptr %227[%236] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64>
    llvm.store %14, %237 : !llvm.ptr<f64>
    %238 = llvm.mlir.constant(0 : index) : i64
    %239 = llvm.mlir.constant(0 : index) : i64
    %240 = llvm.mlir.constant(2 : index) : i64
    %241 = llvm.mlir.constant(2 : index) : i64
    %242 = llvm.extractvalue %100[1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %243 = llvm.mlir.constant(9 : index) : i64
    %244 = llvm.mul %238, %243  : i64
    %245 = llvm.mlir.constant(9 : index) : i64
    %246 = llvm.mul %239, %245  : i64
    %247 = llvm.add %244, %246  : i64
    %248 = llvm.mlir.constant(3 : index) : i64
    %249 = llvm.mul %240, %248  : i64
    %250 = llvm.add %247, %249  : i64
    %251 = llvm.add %250, %241  : i64
    %252 = llvm.getelementptr %242[%251] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64>
    llvm.store %13, %252 : !llvm.ptr<f64>
    %253 = llvm.mlir.constant(0 : index) : i64
    %254 = llvm.mlir.constant(1 : index) : i64
    %255 = llvm.mlir.constant(1 : index) : i64
    llvm.br ^bb1(%253 : i64)
  ^bb1(%256: i64):  // 2 preds: ^bb0, ^bb23
    %257 = llvm.icmp "slt" %256, %254 : i64
    llvm.cond_br %257, ^bb2, ^bb24
  ^bb2:  // pred: ^bb1
    %258 = llvm.mlir.constant(0 : index) : i64
    %259 = llvm.mlir.constant(1 : index) : i64
    %260 = llvm.mlir.constant(1 : index) : i64
    llvm.br ^bb3(%258 : i64)
  ^bb3(%261: i64):  // 2 preds: ^bb2, ^bb22
    %262 = llvm.icmp "slt" %261, %259 : i64
    llvm.cond_br %262, ^bb4, ^bb23
  ^bb4:  // pred: ^bb3
    %263 = llvm.mlir.constant(0 : index) : i64
    %264 = llvm.mlir.constant(2 : index) : i64
    %265 = llvm.mlir.constant(1 : index) : i64
    llvm.br ^bb5(%263 : i64)
  ^bb5(%266: i64):  // 2 preds: ^bb4, ^bb21
    %267 = llvm.icmp "slt" %266, %264 : i64
    llvm.cond_br %267, ^bb6, ^bb22
  ^bb6:  // pred: ^bb5
    %268 = llvm.mlir.constant(0 : index) : i64
    %269 = llvm.mlir.constant(2 : index) : i64
    %270 = llvm.mlir.constant(1 : index) : i64
    llvm.br ^bb7(%268 : i64)
  ^bb7(%271: i64):  // 2 preds: ^bb6, ^bb20
    %272 = llvm.icmp "slt" %271, %269 : i64
    llvm.cond_br %272, ^bb8, ^bb21
  ^bb8:  // pred: ^bb7
    %273 = llvm.extractvalue %74[1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %274 = llvm.mlir.constant(4 : index) : i64
    %275 = llvm.mul %256, %274  : i64
    %276 = llvm.mlir.constant(4 : index) : i64
    %277 = llvm.mul %261, %276  : i64
    %278 = llvm.add %275, %277  : i64
    %279 = llvm.mlir.constant(2 : index) : i64
    %280 = llvm.mul %266, %279  : i64
    %281 = llvm.add %278, %280  : i64
    %282 = llvm.add %281, %271  : i64
    %283 = llvm.getelementptr %273[%282] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64>
    llvm.store %12, %283 : !llvm.ptr<f64>
    %284 = llvm.mlir.constant(0 : index) : i64
    %285 = llvm.mlir.constant(1 : index) : i64
    %286 = llvm.mlir.constant(1 : index) : i64
    llvm.br ^bb9(%284 : i64)
  ^bb9(%287: i64):  // 2 preds: ^bb8, ^bb19
    %288 = llvm.icmp "slt" %287, %285 : i64
    llvm.cond_br %288, ^bb10, ^bb20
  ^bb10:  // pred: ^bb9
    %289 = llvm.mlir.constant(0 : index) : i64
    %290 = llvm.mlir.constant(1 : index) : i64
    %291 = llvm.mlir.constant(1 : index) : i64
    llvm.br ^bb11(%289 : i64)
  ^bb11(%292: i64):  // 2 preds: ^bb10, ^bb18
    %293 = llvm.icmp "slt" %292, %290 : i64
    llvm.cond_br %293, ^bb12, ^bb19
  ^bb12:  // pred: ^bb11
    %294 = llvm.mlir.constant(0 : index) : i64
    %295 = llvm.mlir.constant(3 : index) : i64
    %296 = llvm.mlir.constant(1 : index) : i64
    llvm.br ^bb13(%294 : i64)
  ^bb13(%297: i64):  // 2 preds: ^bb12, ^bb17
    %298 = llvm.icmp "slt" %297, %295 : i64
    llvm.cond_br %298, ^bb14, ^bb18
  ^bb14:  // pred: ^bb13
    %299 = llvm.mlir.constant(0 : index) : i64
    %300 = llvm.mlir.constant(3 : index) : i64
    %301 = llvm.mlir.constant(1 : index) : i64
    llvm.br ^bb15(%299 : i64)
  ^bb15(%302: i64):  // 2 preds: ^bb14, ^bb16
    %303 = llvm.icmp "slt" %302, %300 : i64
    llvm.cond_br %303, ^bb16, ^bb17
  ^bb16:  // pred: ^bb15
    %304 = llvm.add %287, %256  : i64
    %305 = llvm.add %292, %261  : i64
    %306 = llvm.add %297, %266  : i64
    %307 = llvm.add %302, %271  : i64
    %308 = llvm.extractvalue %48[1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %309 = llvm.mlir.constant(16 : index) : i64
    %310 = llvm.mul %304, %309  : i64
    %311 = llvm.mlir.constant(16 : index) : i64
    %312 = llvm.mul %305, %311  : i64
    %313 = llvm.add %310, %312  : i64
    %314 = llvm.mlir.constant(4 : index) : i64
    %315 = llvm.mul %306, %314  : i64
    %316 = llvm.add %313, %315  : i64
    %317 = llvm.add %316, %307  : i64
    %318 = llvm.getelementptr %308[%317] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64>
    %319 = llvm.load %318 : !llvm.ptr<f64>
    %320 = llvm.extractvalue %100[1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %321 = llvm.mlir.constant(9 : index) : i64
    %322 = llvm.mul %287, %321  : i64
    %323 = llvm.mlir.constant(9 : index) : i64
    %324 = llvm.mul %292, %323  : i64
    %325 = llvm.add %322, %324  : i64
    %326 = llvm.mlir.constant(3 : index) : i64
    %327 = llvm.mul %297, %326  : i64
    %328 = llvm.add %325, %327  : i64
    %329 = llvm.add %328, %302  : i64
    %330 = llvm.getelementptr %320[%329] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64>
    %331 = llvm.load %330 : !llvm.ptr<f64>
    %332 = llvm.fmul %319, %331  : f64
    %333 = llvm.extractvalue %74[1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %334 = llvm.mlir.constant(4 : index) : i64
    %335 = llvm.mul %256, %334  : i64
    %336 = llvm.mlir.constant(4 : index) : i64
    %337 = llvm.mul %261, %336  : i64
    %338 = llvm.add %335, %337  : i64
    %339 = llvm.mlir.constant(2 : index) : i64
    %340 = llvm.mul %266, %339  : i64
    %341 = llvm.add %338, %340  : i64
    %342 = llvm.add %341, %271  : i64
    %343 = llvm.getelementptr %333[%342] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64>
    %344 = llvm.load %343 : !llvm.ptr<f64>
    %345 = llvm.fadd %344, %332  : f64
    %346 = llvm.extractvalue %74[1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %347 = llvm.mlir.constant(4 : index) : i64
    %348 = llvm.mul %256, %347  : i64
    %349 = llvm.mlir.constant(4 : index) : i64
    %350 = llvm.mul %261, %349  : i64
    %351 = llvm.add %348, %350  : i64
    %352 = llvm.mlir.constant(2 : index) : i64
    %353 = llvm.mul %266, %352  : i64
    %354 = llvm.add %351, %353  : i64
    %355 = llvm.add %354, %271  : i64
    %356 = llvm.getelementptr %346[%355] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64>
    llvm.store %345, %356 : !llvm.ptr<f64>
    %357 = llvm.add %302, %301  : i64
    llvm.br ^bb15(%357 : i64)
  ^bb17:  // pred: ^bb15
    %358 = llvm.add %297, %296  : i64
    llvm.br ^bb13(%358 : i64)
  ^bb18:  // pred: ^bb13
    %359 = llvm.add %292, %291  : i64
    llvm.br ^bb11(%359 : i64)
  ^bb19:  // pred: ^bb11
    %360 = llvm.add %287, %286  : i64
    llvm.br ^bb9(%360 : i64)
  ^bb20:  // pred: ^bb9
    %361 = llvm.extractvalue %74[1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %362 = llvm.mlir.constant(4 : index) : i64
    %363 = llvm.mul %256, %362  : i64
    %364 = llvm.mlir.constant(4 : index) : i64
    %365 = llvm.mul %261, %364  : i64
    %366 = llvm.add %363, %365  : i64
    %367 = llvm.mlir.constant(2 : index) : i64
    %368 = llvm.mul %266, %367  : i64
    %369 = llvm.add %366, %368  : i64
    %370 = llvm.add %369, %271  : i64
    %371 = llvm.getelementptr %361[%370] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64>
    %372 = llvm.load %371 : !llvm.ptr<f64>
    %373 = llvm.extractvalue %114[1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<1 x i64>, array<1 x i64>)>
    %374 = llvm.getelementptr %373[%261] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64>
    %375 = llvm.load %374 : !llvm.ptr<f64>
    %376 = llvm.fadd %372, %375  : f64
    %377 = llvm.extractvalue %74[1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %378 = llvm.mlir.constant(4 : index) : i64
    %379 = llvm.mul %256, %378  : i64
    %380 = llvm.mlir.constant(4 : index) : i64
    %381 = llvm.mul %261, %380  : i64
    %382 = llvm.add %379, %381  : i64
    %383 = llvm.mlir.constant(2 : index) : i64
    %384 = llvm.mul %266, %383  : i64
    %385 = llvm.add %382, %384  : i64
    %386 = llvm.add %385, %271  : i64
    %387 = llvm.getelementptr %377[%386] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64>
    llvm.store %376, %387 : !llvm.ptr<f64>
    %388 = llvm.add %271, %270  : i64
    llvm.br ^bb7(%388 : i64)
  ^bb21:  // pred: ^bb7
    %389 = llvm.add %266, %265  : i64
    llvm.br ^bb5(%389 : i64)
  ^bb22:  // pred: ^bb5
    %390 = llvm.add %261, %260  : i64
    llvm.br ^bb3(%390 : i64)
  ^bb23:  // pred: ^bb3
    %391 = llvm.add %256, %255  : i64
    llvm.br ^bb1(%391 : i64)
  ^bb24:  // pred: ^bb1
    %392 = llvm.extractvalue %114[0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<1 x i64>, array<1 x i64>)>
    %393 = llvm.bitcast %392 : !llvm.ptr<f64> to !llvm.ptr<i8>
    llvm.call @free(%393) : (!llvm.ptr<i8>) -> ()
    %394 = llvm.extractvalue %100[0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %395 = llvm.bitcast %394 : !llvm.ptr<f64> to !llvm.ptr<i8>
    llvm.call @free(%395) : (!llvm.ptr<i8>) -> ()
    %396 = llvm.extractvalue %74[0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %397 = llvm.bitcast %396 : !llvm.ptr<f64> to !llvm.ptr<i8>
    llvm.call @free(%397) : (!llvm.ptr<i8>) -> ()
    %398 = llvm.extractvalue %48[0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
    %399 = llvm.bitcast %398 : !llvm.ptr<f64> to !llvm.ptr<i8>
    llvm.call @free(%399) : (!llvm.ptr<i8>) -> ()
    llvm.return %74 : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<4 x i64>, array<4 x i64>)>
  }
}

The arguments you are passing aren’t going to match the lowering of MLIR memrefs. Please see:

and the surrounding documentation. Also, could you please reformat your message?

This would be completely unrelated to the subject of this post. Could you please create a new post and copy/paste?