Created
May 9, 2023 16:55
-
-
Save sergei-mironov/cf485111b55c19c3a2a9c6bbeed84777 to your computer and use it in GitHub Desktop.
This file contains 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
| module @C_workflow { | |
| llvm.func @__quantum__rt__finalize() | |
| llvm.func @__quantum__rt__initialize() | |
| llvm.mlir.global internal constant @backend_best("best\00") {addr_space = 0 : i32} | |
| llvm.mlir.global internal constant @backend("backend\00") {addr_space = 0 : i32} | |
| llvm.func @__quantum__rt__device(!llvm.ptr<i8>, !llvm.ptr<i8>) | |
| llvm.func @free(!llvm.ptr<i8>) | |
| llvm.func @malloc(i64) -> !llvm.ptr<i8> | |
| llvm.mlir.global private constant @__constant_4x3x4xf64(dense<9.9999999999999995E-8> : tensor<4x3x4xf64>) {addr_space = 0 : i32} : !llvm.array<4 x array<3 x array<4 x f64>>> | |
| llvm.mlir.global private constant @__constant_4x4xf64(dense<9.9999999999999995E-8> : tensor<4x4xf64>) {addr_space = 0 : i32} : !llvm.array<4 x array<4 x f64>> | |
| llvm.mlir.global private constant @__constant_4xf64_1(dense<2.000000e+00> : tensor<4xf64>) {addr_space = 0 : i32} : !llvm.array<4 x f64> | |
| llvm.mlir.global private constant @__constant_4xf64_0(dense<3.000000e+00> : tensor<4xf64>) {addr_space = 0 : i32} : !llvm.array<4 x f64> | |
| llvm.mlir.global private constant @__constant_4xf64(dense<0.000000e+00> : tensor<4xf64>) {addr_space = 0 : i32} : !llvm.array<4 x f64> | |
| llvm.func @jit.C_workflow() -> !llvm.struct<(struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)>, struct<(ptr<f64>, ptr<f64>, i64, array<3 x i64>, array<3 x i64>)>)> attributes {llvm.emit_c_interface, sym_visibility = "public"} { | |
| %0 = llvm.mlir.constant(0 : index) : i64 | |
| %1 = llvm.mlir.constant(3735928559 : index) : i64 | |
| %2 = llvm.mlir.constant(4 : index) : i64 | |
| %3 = llvm.mlir.constant(1 : index) : i64 | |
| %4 = llvm.mlir.addressof @__constant_4xf64 : !llvm.ptr<array<4 x f64>> | |
| %5 = llvm.getelementptr %4[0, 0] : (!llvm.ptr<array<4 x f64>>) -> !llvm.ptr<f64> | |
| %6 = llvm.inttoptr %1 : i64 to !llvm.ptr<f64> | |
| %7 = llvm.call @f.finitediff0(%6, %5, %0, %2, %3) : (!llvm.ptr<f64>, !llvm.ptr<f64>, i64, i64, i64) -> !llvm.struct<(struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)>, struct<(ptr<f64>, ptr<f64>, i64, array<3 x i64>, array<3 x i64>)>)> | |
| %8 = llvm.extractvalue %7[0] : !llvm.struct<(struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)>, struct<(ptr<f64>, ptr<f64>, i64, array<3 x i64>, array<3 x i64>)>)> | |
| %9 = llvm.extractvalue %7[1] : !llvm.struct<(struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)>, struct<(ptr<f64>, ptr<f64>, i64, array<3 x i64>, array<3 x i64>)>)> | |
| %10 = llvm.mlir.undef : !llvm.struct<(struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)>, struct<(ptr<f64>, ptr<f64>, i64, array<3 x i64>, array<3 x i64>)>)> | |
| %11 = llvm.insertvalue %8, %10[0] : !llvm.struct<(struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)>, struct<(ptr<f64>, ptr<f64>, i64, array<3 x i64>, array<3 x i64>)>)> | |
| %12 = llvm.insertvalue %9, %11[1] : !llvm.struct<(struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)>, struct<(ptr<f64>, ptr<f64>, i64, array<3 x i64>, array<3 x i64>)>)> | |
| llvm.return %12 : !llvm.struct<(struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)>, struct<(ptr<f64>, ptr<f64>, i64, array<3 x i64>, array<3 x i64>)>)> | |
| } | |
| llvm.func @_mlir_ciface_jit.C_workflow(%arg0: !llvm.ptr<struct<(struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)>, struct<(ptr<f64>, ptr<f64>, i64, array<3 x i64>, array<3 x i64>)>)>>) attributes {llvm.emit_c_interface, sym_visibility = "public"} { | |
| %0 = llvm.call @jit.C_workflow() : () -> !llvm.struct<(struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)>, struct<(ptr<f64>, ptr<f64>, i64, array<3 x i64>, array<3 x i64>)>)> | |
| llvm.store %0, %arg0 : !llvm.ptr<struct<(struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)>, struct<(ptr<f64>, ptr<f64>, i64, array<3 x i64>, array<3 x i64>)>)>> | |
| llvm.return | |
| } | |
| llvm.func internal @f(%arg0: !llvm.ptr<f64>, %arg1: !llvm.ptr<f64>, %arg2: i64, %arg3: i64, %arg4: i64) -> !llvm.struct<(struct<(ptr<f64>, ptr<f64>, i64, array<1 x i64>, array<1 x i64>)>, struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)>)> attributes {sym_visibility = "private"} { | |
| %0 = llvm.mlir.constant(64 : index) : i64 | |
| %1 = llvm.mlir.constant(2 : index) : i64 | |
| %2 = llvm.mlir.constant(3 : index) : i64 | |
| %3 = llvm.mlir.constant(1 : index) : i64 | |
| %4 = llvm.mlir.constant(4 : index) : i64 | |
| %5 = llvm.mlir.constant(0 : index) : i64 | |
| %6 = llvm.mlir.undef : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<1 x i64>, array<1 x i64>)> | |
| %7 = llvm.insertvalue %arg0, %6[0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<1 x i64>, array<1 x i64>)> | |
| %8 = llvm.insertvalue %arg1, %7[1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<1 x i64>, array<1 x i64>)> | |
| %9 = llvm.insertvalue %arg2, %8[2] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<1 x i64>, array<1 x i64>)> | |
| %10 = llvm.insertvalue %arg3, %9[3, 0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<1 x i64>, array<1 x i64>)> | |
| %11 = llvm.insertvalue %arg4, %10[4, 0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<1 x i64>, array<1 x i64>)> | |
| %12 = llvm.mlir.addressof @__constant_4xf64_0 : !llvm.ptr<array<4 x f64>> | |
| %13 = llvm.getelementptr %12[0, 0] : (!llvm.ptr<array<4 x f64>>) -> !llvm.ptr<f64> | |
| %14 = llvm.mlir.addressof @__constant_4xf64_1 : !llvm.ptr<array<4 x f64>> | |
| %15 = llvm.getelementptr %14[0, 0] : (!llvm.ptr<array<4 x f64>>) -> !llvm.ptr<f64> | |
| %16 = llvm.mlir.null : !llvm.ptr<f64> | |
| %17 = llvm.getelementptr %16[4] : (!llvm.ptr<f64>) -> !llvm.ptr<f64> | |
| %18 = llvm.ptrtoint %17 : !llvm.ptr<f64> to i64 | |
| %19 = llvm.add %18, %0 : i64 | |
| %20 = llvm.call @malloc(%19) : (i64) -> !llvm.ptr<i8> | |
| %21 = llvm.bitcast %20 : !llvm.ptr<i8> to !llvm.ptr<f64> | |
| %22 = llvm.ptrtoint %21 : !llvm.ptr<f64> to i64 | |
| %23 = llvm.sub %0, %3 : i64 | |
| %24 = llvm.add %22, %23 : i64 | |
| %25 = llvm.urem %24, %0 : i64 | |
| %26 = llvm.sub %24, %25 : i64 | |
| %27 = llvm.inttoptr %26 : i64 to !llvm.ptr<f64> | |
| llvm.br ^bb1(%5 : i64) | |
| ^bb1(%28: i64): // 2 preds: ^bb0, ^bb2 | |
| %29 = llvm.icmp "slt" %28, %4 : i64 | |
| llvm.cond_br %29, ^bb2, ^bb3 | |
| ^bb2: // pred: ^bb1 | |
| %30 = llvm.getelementptr %arg1[%28] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64> | |
| %31 = llvm.load %30 : !llvm.ptr<f64> | |
| %32 = llvm.getelementptr %15[%28] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64> | |
| %33 = llvm.load %32 : !llvm.ptr<f64> | |
| %34 = llvm.fmul %31, %33 : f64 | |
| %35 = llvm.getelementptr %27[%28] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64> | |
| llvm.store %34, %35 : !llvm.ptr<f64> | |
| %36 = llvm.add %28, %3 : i64 | |
| llvm.br ^bb1(%36 : i64) | |
| ^bb3: // pred: ^bb1 | |
| %37 = llvm.mlir.null : !llvm.ptr<f64> | |
| %38 = llvm.getelementptr %37[4] : (!llvm.ptr<f64>) -> !llvm.ptr<f64> | |
| %39 = llvm.ptrtoint %38 : !llvm.ptr<f64> to i64 | |
| %40 = llvm.add %39, %0 : i64 | |
| %41 = llvm.call @malloc(%40) : (i64) -> !llvm.ptr<i8> | |
| %42 = llvm.bitcast %41 : !llvm.ptr<i8> to !llvm.ptr<f64> | |
| %43 = llvm.ptrtoint %42 : !llvm.ptr<f64> to i64 | |
| %44 = llvm.sub %0, %3 : i64 | |
| %45 = llvm.add %43, %44 : i64 | |
| %46 = llvm.urem %45, %0 : i64 | |
| %47 = llvm.sub %45, %46 : i64 | |
| %48 = llvm.inttoptr %47 : i64 to !llvm.ptr<f64> | |
| llvm.br ^bb4(%5 : i64) | |
| ^bb4(%49: i64): // 2 preds: ^bb3, ^bb5 | |
| %50 = llvm.icmp "slt" %49, %4 : i64 | |
| llvm.cond_br %50, ^bb5, ^bb6 | |
| ^bb5: // pred: ^bb4 | |
| %51 = llvm.getelementptr %arg1[%49] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64> | |
| %52 = llvm.load %51 : !llvm.ptr<f64> | |
| %53 = llvm.getelementptr %13[%49] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64> | |
| %54 = llvm.load %53 : !llvm.ptr<f64> | |
| %55 = llvm.fmul %52, %54 : f64 | |
| %56 = llvm.getelementptr %48[%49] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64> | |
| llvm.store %55, %56 : !llvm.ptr<f64> | |
| %57 = llvm.add %49, %3 : i64 | |
| llvm.br ^bb4(%57 : i64) | |
| ^bb6: // pred: ^bb4 | |
| %58 = llvm.mlir.undef : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)> | |
| %59 = llvm.insertvalue %21, %58[0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)> | |
| %60 = llvm.insertvalue %27, %59[1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)> | |
| %61 = llvm.insertvalue %5, %60[2] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)> | |
| %62 = llvm.insertvalue %3, %61[3, 0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)> | |
| %63 = llvm.insertvalue %4, %62[4, 0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)> | |
| %64 = llvm.insertvalue %4, %63[3, 1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)> | |
| %65 = llvm.insertvalue %3, %64[4, 1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)> | |
| %66 = llvm.mlir.undef : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)> | |
| %67 = llvm.insertvalue %42, %66[0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)> | |
| %68 = llvm.insertvalue %48, %67[1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)> | |
| %69 = llvm.insertvalue %5, %68[2] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)> | |
| %70 = llvm.insertvalue %3, %69[3, 0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)> | |
| %71 = llvm.insertvalue %4, %70[4, 0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)> | |
| %72 = llvm.insertvalue %4, %71[3, 1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)> | |
| %73 = llvm.insertvalue %3, %72[4, 1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)> | |
| %74 = llvm.mlir.null : !llvm.ptr<f64> | |
| %75 = llvm.getelementptr %74[12] : (!llvm.ptr<f64>) -> !llvm.ptr<f64> | |
| %76 = llvm.ptrtoint %75 : !llvm.ptr<f64> to i64 | |
| %77 = llvm.add %76, %0 : i64 | |
| %78 = llvm.call @malloc(%77) : (i64) -> !llvm.ptr<i8> | |
| %79 = llvm.bitcast %78 : !llvm.ptr<i8> to !llvm.ptr<f64> | |
| %80 = llvm.ptrtoint %79 : !llvm.ptr<f64> to i64 | |
| %81 = llvm.sub %0, %3 : i64 | |
| %82 = llvm.add %80, %81 : i64 | |
| %83 = llvm.urem %82, %0 : i64 | |
| %84 = llvm.sub %82, %83 : i64 | |
| %85 = llvm.inttoptr %84 : i64 to !llvm.ptr<f64> | |
| %86 = llvm.mlir.undef : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)> | |
| %87 = llvm.insertvalue %79, %86[0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)> | |
| %88 = llvm.insertvalue %85, %87[1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)> | |
| %89 = llvm.insertvalue %5, %88[2] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)> | |
| %90 = llvm.insertvalue %2, %89[3, 0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)> | |
| %91 = llvm.insertvalue %4, %90[3, 1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)> | |
| %92 = llvm.insertvalue %4, %91[4, 0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)> | |
| %93 = llvm.insertvalue %3, %92[4, 1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)> | |
| llvm.br ^bb7(%5 : i64) | |
| ^bb7(%94: i64): // 2 preds: ^bb6, ^bb18 | |
| %95 = llvm.icmp "slt" %94, %2 : i64 | |
| llvm.cond_br %95, ^bb8, ^bb19 | |
| ^bb8: // pred: ^bb7 | |
| llvm.br ^bb9(%5 : i64) | |
| ^bb9(%96: i64): // 2 preds: ^bb8, ^bb17 | |
| %97 = llvm.icmp "slt" %96, %4 : i64 | |
| llvm.cond_br %97, ^bb10, ^bb18 | |
| ^bb10: // pred: ^bb9 | |
| %98 = llvm.icmp "ult" %94, %3 : i64 | |
| llvm.cond_br %98, ^bb11, ^bb12 | |
| ^bb11: // pred: ^bb10 | |
| %99 = llvm.mul %94, %4 : i64 | |
| %100 = llvm.add %99, %96 : i64 | |
| %101 = llvm.getelementptr %arg1[%100] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64> | |
| %102 = llvm.load %101 : !llvm.ptr<f64> | |
| llvm.br ^bb16(%102 : f64) | |
| ^bb12: // pred: ^bb10 | |
| %103 = llvm.icmp "ult" %94, %1 : i64 | |
| llvm.cond_br %103, ^bb13(%3, %65 : i64, !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)>), ^bb13(%1, %73 : i64, !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)>) | |
| ^bb13(%104: i64, %105: !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)>): // 2 preds: ^bb12, ^bb12 | |
| %106 = llvm.sub %94, %104 : i64 | |
| %107 = llvm.extractvalue %105[1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)> | |
| %108 = llvm.mul %106, %4 : i64 | |
| %109 = llvm.add %108, %96 : i64 | |
| %110 = llvm.getelementptr %107[%109] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64> | |
| %111 = llvm.load %110 : !llvm.ptr<f64> | |
| llvm.br ^bb14(%111 : f64) | |
| ^bb14(%112: f64): // pred: ^bb13 | |
| llvm.br ^bb15 | |
| ^bb15: // pred: ^bb14 | |
| llvm.br ^bb16(%112 : f64) | |
| ^bb16(%113: f64): // 2 preds: ^bb11, ^bb15 | |
| llvm.br ^bb17 | |
| ^bb17: // pred: ^bb16 | |
| %114 = llvm.mul %94, %4 : i64 | |
| %115 = llvm.add %114, %96 : i64 | |
| %116 = llvm.getelementptr %85[%115] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64> | |
| llvm.store %113, %116 : !llvm.ptr<f64> | |
| %117 = llvm.add %96, %3 : i64 | |
| llvm.br ^bb9(%117 : i64) | |
| ^bb18: // pred: ^bb9 | |
| %118 = llvm.add %94, %3 : i64 | |
| llvm.br ^bb7(%118 : i64) | |
| ^bb19: // pred: ^bb7 | |
| llvm.call @free(%41) : (!llvm.ptr<i8>) -> () | |
| llvm.call @free(%20) : (!llvm.ptr<i8>) -> () | |
| %119 = llvm.mlir.undef : !llvm.struct<(struct<(ptr<f64>, ptr<f64>, i64, array<1 x i64>, array<1 x i64>)>, struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)>)> | |
| %120 = llvm.insertvalue %11, %119[0] : !llvm.struct<(struct<(ptr<f64>, ptr<f64>, i64, array<1 x i64>, array<1 x i64>)>, struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)>)> | |
| %121 = llvm.insertvalue %93, %120[1] : !llvm.struct<(struct<(ptr<f64>, ptr<f64>, i64, array<1 x i64>, array<1 x i64>)>, struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)>)> | |
| llvm.return %121 : !llvm.struct<(struct<(ptr<f64>, ptr<f64>, i64, array<1 x i64>, array<1 x i64>)>, struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)>)> | |
| } | |
| llvm.func @f.finitediff0(%arg0: !llvm.ptr<f64>, %arg1: !llvm.ptr<f64>, %arg2: i64, %arg3: i64, %arg4: i64) -> !llvm.struct<(struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)>, struct<(ptr<f64>, ptr<f64>, i64, array<3 x i64>, array<3 x i64>)>)> attributes {sym_visibility = "private"} { | |
| %0 = llvm.mlir.constant(false) : i1 | |
| %1 = llvm.mlir.constant(64 : index) : i64 | |
| %2 = llvm.mlir.constant(12 : index) : i64 | |
| %3 = llvm.mlir.constant(9.9999999999999995E-8 : f64) : f64 | |
| %4 = llvm.mlir.constant(3 : index) : i64 | |
| %5 = llvm.mlir.constant(1 : index) : i64 | |
| %6 = llvm.mlir.constant(4 : index) : i64 | |
| %7 = llvm.mlir.constant(0 : index) : i64 | |
| %8 = llvm.mlir.addressof @__constant_4x4xf64 : !llvm.ptr<array<4 x array<4 x f64>>> | |
| %9 = llvm.getelementptr %8[0, 0, 0] : (!llvm.ptr<array<4 x array<4 x f64>>>) -> !llvm.ptr<f64> | |
| %10 = llvm.mlir.addressof @__constant_4x3x4xf64 : !llvm.ptr<array<4 x array<3 x array<4 x f64>>>> | |
| %11 = llvm.getelementptr %10[0, 0, 0, 0] : (!llvm.ptr<array<4 x array<3 x array<4 x f64>>>>) -> !llvm.ptr<f64> | |
| %12 = llvm.call @f(%arg0, %arg1, %arg2, %arg3, %arg4) : (!llvm.ptr<f64>, !llvm.ptr<f64>, i64, i64, i64) -> !llvm.struct<(struct<(ptr<f64>, ptr<f64>, i64, array<1 x i64>, array<1 x i64>)>, struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)>)> | |
| %13 = llvm.extractvalue %12[0] : !llvm.struct<(struct<(ptr<f64>, ptr<f64>, i64, array<1 x i64>, array<1 x i64>)>, struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)>)> | |
| %14 = llvm.extractvalue %12[1] : !llvm.struct<(struct<(ptr<f64>, ptr<f64>, i64, array<1 x i64>, array<1 x i64>)>, struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)>)> | |
| %15 = llvm.mlir.null : !llvm.ptr<f64> | |
| %16 = llvm.getelementptr %15[16] : (!llvm.ptr<f64>) -> !llvm.ptr<f64> | |
| %17 = llvm.ptrtoint %16 : !llvm.ptr<f64> to i64 | |
| %18 = llvm.add %17, %1 : i64 | |
| %19 = llvm.call @malloc(%18) : (i64) -> !llvm.ptr<i8> | |
| %20 = llvm.bitcast %19 : !llvm.ptr<i8> to !llvm.ptr<f64> | |
| %21 = llvm.ptrtoint %20 : !llvm.ptr<f64> to i64 | |
| %22 = llvm.sub %1, %5 : i64 | |
| %23 = llvm.add %21, %22 : i64 | |
| %24 = llvm.urem %23, %1 : i64 | |
| %25 = llvm.sub %23, %24 : i64 | |
| %26 = llvm.inttoptr %25 : i64 to !llvm.ptr<f64> | |
| llvm.br ^bb1(%7 : i64) | |
| ^bb1(%27: i64): // 2 preds: ^bb0, ^bb8 | |
| %28 = llvm.icmp "slt" %27, %6 : i64 | |
| llvm.cond_br %28, ^bb2, ^bb9 | |
| ^bb2: // pred: ^bb1 | |
| llvm.br ^bb3(%7 : i64) | |
| ^bb3(%29: i64): // 2 preds: ^bb2, ^bb7 | |
| %30 = llvm.icmp "slt" %29, %6 : i64 | |
| llvm.cond_br %30, ^bb4, ^bb8 | |
| ^bb4: // pred: ^bb3 | |
| %31 = llvm.getelementptr %arg1[%27] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64> | |
| %32 = llvm.load %31 : !llvm.ptr<f64> | |
| %33 = llvm.fadd %32, %3 : f64 | |
| %34 = llvm.mlir.null : !llvm.ptr<f64> | |
| %35 = llvm.getelementptr %34[4] : (!llvm.ptr<f64>) -> !llvm.ptr<f64> | |
| %36 = llvm.ptrtoint %35 : !llvm.ptr<f64> to i64 | |
| %37 = llvm.add %36, %1 : i64 | |
| %38 = llvm.call @malloc(%37) : (i64) -> !llvm.ptr<i8> | |
| %39 = llvm.bitcast %38 : !llvm.ptr<i8> to !llvm.ptr<f64> | |
| %40 = llvm.ptrtoint %39 : !llvm.ptr<f64> to i64 | |
| %41 = llvm.sub %1, %5 : i64 | |
| %42 = llvm.add %40, %41 : i64 | |
| %43 = llvm.urem %42, %1 : i64 | |
| %44 = llvm.sub %42, %43 : i64 | |
| %45 = llvm.inttoptr %44 : i64 to !llvm.ptr<f64> | |
| %46 = llvm.mul %arg3, %5 : i64 | |
| %47 = llvm.mlir.null : !llvm.ptr<f64> | |
| %48 = llvm.getelementptr %47[1] : (!llvm.ptr<f64>) -> !llvm.ptr<f64> | |
| %49 = llvm.ptrtoint %48 : !llvm.ptr<f64> to i64 | |
| %50 = llvm.mul %46, %49 : i64 | |
| %51 = llvm.getelementptr %arg1[%arg2] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64> | |
| "llvm.intr.memcpy"(%45, %51, %50, %0) : (!llvm.ptr<f64>, !llvm.ptr<f64>, i64, i1) -> () | |
| %52 = llvm.getelementptr %45[%27] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64> | |
| llvm.store %33, %52 : !llvm.ptr<f64> | |
| %53 = llvm.call @f(%39, %45, %7, %6, %5) : (!llvm.ptr<f64>, !llvm.ptr<f64>, i64, i64, i64) -> !llvm.struct<(struct<(ptr<f64>, ptr<f64>, i64, array<1 x i64>, array<1 x i64>)>, struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)>)> | |
| %54 = llvm.extractvalue %53[0] : !llvm.struct<(struct<(ptr<f64>, ptr<f64>, i64, array<1 x i64>, array<1 x i64>)>, struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)>)> | |
| llvm.call @free(%38) : (!llvm.ptr<i8>) -> () | |
| %55 = llvm.mlir.null : !llvm.ptr<f64> | |
| %56 = llvm.getelementptr %55[4] : (!llvm.ptr<f64>) -> !llvm.ptr<f64> | |
| %57 = llvm.ptrtoint %56 : !llvm.ptr<f64> to i64 | |
| %58 = llvm.add %57, %1 : i64 | |
| %59 = llvm.call @malloc(%58) : (i64) -> !llvm.ptr<i8> | |
| %60 = llvm.bitcast %59 : !llvm.ptr<i8> to !llvm.ptr<f64> | |
| %61 = llvm.ptrtoint %60 : !llvm.ptr<f64> to i64 | |
| %62 = llvm.sub %1, %5 : i64 | |
| %63 = llvm.add %61, %62 : i64 | |
| %64 = llvm.urem %63, %1 : i64 | |
| %65 = llvm.sub %63, %64 : i64 | |
| %66 = llvm.inttoptr %65 : i64 to !llvm.ptr<f64> | |
| llvm.br ^bb5(%7 : i64) | |
| ^bb5(%67: i64): // 2 preds: ^bb4, ^bb6 | |
| %68 = llvm.icmp "slt" %67, %6 : i64 | |
| llvm.cond_br %68, ^bb6, ^bb7 | |
| ^bb6: // pred: ^bb5 | |
| %69 = llvm.extractvalue %54[1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<1 x i64>, array<1 x i64>)> | |
| %70 = llvm.getelementptr %69[%67] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64> | |
| %71 = llvm.load %70 : !llvm.ptr<f64> | |
| %72 = llvm.extractvalue %13[1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<1 x i64>, array<1 x i64>)> | |
| %73 = llvm.getelementptr %72[%67] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64> | |
| %74 = llvm.load %73 : !llvm.ptr<f64> | |
| %75 = llvm.fsub %71, %74 : f64 | |
| %76 = llvm.getelementptr %66[%67] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64> | |
| llvm.store %75, %76 : !llvm.ptr<f64> | |
| %77 = llvm.add %67, %5 : i64 | |
| llvm.br ^bb5(%77 : i64) | |
| ^bb7: // pred: ^bb5 | |
| %78 = llvm.getelementptr %66[%29] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64> | |
| %79 = llvm.load %78 : !llvm.ptr<f64> | |
| llvm.call @free(%59) : (!llvm.ptr<i8>) -> () | |
| %80 = llvm.mul %27, %6 : i64 | |
| %81 = llvm.add %80, %29 : i64 | |
| %82 = llvm.getelementptr %26[%81] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64> | |
| llvm.store %79, %82 : !llvm.ptr<f64> | |
| %83 = llvm.add %29, %5 : i64 | |
| llvm.br ^bb3(%83 : i64) | |
| ^bb8: // pred: ^bb3 | |
| %84 = llvm.add %27, %5 : i64 | |
| llvm.br ^bb1(%84 : i64) | |
| ^bb9: // pred: ^bb1 | |
| %85 = llvm.mlir.null : !llvm.ptr<f64> | |
| %86 = llvm.getelementptr %85[16] : (!llvm.ptr<f64>) -> !llvm.ptr<f64> | |
| %87 = llvm.ptrtoint %86 : !llvm.ptr<f64> to i64 | |
| %88 = llvm.add %87, %1 : i64 | |
| %89 = llvm.call @malloc(%88) : (i64) -> !llvm.ptr<i8> | |
| %90 = llvm.bitcast %89 : !llvm.ptr<i8> to !llvm.ptr<f64> | |
| %91 = llvm.ptrtoint %90 : !llvm.ptr<f64> to i64 | |
| %92 = llvm.sub %1, %5 : i64 | |
| %93 = llvm.add %91, %92 : i64 | |
| %94 = llvm.urem %93, %1 : i64 | |
| %95 = llvm.sub %93, %94 : i64 | |
| %96 = llvm.inttoptr %95 : i64 to !llvm.ptr<f64> | |
| %97 = llvm.mlir.undef : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)> | |
| %98 = llvm.insertvalue %90, %97[0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)> | |
| %99 = llvm.insertvalue %96, %98[1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)> | |
| %100 = llvm.insertvalue %7, %99[2] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)> | |
| %101 = llvm.insertvalue %6, %100[3, 0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)> | |
| %102 = llvm.insertvalue %6, %101[3, 1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)> | |
| %103 = llvm.insertvalue %6, %102[4, 0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)> | |
| %104 = llvm.insertvalue %5, %103[4, 1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)> | |
| llvm.br ^bb10(%7 : i64) | |
| ^bb10(%105: i64): // 2 preds: ^bb9, ^bb14 | |
| %106 = llvm.icmp "slt" %105, %6 : i64 | |
| llvm.cond_br %106, ^bb11, ^bb15 | |
| ^bb11: // pred: ^bb10 | |
| llvm.br ^bb12(%7 : i64) | |
| ^bb12(%107: i64): // 2 preds: ^bb11, ^bb13 | |
| %108 = llvm.icmp "slt" %107, %6 : i64 | |
| llvm.cond_br %108, ^bb13, ^bb14 | |
| ^bb13: // pred: ^bb12 | |
| %109 = llvm.mul %105, %6 : i64 | |
| %110 = llvm.add %109, %107 : i64 | |
| %111 = llvm.getelementptr %26[%110] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64> | |
| %112 = llvm.load %111 : !llvm.ptr<f64> | |
| %113 = llvm.mul %105, %6 : i64 | |
| %114 = llvm.add %113, %107 : i64 | |
| %115 = llvm.getelementptr %9[%114] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64> | |
| %116 = llvm.load %115 : !llvm.ptr<f64> | |
| %117 = llvm.fdiv %112, %116 : f64 | |
| %118 = llvm.mul %105, %6 : i64 | |
| %119 = llvm.add %118, %107 : i64 | |
| %120 = llvm.getelementptr %96[%119] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64> | |
| llvm.store %117, %120 : !llvm.ptr<f64> | |
| %121 = llvm.add %107, %5 : i64 | |
| llvm.br ^bb12(%121 : i64) | |
| ^bb14: // pred: ^bb12 | |
| %122 = llvm.add %105, %5 : i64 | |
| llvm.br ^bb10(%122 : i64) | |
| ^bb15: // pred: ^bb10 | |
| llvm.call @free(%19) : (!llvm.ptr<i8>) -> () | |
| %123 = llvm.mlir.null : !llvm.ptr<f64> | |
| %124 = llvm.getelementptr %123[48] : (!llvm.ptr<f64>) -> !llvm.ptr<f64> | |
| %125 = llvm.ptrtoint %124 : !llvm.ptr<f64> to i64 | |
| %126 = llvm.add %125, %1 : i64 | |
| %127 = llvm.call @malloc(%126) : (i64) -> !llvm.ptr<i8> | |
| %128 = llvm.bitcast %127 : !llvm.ptr<i8> to !llvm.ptr<f64> | |
| %129 = llvm.ptrtoint %128 : !llvm.ptr<f64> to i64 | |
| %130 = llvm.sub %1, %5 : i64 | |
| %131 = llvm.add %129, %130 : i64 | |
| %132 = llvm.urem %131, %1 : i64 | |
| %133 = llvm.sub %131, %132 : i64 | |
| %134 = llvm.inttoptr %133 : i64 to !llvm.ptr<f64> | |
| llvm.br ^bb16(%7 : i64) | |
| ^bb16(%135: i64): // 2 preds: ^bb15, ^bb29 | |
| %136 = llvm.icmp "slt" %135, %6 : i64 | |
| llvm.cond_br %136, ^bb17, ^bb30 | |
| ^bb17: // pred: ^bb16 | |
| llvm.br ^bb18(%7 : i64) | |
| ^bb18(%137: i64): // 2 preds: ^bb17, ^bb28 | |
| %138 = llvm.icmp "slt" %137, %4 : i64 | |
| llvm.cond_br %138, ^bb19, ^bb29 | |
| ^bb19: // pred: ^bb18 | |
| llvm.br ^bb20(%7 : i64) | |
| ^bb20(%139: i64): // 2 preds: ^bb19, ^bb27 | |
| %140 = llvm.icmp "slt" %139, %6 : i64 | |
| llvm.cond_br %140, ^bb21, ^bb28 | |
| ^bb21: // pred: ^bb20 | |
| %141 = llvm.getelementptr %arg1[%135] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64> | |
| %142 = llvm.load %141 : !llvm.ptr<f64> | |
| %143 = llvm.fadd %142, %3 : f64 | |
| %144 = llvm.mlir.null : !llvm.ptr<f64> | |
| %145 = llvm.getelementptr %144[4] : (!llvm.ptr<f64>) -> !llvm.ptr<f64> | |
| %146 = llvm.ptrtoint %145 : !llvm.ptr<f64> to i64 | |
| %147 = llvm.add %146, %1 : i64 | |
| %148 = llvm.call @malloc(%147) : (i64) -> !llvm.ptr<i8> | |
| %149 = llvm.bitcast %148 : !llvm.ptr<i8> to !llvm.ptr<f64> | |
| %150 = llvm.ptrtoint %149 : !llvm.ptr<f64> to i64 | |
| %151 = llvm.sub %1, %5 : i64 | |
| %152 = llvm.add %150, %151 : i64 | |
| %153 = llvm.urem %152, %1 : i64 | |
| %154 = llvm.sub %152, %153 : i64 | |
| %155 = llvm.inttoptr %154 : i64 to !llvm.ptr<f64> | |
| %156 = llvm.mul %arg3, %5 : i64 | |
| %157 = llvm.mlir.null : !llvm.ptr<f64> | |
| %158 = llvm.getelementptr %157[1] : (!llvm.ptr<f64>) -> !llvm.ptr<f64> | |
| %159 = llvm.ptrtoint %158 : !llvm.ptr<f64> to i64 | |
| %160 = llvm.mul %156, %159 : i64 | |
| %161 = llvm.getelementptr %arg1[%arg2] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64> | |
| "llvm.intr.memcpy"(%155, %161, %160, %0) : (!llvm.ptr<f64>, !llvm.ptr<f64>, i64, i1) -> () | |
| %162 = llvm.getelementptr %155[%135] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64> | |
| llvm.store %143, %162 : !llvm.ptr<f64> | |
| %163 = llvm.call @f(%149, %155, %7, %6, %5) : (!llvm.ptr<f64>, !llvm.ptr<f64>, i64, i64, i64) -> !llvm.struct<(struct<(ptr<f64>, ptr<f64>, i64, array<1 x i64>, array<1 x i64>)>, struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)>)> | |
| %164 = llvm.extractvalue %163[1] : !llvm.struct<(struct<(ptr<f64>, ptr<f64>, i64, array<1 x i64>, array<1 x i64>)>, struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)>)> | |
| llvm.call @free(%148) : (!llvm.ptr<i8>) -> () | |
| %165 = llvm.mlir.null : !llvm.ptr<f64> | |
| %166 = llvm.getelementptr %165[12] : (!llvm.ptr<f64>) -> !llvm.ptr<f64> | |
| %167 = llvm.ptrtoint %166 : !llvm.ptr<f64> to i64 | |
| %168 = llvm.add %167, %1 : i64 | |
| %169 = llvm.call @malloc(%168) : (i64) -> !llvm.ptr<i8> | |
| %170 = llvm.bitcast %169 : !llvm.ptr<i8> to !llvm.ptr<f64> | |
| %171 = llvm.ptrtoint %170 : !llvm.ptr<f64> to i64 | |
| %172 = llvm.sub %1, %5 : i64 | |
| %173 = llvm.add %171, %172 : i64 | |
| %174 = llvm.urem %173, %1 : i64 | |
| %175 = llvm.sub %173, %174 : i64 | |
| %176 = llvm.inttoptr %175 : i64 to !llvm.ptr<f64> | |
| llvm.br ^bb22(%7 : i64) | |
| ^bb22(%177: i64): // 2 preds: ^bb21, ^bb26 | |
| %178 = llvm.icmp "slt" %177, %4 : i64 | |
| llvm.cond_br %178, ^bb23, ^bb27 | |
| ^bb23: // pred: ^bb22 | |
| llvm.br ^bb24(%7 : i64) | |
| ^bb24(%179: i64): // 2 preds: ^bb23, ^bb25 | |
| %180 = llvm.icmp "slt" %179, %6 : i64 | |
| llvm.cond_br %180, ^bb25, ^bb26 | |
| ^bb25: // pred: ^bb24 | |
| %181 = llvm.extractvalue %164[1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)> | |
| %182 = llvm.mul %177, %6 : i64 | |
| %183 = llvm.add %182, %179 : i64 | |
| %184 = llvm.getelementptr %181[%183] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64> | |
| %185 = llvm.load %184 : !llvm.ptr<f64> | |
| %186 = llvm.extractvalue %14[1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)> | |
| %187 = llvm.mul %177, %6 : i64 | |
| %188 = llvm.add %187, %179 : i64 | |
| %189 = llvm.getelementptr %186[%188] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64> | |
| %190 = llvm.load %189 : !llvm.ptr<f64> | |
| %191 = llvm.fsub %185, %190 : f64 | |
| %192 = llvm.mul %177, %6 : i64 | |
| %193 = llvm.add %192, %179 : i64 | |
| %194 = llvm.getelementptr %176[%193] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64> | |
| llvm.store %191, %194 : !llvm.ptr<f64> | |
| %195 = llvm.add %179, %5 : i64 | |
| llvm.br ^bb24(%195 : i64) | |
| ^bb26: // pred: ^bb24 | |
| %196 = llvm.add %177, %5 : i64 | |
| llvm.br ^bb22(%196 : i64) | |
| ^bb27: // pred: ^bb22 | |
| %197 = llvm.mul %137, %6 : i64 | |
| %198 = llvm.add %197, %139 : i64 | |
| %199 = llvm.getelementptr %176[%198] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64> | |
| %200 = llvm.load %199 : !llvm.ptr<f64> | |
| llvm.call @free(%169) : (!llvm.ptr<i8>) -> () | |
| %201 = llvm.mul %135, %2 : i64 | |
| %202 = llvm.mul %137, %6 : i64 | |
| %203 = llvm.add %201, %202 : i64 | |
| %204 = llvm.add %203, %139 : i64 | |
| %205 = llvm.getelementptr %134[%204] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64> | |
| llvm.store %200, %205 : !llvm.ptr<f64> | |
| %206 = llvm.add %139, %5 : i64 | |
| llvm.br ^bb20(%206 : i64) | |
| ^bb28: // pred: ^bb20 | |
| %207 = llvm.add %137, %5 : i64 | |
| llvm.br ^bb18(%207 : i64) | |
| ^bb29: // pred: ^bb18 | |
| %208 = llvm.add %135, %5 : i64 | |
| llvm.br ^bb16(%208 : i64) | |
| ^bb30: // pred: ^bb16 | |
| %209 = llvm.mlir.null : !llvm.ptr<f64> | |
| %210 = llvm.getelementptr %209[48] : (!llvm.ptr<f64>) -> !llvm.ptr<f64> | |
| %211 = llvm.ptrtoint %210 : !llvm.ptr<f64> to i64 | |
| %212 = llvm.add %211, %1 : i64 | |
| %213 = llvm.call @malloc(%212) : (i64) -> !llvm.ptr<i8> | |
| %214 = llvm.bitcast %213 : !llvm.ptr<i8> to !llvm.ptr<f64> | |
| %215 = llvm.ptrtoint %214 : !llvm.ptr<f64> to i64 | |
| %216 = llvm.sub %1, %5 : i64 | |
| %217 = llvm.add %215, %216 : i64 | |
| %218 = llvm.urem %217, %1 : i64 | |
| %219 = llvm.sub %217, %218 : i64 | |
| %220 = llvm.inttoptr %219 : i64 to !llvm.ptr<f64> | |
| %221 = llvm.mlir.undef : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<3 x i64>, array<3 x i64>)> | |
| %222 = llvm.insertvalue %214, %221[0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<3 x i64>, array<3 x i64>)> | |
| %223 = llvm.insertvalue %220, %222[1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<3 x i64>, array<3 x i64>)> | |
| %224 = llvm.insertvalue %7, %223[2] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<3 x i64>, array<3 x i64>)> | |
| %225 = llvm.insertvalue %6, %224[3, 0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<3 x i64>, array<3 x i64>)> | |
| %226 = llvm.insertvalue %4, %225[3, 1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<3 x i64>, array<3 x i64>)> | |
| %227 = llvm.insertvalue %6, %226[3, 2] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<3 x i64>, array<3 x i64>)> | |
| %228 = llvm.insertvalue %2, %227[4, 0] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<3 x i64>, array<3 x i64>)> | |
| %229 = llvm.insertvalue %6, %228[4, 1] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<3 x i64>, array<3 x i64>)> | |
| %230 = llvm.insertvalue %5, %229[4, 2] : !llvm.struct<(ptr<f64>, ptr<f64>, i64, array<3 x i64>, array<3 x i64>)> | |
| llvm.br ^bb31(%7 : i64) | |
| ^bb31(%231: i64): // 2 preds: ^bb30, ^bb38 | |
| %232 = llvm.icmp "slt" %231, %6 : i64 | |
| llvm.cond_br %232, ^bb32, ^bb39 | |
| ^bb32: // pred: ^bb31 | |
| llvm.br ^bb33(%7 : i64) | |
| ^bb33(%233: i64): // 2 preds: ^bb32, ^bb37 | |
| %234 = llvm.icmp "slt" %233, %4 : i64 | |
| llvm.cond_br %234, ^bb34, ^bb38 | |
| ^bb34: // pred: ^bb33 | |
| llvm.br ^bb35(%7 : i64) | |
| ^bb35(%235: i64): // 2 preds: ^bb34, ^bb36 | |
| %236 = llvm.icmp "slt" %235, %6 : i64 | |
| llvm.cond_br %236, ^bb36, ^bb37 | |
| ^bb36: // pred: ^bb35 | |
| %237 = llvm.mul %231, %2 : i64 | |
| %238 = llvm.mul %233, %6 : i64 | |
| %239 = llvm.add %237, %238 : i64 | |
| %240 = llvm.add %239, %235 : i64 | |
| %241 = llvm.getelementptr %134[%240] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64> | |
| %242 = llvm.load %241 : !llvm.ptr<f64> | |
| %243 = llvm.mul %231, %2 : i64 | |
| %244 = llvm.mul %233, %6 : i64 | |
| %245 = llvm.add %243, %244 : i64 | |
| %246 = llvm.add %245, %235 : i64 | |
| %247 = llvm.getelementptr %11[%246] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64> | |
| %248 = llvm.load %247 : !llvm.ptr<f64> | |
| %249 = llvm.fdiv %242, %248 : f64 | |
| %250 = llvm.mul %231, %2 : i64 | |
| %251 = llvm.mul %233, %6 : i64 | |
| %252 = llvm.add %250, %251 : i64 | |
| %253 = llvm.add %252, %235 : i64 | |
| %254 = llvm.getelementptr %220[%253] : (!llvm.ptr<f64>, i64) -> !llvm.ptr<f64> | |
| llvm.store %249, %254 : !llvm.ptr<f64> | |
| %255 = llvm.add %235, %5 : i64 | |
| llvm.br ^bb35(%255 : i64) | |
| ^bb37: // pred: ^bb35 | |
| %256 = llvm.add %233, %5 : i64 | |
| llvm.br ^bb33(%256 : i64) | |
| ^bb38: // pred: ^bb33 | |
| %257 = llvm.add %231, %5 : i64 | |
| llvm.br ^bb31(%257 : i64) | |
| ^bb39: // pred: ^bb31 | |
| llvm.call @free(%127) : (!llvm.ptr<i8>) -> () | |
| %258 = llvm.mlir.undef : !llvm.struct<(struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)>, struct<(ptr<f64>, ptr<f64>, i64, array<3 x i64>, array<3 x i64>)>)> | |
| %259 = llvm.insertvalue %104, %258[0] : !llvm.struct<(struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)>, struct<(ptr<f64>, ptr<f64>, i64, array<3 x i64>, array<3 x i64>)>)> | |
| %260 = llvm.insertvalue %230, %259[1] : !llvm.struct<(struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)>, struct<(ptr<f64>, ptr<f64>, i64, array<3 x i64>, array<3 x i64>)>)> | |
| llvm.return %260 : !llvm.struct<(struct<(ptr<f64>, ptr<f64>, i64, array<2 x i64>, array<2 x i64>)>, struct<(ptr<f64>, ptr<f64>, i64, array<3 x i64>, array<3 x i64>)>)> | |
| } | |
| llvm.func @setup() { | |
| %0 = llvm.mlir.addressof @backend : !llvm.ptr<array<8 x i8>> | |
| %1 = llvm.getelementptr %0[0, 0] : (!llvm.ptr<array<8 x i8>>) -> !llvm.ptr<i8> | |
| %2 = llvm.mlir.addressof @backend_best : !llvm.ptr<array<5 x i8>> | |
| %3 = llvm.getelementptr %2[0, 0] : (!llvm.ptr<array<5 x i8>>) -> !llvm.ptr<i8> | |
| llvm.call @__quantum__rt__device(%1, %3) : (!llvm.ptr<i8>, !llvm.ptr<i8>) -> () | |
| llvm.call @__quantum__rt__initialize() : () -> () | |
| llvm.return | |
| } | |
| llvm.func @teardown() { | |
| llvm.call @__quantum__rt__finalize() : () -> () | |
| llvm.return | |
| } | |
| } | |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment