-
-
Save silvasean/683adcb9daa95de3700f999777fd61ea to your computer and use it in GitHub Desktop.
TensorRewriteAdaptor error
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| // *** IR Dump Before mlir::iree_compiler::IREE::HAL::(anonymous namespace)::ConvertToHALPass *** | |
| #map = affine_map<()[s0] -> (s0 ceildiv 64)> | |
| module { | |
| hal.executable @forward_dispatch_0 attributes {sym_visibility = "private"} { | |
| hal.interface @legacy_io attributes {push_constants = 2 : index} { | |
| hal.interface.binding @rw0, set=0, binding=0, type="StorageBuffer", access="Read|Write" | |
| } | |
| hal.executable.target @llvm_aot, filter="dylib*" { | |
| hal.executable.entry_point @forward_dispatch_0 attributes {interface = @legacy_io, ordinal = 0 : index, signature = (!flow.dispatch.tensor<readwrite:?x?xf32>, index, index) -> ()} { | |
| ^bb0(%arg0: index, %arg1: index, %arg2: index): // no predecessors | |
| %c1 = constant 1 : index | |
| hal.return %c1, %c1, %c1 : index, index, index | |
| } | |
| module { | |
| llvm.func internal @forward_dispatch_0(%arg0: !llvm.ptr<struct<"iree_hal_executable_dispatch_state_v0_t", (array<3 x i32>, array<3 x i32>, i64, ptr<i32>, i64, ptr<ptr<i8>>, ptr<i64>)>>, %arg1: !llvm.ptr<array<3 x i32>>) -> i32 { | |
| %0 = llvm.mlir.constant(0.000000e+00 : f32) : f32 | |
| %1 = llvm.mlir.constant(0 : index) : i64 | |
| %2 = llvm.mlir.constant(1 : index) : i64 | |
| %3 = llvm.load %arg0 : !llvm.ptr<struct<"iree_hal_executable_dispatch_state_v0_t", (array<3 x i32>, array<3 x i32>, i64, ptr<i32>, i64, ptr<ptr<i8>>, ptr<i64>)>> | |
| %4 = llvm.extractvalue %3[5] : !llvm.struct<"iree_hal_executable_dispatch_state_v0_t", (array<3 x i32>, array<3 x i32>, i64, ptr<i32>, i64, ptr<ptr<i8>>, ptr<i64>)> | |
| %5 = llvm.getelementptr %4[%1] : (!llvm.ptr<ptr<i8>>, i64) -> !llvm.ptr<ptr<i8>> | |
| %6 = llvm.load %5 : !llvm.ptr<ptr<i8>> | |
| %7 = llvm.getelementptr %6[%1] : (!llvm.ptr<i8>, i64) -> !llvm.ptr<i8> | |
| %8 = llvm.bitcast %7 : !llvm.ptr<i8> to !llvm.ptr<f32> | |
| %9 = llvm.mlir.undef : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %10 = llvm.insertvalue %8, %9[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %11 = llvm.insertvalue %8, %10[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %12 = llvm.insertvalue %1, %11[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %13 = llvm.load %arg0 : !llvm.ptr<struct<"iree_hal_executable_dispatch_state_v0_t", (array<3 x i32>, array<3 x i32>, i64, ptr<i32>, i64, ptr<ptr<i8>>, ptr<i64>)>> | |
| %14 = llvm.extractvalue %13[3] : !llvm.struct<"iree_hal_executable_dispatch_state_v0_t", (array<3 x i32>, array<3 x i32>, i64, ptr<i32>, i64, ptr<ptr<i8>>, ptr<i64>)> | |
| %15 = llvm.getelementptr %14[%1] : (!llvm.ptr<i32>, i64) -> !llvm.ptr<i32> | |
| %16 = llvm.load %15 : !llvm.ptr<i32> | |
| %17 = llvm.zext %16 : i32 to i64 | |
| %18 = llvm.load %arg0 : !llvm.ptr<struct<"iree_hal_executable_dispatch_state_v0_t", (array<3 x i32>, array<3 x i32>, i64, ptr<i32>, i64, ptr<ptr<i8>>, ptr<i64>)>> | |
| %19 = llvm.extractvalue %18[3] : !llvm.struct<"iree_hal_executable_dispatch_state_v0_t", (array<3 x i32>, array<3 x i32>, i64, ptr<i32>, i64, ptr<ptr<i8>>, ptr<i64>)> | |
| %20 = llvm.getelementptr %19[%2] : (!llvm.ptr<i32>, i64) -> !llvm.ptr<i32> | |
| %21 = llvm.load %20 : !llvm.ptr<i32> | |
| %22 = llvm.zext %21 : i32 to i64 | |
| %23 = llvm.insertvalue %17, %12[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %24 = llvm.insertvalue %22, %23[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %25 = llvm.insertvalue %2, %24[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %26 = llvm.extractvalue %25[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %27 = llvm.extractvalue %25[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %28 = llvm.mul %26, %27 : i64 | |
| %29 = llvm.insertvalue %28, %25[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| llvm.br ^bb1(%1 : i64) | |
| ^bb1(%30: i64): // 2 preds: ^bb0, ^bb4 | |
| %31 = llvm.icmp "slt" %30, %17 : i64 | |
| llvm.cond_br %31, ^bb2(%1 : i64), ^bb5 | |
| ^bb2(%32: i64): // 2 preds: ^bb1, ^bb3 | |
| %33 = llvm.icmp "slt" %32, %22 : i64 | |
| llvm.cond_br %33, ^bb3, ^bb4 | |
| ^bb3: // pred: ^bb2 | |
| %34 = llvm.extractvalue %29[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %35 = llvm.extractvalue %29[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %36 = llvm.mul %30, %35 : i64 | |
| %37 = llvm.add %36, %32 : i64 | |
| %38 = llvm.getelementptr %34[%37] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32> | |
| llvm.store %0, %38 : !llvm.ptr<f32> | |
| %39 = llvm.add %32, %2 : i64 | |
| llvm.br ^bb2(%39 : i64) | |
| ^bb4: // pred: ^bb2 | |
| %40 = llvm.add %30, %2 : i64 | |
| llvm.br ^bb1(%40 : i64) | |
| ^bb5: // pred: ^bb1 | |
| %41 = llvm.mlir.constant(0 : i32) : i32 | |
| llvm.return %41 : i32 | |
| } | |
| } | |
| } | |
| } | |
| hal.executable @forward_dispatch_1 attributes {sym_visibility = "private"} { | |
| hal.interface @legacy_io attributes {push_constants = 8 : index} { | |
| hal.interface.binding @ro0, set=0, binding=0, type="StorageBuffer", access="Read" | |
| hal.interface.binding @ro1, set=0, binding=1, type="StorageBuffer", access="Read" | |
| hal.interface.binding @ro2, set=0, binding=2, type="StorageBuffer", access="Read" | |
| hal.interface.binding @wo3, set=0, binding=3, type="StorageBuffer", access="Write|Discard" | |
| } | |
| hal.executable.target @llvm_aot, filter="dylib*" { | |
| hal.executable.entry_point @forward_dispatch_1 attributes {interface = @legacy_io, ordinal = 0 : index, signature = (!flow.dispatch.tensor<readonly:?x?xf32>, !flow.dispatch.tensor<readonly:?x?xf32>, !flow.dispatch.tensor<readonly:?x?xf32>, !flow.dispatch.tensor<writeonly:?x?xf32>, index, index, index, index, index, index, index, index) -> ()} { | |
| ^bb0(%arg0: index, %arg1: index, %arg2: index): // no predecessors | |
| %c1 = constant 1 : index | |
| %0 = affine.apply #map()[%arg0] | |
| %1 = affine.apply #map()[%arg1] | |
| hal.return %0, %1, %c1 : index, index, index | |
| } | |
| module { | |
| llvm.func internal @forward_dispatch_1(%arg0: !llvm.ptr<struct<"iree_hal_executable_dispatch_state_v0_t", (array<3 x i32>, array<3 x i32>, i64, ptr<i32>, i64, ptr<ptr<i8>>, ptr<i64>)>>, %arg1: !llvm.ptr<array<3 x i32>>) -> i32 { | |
| %0 = llvm.mlir.constant(32 : index) : i64 | |
| %1 = llvm.mlir.constant(4 : index) : i64 | |
| %2 = llvm.mlir.constant(0 : index) : i64 | |
| %3 = llvm.mlir.constant(1 : index) : i64 | |
| %4 = llvm.load %arg0 : !llvm.ptr<struct<"iree_hal_executable_dispatch_state_v0_t", (array<3 x i32>, array<3 x i32>, i64, ptr<i32>, i64, ptr<ptr<i8>>, ptr<i64>)>> | |
| %5 = llvm.extractvalue %4[5] : !llvm.struct<"iree_hal_executable_dispatch_state_v0_t", (array<3 x i32>, array<3 x i32>, i64, ptr<i32>, i64, ptr<ptr<i8>>, ptr<i64>)> | |
| %6 = llvm.getelementptr %5[%2] : (!llvm.ptr<ptr<i8>>, i64) -> !llvm.ptr<ptr<i8>> | |
| %7 = llvm.load %6 : !llvm.ptr<ptr<i8>> | |
| %8 = llvm.getelementptr %7[%2] : (!llvm.ptr<i8>, i64) -> !llvm.ptr<i8> | |
| %9 = llvm.bitcast %8 : !llvm.ptr<i8> to !llvm.ptr<f32> | |
| %10 = llvm.mlir.undef : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %11 = llvm.insertvalue %9, %10[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %12 = llvm.insertvalue %9, %11[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %13 = llvm.insertvalue %2, %12[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %14 = llvm.load %arg0 : !llvm.ptr<struct<"iree_hal_executable_dispatch_state_v0_t", (array<3 x i32>, array<3 x i32>, i64, ptr<i32>, i64, ptr<ptr<i8>>, ptr<i64>)>> | |
| %15 = llvm.extractvalue %14[5] : !llvm.struct<"iree_hal_executable_dispatch_state_v0_t", (array<3 x i32>, array<3 x i32>, i64, ptr<i32>, i64, ptr<ptr<i8>>, ptr<i64>)> | |
| %16 = llvm.getelementptr %15[%3] : (!llvm.ptr<ptr<i8>>, i64) -> !llvm.ptr<ptr<i8>> | |
| %17 = llvm.load %16 : !llvm.ptr<ptr<i8>> | |
| %18 = llvm.getelementptr %17[%2] : (!llvm.ptr<i8>, i64) -> !llvm.ptr<i8> | |
| %19 = llvm.bitcast %18 : !llvm.ptr<i8> to !llvm.ptr<f32> | |
| %20 = llvm.insertvalue %19, %10[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %21 = llvm.insertvalue %19, %20[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %22 = llvm.insertvalue %2, %21[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %23 = llvm.load %arg0 : !llvm.ptr<struct<"iree_hal_executable_dispatch_state_v0_t", (array<3 x i32>, array<3 x i32>, i64, ptr<i32>, i64, ptr<ptr<i8>>, ptr<i64>)>> | |
| %24 = llvm.extractvalue %23[5] : !llvm.struct<"iree_hal_executable_dispatch_state_v0_t", (array<3 x i32>, array<3 x i32>, i64, ptr<i32>, i64, ptr<ptr<i8>>, ptr<i64>)> | |
| %25 = llvm.mlir.constant(2 : index) : i64 | |
| %26 = llvm.getelementptr %24[%25] : (!llvm.ptr<ptr<i8>>, i64) -> !llvm.ptr<ptr<i8>> | |
| %27 = llvm.load %26 : !llvm.ptr<ptr<i8>> | |
| %28 = llvm.getelementptr %27[%2] : (!llvm.ptr<i8>, i64) -> !llvm.ptr<i8> | |
| %29 = llvm.bitcast %28 : !llvm.ptr<i8> to !llvm.ptr<f32> | |
| %30 = llvm.insertvalue %29, %10[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %31 = llvm.insertvalue %29, %30[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %32 = llvm.insertvalue %2, %31[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %33 = llvm.load %arg0 : !llvm.ptr<struct<"iree_hal_executable_dispatch_state_v0_t", (array<3 x i32>, array<3 x i32>, i64, ptr<i32>, i64, ptr<ptr<i8>>, ptr<i64>)>> | |
| %34 = llvm.extractvalue %33[5] : !llvm.struct<"iree_hal_executable_dispatch_state_v0_t", (array<3 x i32>, array<3 x i32>, i64, ptr<i32>, i64, ptr<ptr<i8>>, ptr<i64>)> | |
| %35 = llvm.mlir.constant(3 : index) : i64 | |
| %36 = llvm.getelementptr %34[%35] : (!llvm.ptr<ptr<i8>>, i64) -> !llvm.ptr<ptr<i8>> | |
| %37 = llvm.load %36 : !llvm.ptr<ptr<i8>> | |
| %38 = llvm.getelementptr %37[%2] : (!llvm.ptr<i8>, i64) -> !llvm.ptr<i8> | |
| %39 = llvm.bitcast %38 : !llvm.ptr<i8> to !llvm.ptr<f32> | |
| %40 = llvm.insertvalue %39, %10[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %41 = llvm.insertvalue %39, %40[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %42 = llvm.insertvalue %2, %41[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %43 = llvm.load %arg0 : !llvm.ptr<struct<"iree_hal_executable_dispatch_state_v0_t", (array<3 x i32>, array<3 x i32>, i64, ptr<i32>, i64, ptr<ptr<i8>>, ptr<i64>)>> | |
| %44 = llvm.extractvalue %43[3] : !llvm.struct<"iree_hal_executable_dispatch_state_v0_t", (array<3 x i32>, array<3 x i32>, i64, ptr<i32>, i64, ptr<ptr<i8>>, ptr<i64>)> | |
| %45 = llvm.getelementptr %44[%2] : (!llvm.ptr<i32>, i64) -> !llvm.ptr<i32> | |
| %46 = llvm.load %45 : !llvm.ptr<i32> | |
| %47 = llvm.zext %46 : i32 to i64 | |
| %48 = llvm.load %arg0 : !llvm.ptr<struct<"iree_hal_executable_dispatch_state_v0_t", (array<3 x i32>, array<3 x i32>, i64, ptr<i32>, i64, ptr<ptr<i8>>, ptr<i64>)>> | |
| %49 = llvm.extractvalue %48[3] : !llvm.struct<"iree_hal_executable_dispatch_state_v0_t", (array<3 x i32>, array<3 x i32>, i64, ptr<i32>, i64, ptr<ptr<i8>>, ptr<i64>)> | |
| %50 = llvm.getelementptr %49[%3] : (!llvm.ptr<i32>, i64) -> !llvm.ptr<i32> | |
| %51 = llvm.load %50 : !llvm.ptr<i32> | |
| %52 = llvm.zext %51 : i32 to i64 | |
| %53 = llvm.load %arg0 : !llvm.ptr<struct<"iree_hal_executable_dispatch_state_v0_t", (array<3 x i32>, array<3 x i32>, i64, ptr<i32>, i64, ptr<ptr<i8>>, ptr<i64>)>> | |
| %54 = llvm.extractvalue %53[3] : !llvm.struct<"iree_hal_executable_dispatch_state_v0_t", (array<3 x i32>, array<3 x i32>, i64, ptr<i32>, i64, ptr<ptr<i8>>, ptr<i64>)> | |
| %55 = llvm.getelementptr %54[%25] : (!llvm.ptr<i32>, i64) -> !llvm.ptr<i32> | |
| %56 = llvm.load %55 : !llvm.ptr<i32> | |
| %57 = llvm.zext %56 : i32 to i64 | |
| %58 = llvm.load %arg0 : !llvm.ptr<struct<"iree_hal_executable_dispatch_state_v0_t", (array<3 x i32>, array<3 x i32>, i64, ptr<i32>, i64, ptr<ptr<i8>>, ptr<i64>)>> | |
| %59 = llvm.extractvalue %58[3] : !llvm.struct<"iree_hal_executable_dispatch_state_v0_t", (array<3 x i32>, array<3 x i32>, i64, ptr<i32>, i64, ptr<ptr<i8>>, ptr<i64>)> | |
| %60 = llvm.getelementptr %59[%35] : (!llvm.ptr<i32>, i64) -> !llvm.ptr<i32> | |
| %61 = llvm.load %60 : !llvm.ptr<i32> | |
| %62 = llvm.zext %61 : i32 to i64 | |
| %63 = llvm.load %arg0 : !llvm.ptr<struct<"iree_hal_executable_dispatch_state_v0_t", (array<3 x i32>, array<3 x i32>, i64, ptr<i32>, i64, ptr<ptr<i8>>, ptr<i64>)>> | |
| %64 = llvm.extractvalue %63[3] : !llvm.struct<"iree_hal_executable_dispatch_state_v0_t", (array<3 x i32>, array<3 x i32>, i64, ptr<i32>, i64, ptr<ptr<i8>>, ptr<i64>)> | |
| %65 = llvm.getelementptr %64[%1] : (!llvm.ptr<i32>, i64) -> !llvm.ptr<i32> | |
| %66 = llvm.load %65 : !llvm.ptr<i32> | |
| %67 = llvm.zext %66 : i32 to i64 | |
| %68 = llvm.load %arg0 : !llvm.ptr<struct<"iree_hal_executable_dispatch_state_v0_t", (array<3 x i32>, array<3 x i32>, i64, ptr<i32>, i64, ptr<ptr<i8>>, ptr<i64>)>> | |
| %69 = llvm.extractvalue %68[3] : !llvm.struct<"iree_hal_executable_dispatch_state_v0_t", (array<3 x i32>, array<3 x i32>, i64, ptr<i32>, i64, ptr<ptr<i8>>, ptr<i64>)> | |
| %70 = llvm.mlir.constant(5 : index) : i64 | |
| %71 = llvm.getelementptr %69[%70] : (!llvm.ptr<i32>, i64) -> !llvm.ptr<i32> | |
| %72 = llvm.load %71 : !llvm.ptr<i32> | |
| %73 = llvm.zext %72 : i32 to i64 | |
| %74 = llvm.load %arg0 : !llvm.ptr<struct<"iree_hal_executable_dispatch_state_v0_t", (array<3 x i32>, array<3 x i32>, i64, ptr<i32>, i64, ptr<ptr<i8>>, ptr<i64>)>> | |
| %75 = llvm.extractvalue %74[3] : !llvm.struct<"iree_hal_executable_dispatch_state_v0_t", (array<3 x i32>, array<3 x i32>, i64, ptr<i32>, i64, ptr<ptr<i8>>, ptr<i64>)> | |
| %76 = llvm.mlir.constant(6 : index) : i64 | |
| %77 = llvm.getelementptr %75[%76] : (!llvm.ptr<i32>, i64) -> !llvm.ptr<i32> | |
| %78 = llvm.load %77 : !llvm.ptr<i32> | |
| %79 = llvm.zext %78 : i32 to i64 | |
| %80 = llvm.load %arg0 : !llvm.ptr<struct<"iree_hal_executable_dispatch_state_v0_t", (array<3 x i32>, array<3 x i32>, i64, ptr<i32>, i64, ptr<ptr<i8>>, ptr<i64>)>> | |
| %81 = llvm.extractvalue %80[3] : !llvm.struct<"iree_hal_executable_dispatch_state_v0_t", (array<3 x i32>, array<3 x i32>, i64, ptr<i32>, i64, ptr<ptr<i8>>, ptr<i64>)> | |
| %82 = llvm.mlir.constant(7 : index) : i64 | |
| %83 = llvm.getelementptr %81[%82] : (!llvm.ptr<i32>, i64) -> !llvm.ptr<i32> | |
| %84 = llvm.load %83 : !llvm.ptr<i32> | |
| %85 = llvm.zext %84 : i32 to i64 | |
| %86 = llvm.insertvalue %47, %13[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %87 = llvm.insertvalue %52, %86[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %88 = llvm.insertvalue %3, %87[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %89 = llvm.extractvalue %88[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %90 = llvm.extractvalue %88[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %91 = llvm.mul %89, %90 : i64 | |
| %92 = llvm.insertvalue %91, %88[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %93 = llvm.insertvalue %57, %22[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %94 = llvm.insertvalue %62, %93[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %95 = llvm.insertvalue %3, %94[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %96 = llvm.extractvalue %95[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %97 = llvm.extractvalue %95[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %98 = llvm.mul %96, %97 : i64 | |
| %99 = llvm.insertvalue %98, %95[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %100 = llvm.insertvalue %67, %32[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %101 = llvm.insertvalue %73, %100[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %102 = llvm.insertvalue %3, %101[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %103 = llvm.extractvalue %102[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %104 = llvm.extractvalue %102[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %105 = llvm.mul %103, %104 : i64 | |
| %106 = llvm.insertvalue %105, %102[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %107 = llvm.insertvalue %79, %42[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %108 = llvm.insertvalue %85, %107[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %109 = llvm.insertvalue %3, %108[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %110 = llvm.extractvalue %109[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %111 = llvm.extractvalue %109[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %112 = llvm.mul %110, %111 : i64 | |
| %113 = llvm.insertvalue %112, %109[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %114 = llvm.load %arg1 : !llvm.ptr<array<3 x i32>> | |
| %115 = llvm.extractvalue %114[0] : !llvm.array<3 x i32> | |
| %116 = llvm.zext %115 : i32 to i64 | |
| %117 = llvm.load %arg0 : !llvm.ptr<struct<"iree_hal_executable_dispatch_state_v0_t", (array<3 x i32>, array<3 x i32>, i64, ptr<i32>, i64, ptr<ptr<i8>>, ptr<i64>)>> | |
| %118 = llvm.extractvalue %117[0] : !llvm.struct<"iree_hal_executable_dispatch_state_v0_t", (array<3 x i32>, array<3 x i32>, i64, ptr<i32>, i64, ptr<ptr<i8>>, ptr<i64>)> | |
| %119 = llvm.extractvalue %118[0] : !llvm.array<3 x i32> | |
| %120 = llvm.zext %119 : i32 to i64 | |
| %121 = llvm.load %arg1 : !llvm.ptr<array<3 x i32>> | |
| %122 = llvm.extractvalue %121[1] : !llvm.array<3 x i32> | |
| %123 = llvm.zext %122 : i32 to i64 | |
| %124 = llvm.load %arg0 : !llvm.ptr<struct<"iree_hal_executable_dispatch_state_v0_t", (array<3 x i32>, array<3 x i32>, i64, ptr<i32>, i64, ptr<ptr<i8>>, ptr<i64>)>> | |
| %125 = llvm.extractvalue %124[0] : !llvm.struct<"iree_hal_executable_dispatch_state_v0_t", (array<3 x i32>, array<3 x i32>, i64, ptr<i32>, i64, ptr<ptr<i8>>, ptr<i64>)> | |
| %126 = llvm.extractvalue %125[1] : !llvm.array<3 x i32> | |
| %127 = llvm.zext %126 : i32 to i64 | |
| %128 = llvm.mlir.constant(64 : index) : i64 | |
| %129 = llvm.mul %123, %128 : i64 | |
| %130 = llvm.mul %127, %128 : i64 | |
| llvm.br ^bb1(%129 : i64) | |
| ^bb1(%131: i64): // 2 preds: ^bb0, ^bb30 | |
| %132 = llvm.icmp "slt" %131, %47 : i64 | |
| llvm.cond_br %132, ^bb2, ^bb31 | |
| ^bb2: // pred: ^bb1 | |
| %133 = llvm.mul %116, %128 : i64 | |
| %134 = llvm.mul %120, %128 : i64 | |
| llvm.br ^bb3(%133 : i64) | |
| ^bb3(%135: i64): // 2 preds: ^bb2, ^bb29 | |
| %136 = llvm.icmp "slt" %135, %62 : i64 | |
| llvm.cond_br %136, ^bb4, ^bb30 | |
| ^bb4: // pred: ^bb3 | |
| %137 = llvm.mlir.constant(-1 : index) : i64 | |
| %138 = llvm.mul %131, %137 : i64 | |
| %139 = llvm.add %47, %138 : i64 | |
| %140 = llvm.icmp "slt" %128, %139 : i64 | |
| %141 = llvm.select %140, %128, %139 : i1, i64 | |
| %142 = llvm.extractvalue %92[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %143 = llvm.bitcast %142 : !llvm.ptr<f32> to !llvm.ptr<f32> | |
| %144 = llvm.insertvalue %143, %10[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %145 = llvm.extractvalue %92[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %146 = llvm.bitcast %145 : !llvm.ptr<f32> to !llvm.ptr<f32> | |
| %147 = llvm.insertvalue %146, %144[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %148 = llvm.extractvalue %92[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %149 = llvm.extractvalue %92[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %150 = llvm.extractvalue %92[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %151 = llvm.mul %131, %148 : i64 | |
| %152 = llvm.add %150, %151 : i64 | |
| %153 = llvm.mlir.constant(0 : i64) : i64 | |
| %154 = llvm.mul %153, %149 : i64 | |
| %155 = llvm.add %152, %154 : i64 | |
| %156 = llvm.insertvalue %155, %147[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %157 = llvm.mlir.constant(1 : i64) : i64 | |
| %158 = llvm.insertvalue %52, %156[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %159 = llvm.insertvalue %157, %158[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %160 = llvm.mul %157, %148 : i64 | |
| %161 = llvm.insertvalue %141, %159[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %162 = llvm.insertvalue %160, %161[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %163 = llvm.mul %135, %137 : i64 | |
| %164 = llvm.add %62, %163 : i64 | |
| %165 = llvm.icmp "slt" %128, %164 : i64 | |
| %166 = llvm.select %165, %128, %164 : i1, i64 | |
| %167 = llvm.extractvalue %99[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %168 = llvm.bitcast %167 : !llvm.ptr<f32> to !llvm.ptr<f32> | |
| %169 = llvm.insertvalue %168, %10[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %170 = llvm.extractvalue %99[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %171 = llvm.bitcast %170 : !llvm.ptr<f32> to !llvm.ptr<f32> | |
| %172 = llvm.insertvalue %171, %169[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %173 = llvm.extractvalue %99[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %174 = llvm.extractvalue %99[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %175 = llvm.extractvalue %99[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %176 = llvm.mul %153, %173 : i64 | |
| %177 = llvm.add %175, %176 : i64 | |
| %178 = llvm.mul %135, %174 : i64 | |
| %179 = llvm.add %177, %178 : i64 | |
| %180 = llvm.insertvalue %179, %172[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %181 = llvm.insertvalue %166, %180[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %182 = llvm.insertvalue %157, %181[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %183 = llvm.mul %157, %173 : i64 | |
| %184 = llvm.insertvalue %57, %182[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %185 = llvm.insertvalue %183, %184[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %186 = llvm.add %67, %138 : i64 | |
| %187 = llvm.icmp "slt" %128, %186 : i64 | |
| %188 = llvm.select %187, %128, %186 : i1, i64 | |
| %189 = llvm.add %73, %163 : i64 | |
| %190 = llvm.icmp "slt" %128, %189 : i64 | |
| %191 = llvm.select %190, %128, %189 : i1, i64 | |
| %192 = llvm.extractvalue %113[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %193 = llvm.bitcast %192 : !llvm.ptr<f32> to !llvm.ptr<f32> | |
| %194 = llvm.insertvalue %193, %10[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %195 = llvm.extractvalue %113[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %196 = llvm.bitcast %195 : !llvm.ptr<f32> to !llvm.ptr<f32> | |
| %197 = llvm.insertvalue %196, %194[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %198 = llvm.extractvalue %113[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %199 = llvm.extractvalue %113[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %200 = llvm.extractvalue %113[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %201 = llvm.mul %131, %198 : i64 | |
| %202 = llvm.add %200, %201 : i64 | |
| %203 = llvm.mul %135, %199 : i64 | |
| %204 = llvm.add %202, %203 : i64 | |
| %205 = llvm.insertvalue %204, %197[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %206 = llvm.insertvalue %191, %205[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %207 = llvm.insertvalue %157, %206[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %208 = llvm.mul %157, %198 : i64 | |
| %209 = llvm.insertvalue %188, %207[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %210 = llvm.insertvalue %208, %209[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %211 = llvm.extractvalue %106[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %212 = llvm.bitcast %211 : !llvm.ptr<f32> to !llvm.ptr<f32> | |
| %213 = llvm.insertvalue %212, %10[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %214 = llvm.extractvalue %106[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %215 = llvm.bitcast %214 : !llvm.ptr<f32> to !llvm.ptr<f32> | |
| %216 = llvm.insertvalue %215, %213[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %217 = llvm.extractvalue %106[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %218 = llvm.extractvalue %106[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %219 = llvm.extractvalue %106[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %220 = llvm.mul %131, %217 : i64 | |
| %221 = llvm.add %219, %220 : i64 | |
| %222 = llvm.mul %135, %218 : i64 | |
| %223 = llvm.add %221, %222 : i64 | |
| %224 = llvm.insertvalue %223, %216[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %225 = llvm.insertvalue %191, %224[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %226 = llvm.insertvalue %157, %225[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %227 = llvm.mul %157, %217 : i64 | |
| %228 = llvm.insertvalue %188, %226[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %229 = llvm.insertvalue %227, %228[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| llvm.br ^bb5(%2 : i64) | |
| ^bb5(%230: i64): // 2 preds: ^bb4, ^bb8 | |
| %231 = llvm.icmp "slt" %230, %188 : i64 | |
| llvm.cond_br %231, ^bb6(%2 : i64), ^bb9(%2 : i64) | |
| ^bb6(%232: i64): // 2 preds: ^bb5, ^bb7 | |
| %233 = llvm.icmp "slt" %232, %191 : i64 | |
| llvm.cond_br %233, ^bb7, ^bb8 | |
| ^bb7: // pred: ^bb6 | |
| %234 = llvm.extractvalue %229[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %235 = llvm.extractvalue %229[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %236 = llvm.extractvalue %229[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %237 = llvm.mul %230, %236 : i64 | |
| %238 = llvm.add %235, %237 : i64 | |
| %239 = llvm.add %238, %232 : i64 | |
| %240 = llvm.getelementptr %234[%239] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32> | |
| %241 = llvm.load %240 : !llvm.ptr<f32> | |
| %242 = llvm.extractvalue %210[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %243 = llvm.extractvalue %210[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %244 = llvm.extractvalue %210[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %245 = llvm.mul %230, %244 : i64 | |
| %246 = llvm.add %243, %245 : i64 | |
| %247 = llvm.add %246, %232 : i64 | |
| %248 = llvm.getelementptr %242[%247] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32> | |
| llvm.store %241, %248 : !llvm.ptr<f32> | |
| %249 = llvm.add %232, %3 : i64 | |
| llvm.br ^bb6(%249 : i64) | |
| ^bb8: // pred: ^bb6 | |
| %250 = llvm.add %230, %3 : i64 | |
| llvm.br ^bb5(%250 : i64) | |
| ^bb9(%251: i64): // 2 preds: ^bb5, ^bb28 | |
| %252 = llvm.icmp "slt" %251, %141 : i64 | |
| llvm.cond_br %252, ^bb10(%2 : i64), ^bb29 | |
| ^bb10(%253: i64): // 2 preds: ^bb9, ^bb27 | |
| %254 = llvm.icmp "slt" %253, %166 : i64 | |
| llvm.cond_br %254, ^bb11(%2 : i64), ^bb28 | |
| ^bb11(%255: i64): // 2 preds: ^bb10, ^bb26 | |
| %256 = llvm.icmp "slt" %255, %52 : i64 | |
| llvm.cond_br %256, ^bb12, ^bb27 | |
| ^bb12: // pred: ^bb11 | |
| %257 = llvm.mul %251, %137 : i64 | |
| %258 = llvm.add %141, %257 : i64 | |
| %259 = llvm.icmp "slt" %0, %258 : i64 | |
| %260 = llvm.select %259, %0, %258 : i1, i64 | |
| %261 = llvm.mul %255, %137 : i64 | |
| %262 = llvm.add %52, %261 : i64 | |
| %263 = llvm.icmp "slt" %0, %262 : i64 | |
| %264 = llvm.select %263, %0, %262 : i1, i64 | |
| %265 = llvm.extractvalue %162[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %266 = llvm.bitcast %265 : !llvm.ptr<f32> to !llvm.ptr<f32> | |
| %267 = llvm.insertvalue %266, %10[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %268 = llvm.extractvalue %162[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %269 = llvm.bitcast %268 : !llvm.ptr<f32> to !llvm.ptr<f32> | |
| %270 = llvm.insertvalue %269, %267[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %271 = llvm.extractvalue %162[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %272 = llvm.extractvalue %162[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %273 = llvm.extractvalue %162[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %274 = llvm.mul %251, %271 : i64 | |
| %275 = llvm.add %273, %274 : i64 | |
| %276 = llvm.mul %255, %272 : i64 | |
| %277 = llvm.add %275, %276 : i64 | |
| %278 = llvm.insertvalue %277, %270[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %279 = llvm.insertvalue %264, %278[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %280 = llvm.insertvalue %157, %279[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %281 = llvm.mul %157, %271 : i64 | |
| %282 = llvm.insertvalue %260, %280[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %283 = llvm.insertvalue %281, %282[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %284 = llvm.add %57, %261 : i64 | |
| %285 = llvm.icmp "slt" %0, %284 : i64 | |
| %286 = llvm.select %285, %0, %284 : i1, i64 | |
| %287 = llvm.mul %253, %137 : i64 | |
| %288 = llvm.add %166, %287 : i64 | |
| %289 = llvm.icmp "slt" %0, %288 : i64 | |
| %290 = llvm.select %289, %0, %288 : i1, i64 | |
| %291 = llvm.extractvalue %185[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %292 = llvm.bitcast %291 : !llvm.ptr<f32> to !llvm.ptr<f32> | |
| %293 = llvm.insertvalue %292, %10[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %294 = llvm.extractvalue %185[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %295 = llvm.bitcast %294 : !llvm.ptr<f32> to !llvm.ptr<f32> | |
| %296 = llvm.insertvalue %295, %293[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %297 = llvm.extractvalue %185[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %298 = llvm.extractvalue %185[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %299 = llvm.extractvalue %185[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %300 = llvm.mul %255, %297 : i64 | |
| %301 = llvm.add %299, %300 : i64 | |
| %302 = llvm.mul %253, %298 : i64 | |
| %303 = llvm.add %301, %302 : i64 | |
| %304 = llvm.insertvalue %303, %296[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %305 = llvm.insertvalue %290, %304[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %306 = llvm.insertvalue %157, %305[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %307 = llvm.mul %157, %297 : i64 | |
| %308 = llvm.insertvalue %286, %306[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %309 = llvm.insertvalue %307, %308[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %310 = llvm.add %188, %257 : i64 | |
| %311 = llvm.icmp "slt" %0, %310 : i64 | |
| %312 = llvm.select %311, %0, %310 : i1, i64 | |
| %313 = llvm.add %191, %287 : i64 | |
| %314 = llvm.icmp "slt" %0, %313 : i64 | |
| %315 = llvm.select %314, %0, %313 : i1, i64 | |
| %316 = llvm.extractvalue %210[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %317 = llvm.bitcast %316 : !llvm.ptr<f32> to !llvm.ptr<f32> | |
| %318 = llvm.insertvalue %317, %10[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %319 = llvm.extractvalue %210[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %320 = llvm.bitcast %319 : !llvm.ptr<f32> to !llvm.ptr<f32> | |
| %321 = llvm.insertvalue %320, %318[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %322 = llvm.extractvalue %210[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %323 = llvm.extractvalue %210[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %324 = llvm.extractvalue %210[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %325 = llvm.mul %251, %322 : i64 | |
| %326 = llvm.add %324, %325 : i64 | |
| %327 = llvm.mul %253, %323 : i64 | |
| %328 = llvm.add %326, %327 : i64 | |
| %329 = llvm.insertvalue %328, %321[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %330 = llvm.insertvalue %315, %329[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %331 = llvm.insertvalue %157, %330[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %332 = llvm.mul %157, %322 : i64 | |
| %333 = llvm.insertvalue %312, %331[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %334 = llvm.insertvalue %332, %333[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| llvm.br ^bb13(%2 : i64) | |
| ^bb13(%335: i64): // 2 preds: ^bb12, ^bb25 | |
| %336 = llvm.icmp "slt" %335, %260 : i64 | |
| llvm.cond_br %336, ^bb14(%2 : i64), ^bb26 | |
| ^bb14(%337: i64): // 2 preds: ^bb13, ^bb24 | |
| %338 = llvm.icmp "slt" %337, %290 : i64 | |
| llvm.cond_br %338, ^bb15(%2 : i64), ^bb25 | |
| ^bb15(%339: i64): // 2 preds: ^bb14, ^bb23 | |
| %340 = llvm.icmp "slt" %339, %264 : i64 | |
| llvm.cond_br %340, ^bb16, ^bb24 | |
| ^bb16: // pred: ^bb15 | |
| %341 = llvm.mul %335, %137 : i64 | |
| %342 = llvm.add %260, %341 : i64 | |
| %343 = llvm.icmp "slt" %1, %342 : i64 | |
| %344 = llvm.select %343, %1, %342 : i1, i64 | |
| %345 = llvm.mul %339, %137 : i64 | |
| %346 = llvm.add %264, %345 : i64 | |
| %347 = llvm.icmp "slt" %1, %346 : i64 | |
| %348 = llvm.select %347, %1, %346 : i1, i64 | |
| %349 = llvm.extractvalue %283[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %350 = llvm.bitcast %349 : !llvm.ptr<f32> to !llvm.ptr<f32> | |
| %351 = llvm.insertvalue %350, %10[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %352 = llvm.extractvalue %283[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %353 = llvm.bitcast %352 : !llvm.ptr<f32> to !llvm.ptr<f32> | |
| %354 = llvm.insertvalue %353, %351[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %355 = llvm.extractvalue %283[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %356 = llvm.extractvalue %283[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %357 = llvm.extractvalue %283[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %358 = llvm.mul %335, %355 : i64 | |
| %359 = llvm.add %357, %358 : i64 | |
| %360 = llvm.mul %339, %356 : i64 | |
| %361 = llvm.add %359, %360 : i64 | |
| %362 = llvm.insertvalue %361, %354[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %363 = llvm.insertvalue %348, %362[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %364 = llvm.insertvalue %157, %363[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %365 = llvm.mul %157, %355 : i64 | |
| %366 = llvm.insertvalue %344, %364[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %367 = llvm.insertvalue %365, %366[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %368 = llvm.add %286, %345 : i64 | |
| %369 = llvm.icmp "slt" %1, %368 : i64 | |
| %370 = llvm.select %369, %1, %368 : i1, i64 | |
| %371 = llvm.mul %337, %137 : i64 | |
| %372 = llvm.add %290, %371 : i64 | |
| %373 = llvm.icmp "slt" %1, %372 : i64 | |
| %374 = llvm.select %373, %1, %372 : i1, i64 | |
| %375 = llvm.extractvalue %309[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %376 = llvm.bitcast %375 : !llvm.ptr<f32> to !llvm.ptr<f32> | |
| %377 = llvm.insertvalue %376, %10[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %378 = llvm.extractvalue %309[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %379 = llvm.bitcast %378 : !llvm.ptr<f32> to !llvm.ptr<f32> | |
| %380 = llvm.insertvalue %379, %377[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %381 = llvm.extractvalue %309[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %382 = llvm.extractvalue %309[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %383 = llvm.extractvalue %309[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %384 = llvm.mul %339, %381 : i64 | |
| %385 = llvm.add %383, %384 : i64 | |
| %386 = llvm.mul %337, %382 : i64 | |
| %387 = llvm.add %385, %386 : i64 | |
| %388 = llvm.insertvalue %387, %380[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %389 = llvm.insertvalue %374, %388[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %390 = llvm.insertvalue %157, %389[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %391 = llvm.mul %157, %381 : i64 | |
| %392 = llvm.insertvalue %370, %390[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %393 = llvm.insertvalue %391, %392[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %394 = llvm.add %312, %341 : i64 | |
| %395 = llvm.icmp "slt" %1, %394 : i64 | |
| %396 = llvm.select %395, %1, %394 : i1, i64 | |
| %397 = llvm.add %315, %371 : i64 | |
| %398 = llvm.icmp "slt" %1, %397 : i64 | |
| %399 = llvm.select %398, %1, %397 : i1, i64 | |
| %400 = llvm.extractvalue %334[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %401 = llvm.bitcast %400 : !llvm.ptr<f32> to !llvm.ptr<f32> | |
| %402 = llvm.insertvalue %401, %10[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %403 = llvm.extractvalue %334[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %404 = llvm.bitcast %403 : !llvm.ptr<f32> to !llvm.ptr<f32> | |
| %405 = llvm.insertvalue %404, %402[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %406 = llvm.extractvalue %334[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %407 = llvm.extractvalue %334[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %408 = llvm.extractvalue %334[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %409 = llvm.mul %335, %406 : i64 | |
| %410 = llvm.add %408, %409 : i64 | |
| %411 = llvm.mul %337, %407 : i64 | |
| %412 = llvm.add %410, %411 : i64 | |
| %413 = llvm.insertvalue %412, %405[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %414 = llvm.insertvalue %399, %413[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %415 = llvm.insertvalue %157, %414[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %416 = llvm.mul %157, %406 : i64 | |
| %417 = llvm.insertvalue %396, %415[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %418 = llvm.insertvalue %416, %417[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| llvm.br ^bb17(%2 : i64) | |
| ^bb17(%419: i64): // 2 preds: ^bb16, ^bb22 | |
| %420 = llvm.icmp "slt" %419, %344 : i64 | |
| llvm.cond_br %420, ^bb18(%2 : i64), ^bb23 | |
| ^bb18(%421: i64): // 2 preds: ^bb17, ^bb21 | |
| %422 = llvm.icmp "slt" %421, %374 : i64 | |
| llvm.cond_br %422, ^bb19(%2 : i64), ^bb22 | |
| ^bb19(%423: i64): // 2 preds: ^bb18, ^bb20 | |
| %424 = llvm.icmp "slt" %423, %348 : i64 | |
| llvm.cond_br %424, ^bb20, ^bb21 | |
| ^bb20: // pred: ^bb19 | |
| %425 = llvm.extractvalue %367[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %426 = llvm.extractvalue %367[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %427 = llvm.extractvalue %367[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %428 = llvm.mul %419, %427 : i64 | |
| %429 = llvm.add %426, %428 : i64 | |
| %430 = llvm.add %429, %423 : i64 | |
| %431 = llvm.getelementptr %425[%430] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32> | |
| %432 = llvm.load %431 : !llvm.ptr<f32> | |
| %433 = llvm.extractvalue %393[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %434 = llvm.extractvalue %393[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %435 = llvm.extractvalue %393[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %436 = llvm.mul %423, %435 : i64 | |
| %437 = llvm.add %434, %436 : i64 | |
| %438 = llvm.add %437, %421 : i64 | |
| %439 = llvm.getelementptr %433[%438] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32> | |
| %440 = llvm.load %439 : !llvm.ptr<f32> | |
| %441 = llvm.extractvalue %418[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %442 = llvm.extractvalue %418[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %443 = llvm.extractvalue %418[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> | |
| %444 = llvm.mul %419, %443 : i64 | |
| %445 = llvm.add %442, %444 : i64 | |
| %446 = llvm.add %445, %421 : i64 | |
| %447 = llvm.getelementptr %441[%446] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32> | |
| %448 = llvm.load %447 : !llvm.ptr<f32> | |
| %449 = llvm.fmul %432, %440 : f32 | |
| %450 = llvm.fadd %448, %449 : f32 | |
| llvm.store %450, %447 : !llvm.ptr<f32> | |
| %451 = llvm.add %423, %3 : i64 | |
| llvm.br ^bb19(%451 : i64) | |
| ^bb21: // pred: ^bb19 | |
| %452 = llvm.add %421, %3 : i64 | |
| llvm.br ^bb18(%452 : i64) | |
| ^bb22: // pred: ^bb18 | |
| %453 = llvm.add %419, %3 : i64 | |
| llvm.br ^bb17(%453 : i64) | |
| ^bb23: // pred: ^bb17 | |
| %454 = llvm.add %339, %1 : i64 | |
| llvm.br ^bb15(%454 : i64) | |
| ^bb24: // pred: ^bb15 | |
| %455 = llvm.add %337, %1 : i64 | |
| llvm.br ^bb14(%455 : i64) | |
| ^bb25: // pred: ^bb14 | |
| %456 = llvm.add %335, %1 : i64 | |
| llvm.br ^bb13(%456 : i64) | |
| ^bb26: // pred: ^bb13 | |
| %457 = llvm.add %255, %0 : i64 | |
| llvm.br ^bb11(%457 : i64) | |
| ^bb27: // pred: ^bb11 | |
| %458 = llvm.add %253, %0 : i64 | |
| llvm.br ^bb10(%458 : i64) | |
| ^bb28: // pred: ^bb10 | |
| %459 = llvm.add %251, %0 : i64 | |
| llvm.br ^bb9(%459 : i64) | |
| ^bb29: // pred: ^bb9 | |
| %460 = llvm.add %135, %134 : i64 | |
| llvm.br ^bb3(%460 : i64) | |
| ^bb30: // pred: ^bb3 | |
| %461 = llvm.add %131, %130 : i64 | |
| llvm.br ^bb1(%461 : i64) | |
| ^bb31: // pred: ^bb1 | |
| %462 = llvm.mlir.constant(0 : i32) : i32 | |
| llvm.return %462 : i32 | |
| } | |
| } | |
| } | |
| } | |
| func @forward(%arg0: tensor<?x?xf32>, %arg1: !shapex.ranked_shape<[?,?]>, %arg2: tensor<?x?xf32>, %arg3: !shapex.ranked_shape<[?,?]>) -> (tensor<?x?xf32>, !shapex.ranked_shape<[?,?]>) attributes {iree.module.export, iree.reflection = {f = "I19!B7!d-1d-1B7!d-1d-1R10!B7!d-1d-1", fv = "1"}} { | |
| %0 = shapex.ranked_dim %arg3[0] : !shapex.ranked_shape<[?,?]> -> index | |
| %1 = shapex.ranked_dim %arg3[1] : !shapex.ranked_shape<[?,?]> -> index | |
| %2 = shapex.ranked_dim %arg1[1] : !shapex.ranked_shape<[?,?]> -> index | |
| %3 = shapex.ranked_dim %arg1[0] : !shapex.ranked_shape<[?,?]> -> index | |
| %4 = shapex.make_ranked_shape %3, %1 : (index, index) -> !shapex.ranked_shape<[?,?]> | |
| %5 = linalg.init_tensor [%3, %1] : tensor<?x?xf32> | |
| %6 = flow.ex.stream.fragment(%1, %3, %5, %arg0, %arg2, %2, %0) : (index, index, tensor<?x?xf32>{%3, %1}, tensor<?x?xf32>{%3, %2}, tensor<?x?xf32>{%0, %1}, index, index) -> tensor<?x?xf32>{%3, %1} = | |
| (%arg4: index, %arg5: index, %arg6: tensor<?x?xf32>, %arg7: tensor<?x?xf32>, %arg8: tensor<?x?xf32>, %arg9: index, %arg10: index) -> tensor<?x?xf32> { | |
| %c1 = constant 1 : index | |
| %7 = flow.dispatch @forward_dispatch_0::@forward_dispatch_0[%arg4, %arg5, %c1](%arg6, %arg5, %arg4, %arg5, %arg4) : (tensor<?x?xf32>{%arg5, %arg4}, index, index, index, index) -> %arg6 | |
| %8 = flow.dispatch @forward_dispatch_1::@forward_dispatch_1[%arg4, %arg5, %c1](%arg7, %arg8, %7, %arg5, %arg9, %arg10, %arg4, %arg5, %arg4, %arg5, %arg4) : (tensor<?x?xf32>{%arg5, %arg9}, tensor<?x?xf32>{%arg10, %arg4}, tensor<?x?xf32>{%arg5, %arg4}, index, index, index, index, index, index, index, index) -> tensor<?x?xf32>{%arg5, %arg4} | |
| flow.return %8 : tensor<?x?xf32> | |
| } | |
| return %6, %4 : tensor<?x?xf32>, !shapex.ranked_shape<[?,?]> | |
| } | |
| } |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment