Failed while2for

```
imported mlir mod: module attributes {dlti.dl_spec = #dlti.dl_spec = dense<32> : vector<4xi64>, !llvm.ptr<271> = dense<32> : vector<4xi64>, !llvm.ptr<272> = dense<64> : vector<4xi64>, i64 = dense<64> : vector<2xi64>, i128 = dense<128> : vector<2xi64>, f80 = dense<128> : vector<2xi64>, !llvm.ptr = dense<64> : vector<4xi64>, i1 = dense<8> : vector<2xi64>, i8 = dense<8> : vector<2xi64>, i16 = dense<16> : vector<2xi64>, i32 = dense<32> : vector<2xi64>, f16 = dense<16> : vector<2xi64>, f64 = dense<64> : vector<2xi64>, f128 = dense<128> : vector<2xi64>, "dlti.endianness" = "little", "dlti.mangling_mode" = "e", "dlti.legal_int_widths" = array, "dlti.stack_alignment" = 128 : i64>, llvm.target_triple = "x86_64-unknown-linux-gnu"} {
llvm.mlir.global external local_unnamed_addr @enzyme_dup() {addr_space = 0 : i32, alignment = 4 : i64} : i32
llvm.mlir.global external local_unnamed_addr @enzyme_const() {addr_space = 0 : i32, alignment = 4 : i64} : i32
llvm.module_flags [#llvm.mlir.module_flag, #llvm.mlir.module_flag, #llvm.mlir.module_flag, #llvm.mlir.module_flag, #llvm.mlir.module_flag, #llvm.mlir.module_flag]
llvm.func @_Z26calculate_potential_energyP8Particleid(%arg0: !llvm.ptr {llvm.nocapture, llvm.noundef, llvm.readonly}, %arg1: i32 {llvm.noundef}, %arg2: f64 {llvm.noundef}) -> (f64 {llvm.noundef}) attributes {dso_local, memory_effects = #llvm.memory_effects, no_unwind, passthrough = ["mustprogress", "nofree", "norecurse", "nosync", ["min-legal-vector-width", "0"], ["no-trapping-math", "true"], ["stack-protector-buffer-size", "8"], ["target-cpu", "x86-64"]], target_cpu = "x86-64", target_features = #llvm.target_features<["+cmov", "+cx8", "+fxsr", "+mmx", "+sse", "+sse2", "+x87"]>, tune_cpu = "generic", uwtable_kind = #llvm.uwtableKind, will_return} {
%0 = llvm.mlir.constant(0 : i32) : i32
%1 = llvm.mlir.constant(0.000000e+00 : f64) : f64
%2 = llvm.mlir.constant(0 : i64) : i64
%3 = llvm.mlir.constant(1 : i64) : i64
%4 = llvm.mlir.constant(8 : i64) : i64
%5 = llvm.mlir.constant(16 : i64) : i64
%6 = llvm.mlir.constant(4.000000e+00 : f64) : f64
%7 = llvm.mlir.constant(1.000000e+00 : f64) : f64
%8 = llvm.icmp "sgt" %arg1, %0 : i32
llvm.cond_br %8, ^bb1, ^bb3(%1 : f64)
^bb1: // pred: ^bb0
%9 = llvm.fneg %arg2 : f64
%10 = llvm.zext nneg %arg1 : i32 to i64
%11 = llvm.zext nneg %arg1 : i32 to i64
llvm.br ^bb4(%2, %3, %1 : i64, i64, f64)
^bb2(%12: f64): // 2 preds: ^bb4, ^bb8
%13 = llvm.add %17, %3 overflow : i64
%14 = llvm.icmp "eq" %19, %11 : i64
llvm.cond_br %14, ^bb3(%12 : f64), ^bb4(%19, %13, %12 : i64, i64, f64) {loop_annotation = #llvm.loop_annotation, mustProgress = true>}
^bb3(%15: f64): // 2 preds: ^bb0, ^bb2
llvm.return %15 : f64
^bb4(%16: i64, %17: i64, %18: f64): // 2 preds: ^bb1, ^bb2
%19 = llvm.add %16, %3 overflow : i64
%20 = llvm.icmp "ult" %19, %10 : i64
llvm.cond_br %20, ^bb5, ^bb2(%18 : f64)
^bb5: // pred: ^bb4
%21 = llvm.getelementptr inbounds|nuw %arg0[%16] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<"struct.Particle", (struct<"struct.Vec3", (f64, f64, f64)>, struct<"struct.Vec3", (f64, f64, f64)>, struct<"struct.Vec3", (f64, f64, f64)>)>
%22 = llvm.load %21 {alignment = 8 : i64, tbaa = [#llvm.tbaa_tag, 0>}>, 0>}>, access_type = , 0>}>, 0>}>, offset = 0>]} : !llvm.ptr -> f64
%23 = llvm.getelementptr inbounds|nuw %21[%4] : (!llvm.ptr, i64) -> !llvm.ptr, i8
%24 = llvm.load %23 {alignment = 8 : i64, tbaa = [#llvm.tbaa_tag, 0>}>, 0>}>, access_type = , 0>}>, 0>}>, offset = 0>]} : !llvm.ptr -> f64
%25 = llvm.getelementptr inbounds|nuw %21[%5] : (!llvm.ptr, i64) -> !llvm.ptr, i8
%26 = llvm.load %25 {alignment = 8 : i64, tbaa = [#llvm.tbaa_tag, 0>}>, 0>}>, access_type = , 0>}>, 0>}>, offset = 0>]} : !llvm.ptr -> f64
%27 = llvm.zext nneg %arg1 : i32 to i64
llvm.br ^bb6(%17, %18 : i64, f64)
^bb6(%28: i64, %29: f64): // 2 preds: ^bb5, ^bb8
%30 = llvm.getelementptr inbounds|nuw %arg0[%28] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<"struct.Particle", (struct<"struct.Vec3", (f64, f64, f64)>, struct<"struct.Vec3", (f64, f64, f64)>, struct<"struct.Vec3", (f64, f64, f64)>)>
%31 = llvm.load %30 {alignment = 8 : i64, tbaa = [#llvm.tbaa_tag, 0>}>, 0>}>, access_type = , 0>}>, 0>}>, offset = 0>]} : !llvm.ptr -> f64
%32 = llvm.getelementptr inbounds|nuw %30[%4] : (!llvm.ptr, i64) -> !llvm.ptr, i8
%33 = llvm.load %32 {alignment = 8 : i64, tbaa = [#llvm.tbaa_tag, 0>}>, 0>}>, access_type = , 0>}>, 0>}>, offset = 0>]} : !llvm.ptr -> f64
%34 = llvm.getelementptr inbounds|nuw %30[%5] : (!llvm.ptr, i64) -> !llvm.ptr, i8
%35 = llvm.load %34 {alignment = 8 : i64, tbaa = [#llvm.tbaa_tag, 0>}>, 0>}>, access_type = , 0>}>, 0>}>, offset = 0>]} : !llvm.ptr -> f64
%36 = llvm.fsub %22, %31 : f64
%37 = llvm.fsub %24, %33 : f64
%38 = llvm.fsub %26, %35 : f64
%39 = llvm.fdiv %36, %arg2 : f64
%40 = llvm.intr.round(%39) : (f64) -> f64
%41 = llvm.intr.fmuladd(%9, %40, %36) : (f64, f64, f64) -> f64
%42 = llvm.fdiv %37, %arg2 : f64
%43 = llvm.intr.round(%42) : (f64) -> f64
%44 = llvm.intr.fmuladd(%9, %43, %37) : (f64, f64, f64) -> f64
%45 = llvm.fdiv %38, %arg2 : f64
%46 = llvm.intr.round(%45) : (f64) -> f64
%47 = llvm.intr.fmuladd(%9, %46, %38) : (f64, f64, f64) -> f64
%48 = llvm.fmul %44, %44 : f64
%49 = llvm.intr.fmuladd(%41, %41, %48) : (f64, f64, f64) -> f64
%50 = llvm.intr.fmuladd(%47, %47, %49) : (f64, f64, f64) -> f64
%51 = llvm.fcmp "olt" %50, %6 : f64
llvm.cond_br %51, ^bb7, ^bb8(%29 : f64)
^bb7: // pred: ^bb6
%52 = llvm.fmul %50, %50 : f64
%53 = llvm.fmul %50, %52 : f64
%54 = llvm.fmul %53, %53 : f64
%55 = llvm.fdiv %7, %54 : f64
%56 = llvm.fdiv %7, %53 : f64
%57 = llvm.fsub %55, %56 : f64
%58 = llvm.intr.fmuladd(%57, %6, %29) : (f64, f64, f64) -> f64
llvm.br ^bb8(%58 : f64)
^bb8(%59: f64): // 2 preds: ^bb6, ^bb7
%60 = llvm.add %28, %3 overflow : i64
%61 = llvm.icmp "eq" %60, %27 : i64
llvm.cond_br %61, ^bb2(%59 : f64), ^bb6(%60, %59 : i64, f64) {loop_annotation = #llvm.loop_annotation, mustProgress = true>}
}
llvm.func local_unnamed_addr @_Z21host_autodiff_wrapperP8Particleiid(%arg0: !llvm.ptr {llvm.noundef}, %arg1: i32 {llvm.noundef}, %arg2: i32 {llvm.noundef}, %arg3: f64 {llvm.noundef}) attributes {dso_local, no_unwind, passthrough = ["mustprogress", ["min-legal-vector-width", "0"], ["no-trapping-math", "true"], ["stack-protector-buffer-size", "8"], ["target-cpu", "x86-64"]], target_cpu = "x86-64", target_features = #llvm.target_features<["+cmov", "+cx8", "+fxsr", "+mmx", "+sse", "+sse2", "+x87"]>, tune_cpu = "generic", uwtable_kind = #llvm.uwtableKind} {
%0 = llvm.mlir.constant(0 : i32) : i32
%1 = llvm.mlir.constant(0 : i64) : i64
%2 = llvm.mlir.constant(2 : i32) : i32
%3 = llvm.mlir.constant(0 : i8) : i8
%4 = llvm.mlir.constant(24 : i64) : i64
%5 = llvm.mlir.constant(1 : i64) : i64
%6 = llvm.mlir.constant(48 : i64) : i64
%7 = llvm.mlir.addressof @enzyme_dup : !llvm.ptr
%8 = llvm.mlir.addressof @enzyme_const : !llvm.ptr
%9 = llvm.mlir.addressof @_Z26calculate_potential_energyP8Particleid : !llvm.ptr
%10 = llvm.mul %arg2, %arg1 overflow : i32
%11 = llvm.icmp "sgt" %10, %0 : i32
llvm.cond_br %11, ^bb1, ^bb2
^bb1: // pred: ^bb0
%12 = llvm.zext nneg %10 : i32 to i64
llvm.br ^bb3(%1 : i64)
^bb2: // 2 preds: ^bb0, ^bb3
%13 = llvm.getelementptr inbounds|nuw %arg0[%6] : (!llvm.ptr, i64) -> !llvm.ptr, i8
%14 = llvm.load %7 {alignment = 4 : i64, tbaa = [#llvm.tbaa_tag, 0>}>, 0>}>, access_type = , 0>}>, 0>}>, offset = 0>]} : !llvm.ptr -> i32
%15 = llvm.load %8 {alignment = 4 : i64, tbaa = [#llvm.tbaa_tag, 0>}>, 0>}>, access_type = , 0>}>, 0>}>, offset = 0>]} : !llvm.ptr -> i32
llvm.call @__enzyme_autodiff(%9, %14, %arg0, %13, %15, %arg1, %15, %arg3) vararg(!llvm.func) {no_unwind} : (!llvm.ptr {llvm.nonnull, llvm.noundef}, i32 {llvm.noundef}, !llvm.ptr {llvm.noundef}, !llvm.ptr {llvm.nonnull, llvm.noundef}, i32 {llvm.noundef}, i32 {llvm.noundef}, i32 {llvm.noundef}, f64 {llvm.noundef}) -> ()
llvm.return
^bb3(%16: i64): // 2 preds: ^bb1, ^bb3
%17 = llvm.getelementptr inbounds|nuw %arg0[%16, 2] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<"struct.Particle", (struct<"struct.Vec3", (f64, f64, f64)>, struct<"struct.Vec3", (f64, f64, f64)>, struct<"struct.Vec3", (f64, f64, f64)>)>
"llvm.intr.memset"(%17, %3, %4) <{isVolatile = false}> : (!llvm.ptr, i8, i64) -> ()
%18 = llvm.add %16, %5 overflow : i64
%19 = llvm.icmp "eq" %18, %12 : i64
llvm.cond_br %19, ^bb2, ^bb3(%18 : i64) {loop_annotation = #llvm.loop_annotation, mustProgress = true>}
}
llvm.func local_unnamed_addr @__enzyme_autodiff(!llvm.ptr {llvm.noundef}, ...) attributes {passthrough = [["no-trapping-math", "true"], ["stack-protector-buffer-size", "8"], ["target-cpu", "x86-64"]], target_cpu = "x86-64", target_features = #llvm.target_features<["+cmov", "+cx8", "+fxsr", "+mmx", "+sse", "+sse2", "+x87"]>, tune_cpu = "generic"}
llvm.func local_unnamed_addr @_Z37run_autodiff_simulation_step_launcherP8Particleiid(%arg0: !llvm.ptr {llvm.noundef}, %arg1: i32 {llvm.noundef}, %arg2: i32 {llvm.noundef}, %arg3: f64 {llvm.noundef}) attributes {dso_local, no_unwind, passthrough = ["mustprogress", ["min-legal-vector-width", "0"], ["no-trapping-math", "true"], ["stack-protector-buffer-size", "8"], ["target-cpu", "x86-64"]], target_cpu = "x86-64", target_features = #llvm.target_features<["+cmov", "+cx8", "+fxsr", "+mmx", "+sse", "+sse2", "+x87"]>, tune_cpu = "generic", uwtable_kind = #llvm.uwtableKind} {
%0 = llvm.mlir.constant(1 : i32) : i32
%1 = llvm.mlir.constant(0 : i32) : i32
%2 = llvm.mlir.constant(0 : i64) : i64
%3 = llvm.mlir.constant(2 : i32) : i32
%4 = llvm.mlir.constant(0 : i8) : i8
%5 = llvm.mlir.constant(24 : i64) : i64
%6 = llvm.mlir.constant(1 : i64) : i64
%7 = llvm.mlir.constant(48 : i64) : i64
%8 = llvm.mlir.addressof @enzyme_dup : !llvm.ptr
%9 = llvm.mlir.addressof @enzyme_const : !llvm.ptr
%10 = llvm.mlir.addressof @_Z26calculate_potential_energyP8Particleid : !llvm.ptr
%11 = llvm.mlir.constant(4294967296 : i64) : i64
%12 = llvm.mlir.constant(4294967552 : i64) : i64
%13 = llvm.mlir.zero : !llvm.ptr
%14 = llvm.mlir.constant(8 : i64) : i64
%15 = llvm.mlir.constant(16 : i64) : i64
%16 = llvm.mlir.constant(2 : i64) : i64
%17 = llvm.mlir.constant(32 : i64) : i64
%18 = llvm.mlir.addressof @_Z35__device_stub__negate_forces_kernelP8Particleii : !llvm.ptr
%19 = llvm.alloca %0 x !llvm.ptr {alignment = 8 : i64} : (i32) -> !llvm.ptr
%20 = llvm.alloca %0 x i32 {alignment = 4 : i64} : (i32) -> !llvm.ptr
%21 = llvm.alloca %0 x i32 {alignment = 4 : i64} : (i32) -> !llvm.ptr
%22 = llvm.alloca %0 x !llvm.struct<"struct.dim3", (i32, i32, i32)> {alignment = 8 : i64} : (i32) -> !llvm.ptr
%23 = llvm.alloca %0 x !llvm.struct<"struct.dim3", (i32, i32, i32)> {alignment = 8 : i64} : (i32) -> !llvm.ptr
%24 = llvm.alloca %0 x i64 {alignment = 8 : i64} : (i32) -> !llvm.ptr
%25 = llvm.alloca %0 x !llvm.ptr {alignment = 8 : i64} : (i32) -> !llvm.ptr
%26 = llvm.alloca %0 x !llvm.array<3 x ptr> {alignment = 16 : i64} : (i32) -> !llvm.ptr
%27 = llvm.alloca %0 x i64 {alignment = 8 : i64} : (i32) -> !llvm.ptr
%28 = llvm.alloca %0 x i32 {alignment = 4 : i64} : (i32) -> !llvm.ptr
%29 = llvm.alloca %0 x i64 {alignment = 8 : i64} : (i32) -> !llvm.ptr
%30 = llvm.alloca %0 x i32 {alignment = 4 : i64} : (i32) -> !llvm.ptr
%31 = llvm.alloca %0 x i64 {alignment = 8 : i64} : (i32) -> !llvm.ptr
%32 = llvm.alloca %0 x !llvm.ptr {alignment = 8 : i64} : (i32) -> !llvm.ptr
%33 = llvm.mul %arg2, %arg1 overflow : i32
%34 = llvm.icmp "sgt" %33, %1 : i32
llvm.cond_br %34, ^bb1, ^bb3
^bb1: // pred: ^bb0
%35 = llvm.zext nneg %33 : i32 to i64
llvm.br ^bb2(%2 : i64)
^bb2(%36: i64): // 2 preds: ^bb1, ^bb2
%37 = llvm.getelementptr inbounds|nuw %arg0[%36, 2] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<"struct.Particle", (struct<"struct.Vec3", (f64, f64, f64)>, struct<"struct.Vec3", (f64, f64, f64)>, struct<"struct.Vec3", (f64, f64, f64)>)>
"llvm.intr.memset"(%37, %4, %5) <{isVolatile = false}> : (!llvm.ptr, i8, i64) -> ()
%38 = llvm.add %36, %6 overflow : i64
%39 = llvm.icmp "eq" %38, %35 : i64
llvm.cond_br %39, ^bb3, ^bb2(%38 : i64) {loop_annotation = #llvm.loop_annotation, mustProgress = true>}
^bb3: // 2 preds: ^bb0, ^bb2
%40 = llvm.getelementptr inbounds|nuw %arg0[%7] : (!llvm.ptr, i64) -> !llvm.ptr, i8
%41 = llvm.load %8 {alignment = 4 : i64, tbaa = [#llvm.tbaa_tag, 0>}>, 0>}>, access_type = , 0>}>, 0>}>, offset = 0>]} : !llvm.ptr -> i32
%42 = llvm.load %9 {alignment = 4 : i64, tbaa = [#llvm.tbaa_tag, 0>}>, 0>}>, access_type = , 0>}>, 0>}>, offset = 0>]} : !llvm.ptr -> i32
llvm.call @__enzyme_autodiff(%10, %41, %arg0, %40, %42, %arg1, %42, %arg3) vararg(!llvm.func) {no_unwind} : (!llvm.ptr {llvm.nonnull, llvm.noundef}, i32 {llvm.noundef}, !llvm.ptr {llvm.noundef}, !llvm.ptr {llvm.nonnull, llvm.noundef}, i32 {llvm.noundef}, i32 {llvm.noundef}, i32 {llvm.noundef}, f64 {llvm.noundef}) -> ()
%43 = llvm.zext %arg2 : i32 to i64
%44 = llvm.or disjoint %43, %11 : i64
llvm.store %44, %27 {alignment = 8 : i64} : i64, !llvm.ptr
llvm.store %0, %28 {alignment = 4 : i64} : i32, !llvm.ptr
llvm.store %12, %29 {alignment = 8 : i64} : i64, !llvm.ptr
llvm.store %0, %30 {alignment = 4 : i64} : i32, !llvm.ptr
llvm.store %2, %31 {alignment = 8 : i64} : i64, !llvm.ptr
llvm.store %13, %32 {alignment = 8 : i64} : !llvm.ptr, !llvm.ptr
%45 = llvm.icmp "eq" %1, %1 : i32
llvm.cond_br %45, ^bb4, ^bb5
^bb4: // pred: ^bb3
llvm.intr.lifetime.start 8, %19 : !llvm.ptr
llvm.intr.lifetime.start 4, %20 : !llvm.ptr
llvm.intr.lifetime.start 4, %21 : !llvm.ptr
llvm.intr.lifetime.start 12, %22 : !llvm.ptr
llvm.intr.lifetime.start 12, %23 : !llvm.ptr
llvm.intr.lifetime.start 8, %24 : !llvm.ptr
llvm.intr.lifetime.start 8, %25 : !llvm.ptr
llvm.intr.lifetime.start 24, %26 : !llvm.ptr
llvm.store %arg0, %19 {alignment = 8 : i64, tbaa = [#llvm.tbaa_tag, 0>}>, 0>}>, 0>}>, access_type = , 0>}>, 0>}>, 0>}>, offset = 0>]} : !llvm.ptr, !llvm.ptr
llvm.store %arg1, %20 {alignment = 4 : i64, tbaa = [#llvm.tbaa_tag, 0>}>, 0>}>, access_type = , 0>}>, 0>}>, offset = 0>]} : i32, !llvm.ptr
llvm.store %arg2, %21 {alignment = 4 : i64, tbaa = [#llvm.tbaa_tag, 0>}>, 0>}>, access_type = , 0>}>, 0>}>, offset = 0>]} : i32, !llvm.ptr
llvm.store %19, %26 {alignment = 8 : i64} : !llvm.ptr, !llvm.ptr
%46 = llvm.getelementptr inbounds|nuw %26[%14] : (!llvm.ptr, i64) -> !llvm.ptr, i8
llvm.store %20, %46 {alignment = 8 : i64} : !llvm.ptr, !llvm.ptr
%47 = llvm.getelementptr inbounds|nuw %26[%15] : (!llvm.ptr, i64) -> !llvm.ptr, i8
llvm.store %21, %47 {alignment = 8 : i64} : !llvm.ptr, !llvm.ptr
%48 = llvm.load %27 {alignment = 8 : i64} : !llvm.ptr -> i64
%49 = llvm.load %28 {alignment = 4 : i64} : !llvm.ptr -> i32
%50 = llvm.load %29 {alignment = 8 : i64} : !llvm.ptr -> i64
%51 = llvm.load %30 {alignment = 4 : i64} : !llvm.ptr -> i32
%52 = llvm.load %31 {alignment = 8 : i64} : !llvm.ptr -> i64
%53 = llvm.load %32 {alignment = 8 : i64} : !llvm.ptr -> !llvm.ptr
%54 = llvm.load %24 {alignment = 8 : i64} : !llvm.ptr -> i64
%55 = llvm.load %25 {alignment = 8 : i64} : !llvm.ptr -> !llvm.ptr
%56 = llvm.load %22 {alignment = 8 : i64} : !llvm.ptr -> i64
%57 = llvm.getelementptr inbounds|nuw %22[%14] : (!llvm.ptr, i64) -> !llvm.ptr, i8
%58 = llvm.load %57 {alignment = 8 : i64} : !llvm.ptr -> i32
%59 = llvm.load %23 {alignment = 8 : i64} : !llvm.ptr -> i64
%60 = llvm.getelementptr inbounds|nuw %23[%14] : (!llvm.ptr, i64) -> !llvm.ptr, i8
%61 = llvm.load %60 {alignment = 8 : i64} : !llvm.ptr -> i32
%62 = llvm.getelementptr inbounds %26[%2] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.ptr
%63 = llvm.load %62 {alignment = 8 : i64} : !llvm.ptr -> !llvm.ptr
%64 = llvm.load %63 {alignment = 8 : i64} : !llvm.ptr -> !llvm.ptr
%65 = llvm.getelementptr inbounds %26[%6] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.ptr
%66 = llvm.load %65 {alignment = 8 : i64} : !llvm.ptr -> !llvm.ptr
%67 = llvm.load %66 {alignment = 4 : i64} : !llvm.ptr -> i32
%68 = llvm.getelementptr inbounds %26[%16] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.ptr
%69 = llvm.load %68 {alignment = 8 : i64} : !llvm.ptr -> !llvm.ptr
%70 = llvm.load %69 {alignment = 4 : i64} : !llvm.ptr -> i32
%71 = llvm.trunc %48 : i64 to i32
%72 = llvm.lshr %48, %17 : i64
%73 = llvm.trunc %72 : i64 to i32
%74 = llvm.trunc %50 : i64 to i32
%75 = llvm.lshr %50, %17 : i64
%76 = llvm.trunc %75 : i64 to i32
llvm.call @__mlir_launch_kernel__Z35__device_stub__negate_forces_kernelP8Particleii(%18, %71, %73, %49, %74, %76, %51, %52, %53, %64, %67, %70) : (!llvm.ptr, i32, i32, i32, i32, i32, i32, i64, !llvm.ptr, !llvm.ptr, i32, i32) -> ()
llvm.intr.lifetime.end 8, %19 : !llvm.ptr
llvm.intr.lifetime.end 4, %20 : !llvm.ptr
llvm.intr.lifetime.end 4, %21 : !llvm.ptr
llvm.intr.lifetime.end 12, %22 : !llvm.ptr
llvm.intr.lifetime.end 12, %23 : !llvm.ptr
llvm.intr.lifetime.end 8, %24 : !llvm.ptr
llvm.intr.lifetime.end 8, %25 : !llvm.ptr
llvm.intr.lifetime.end 24, %26 : !llvm.ptr
llvm.br ^bb5
^bb5: // 2 preds: ^bb3, ^bb4
llvm.return
}
llvm.func local_unnamed_addr @__mlir_launch_kernel__Z35__device_stub__negate_forces_kernelP8Particleii(!llvm.ptr, i32, i32, i32, i32, i32, i32, i64, !llvm.ptr, !llvm.ptr, i32, i32)
llvm.func internal @_Z35__device_stub__negate_forces_kernelP8Particleii(%arg0: !llvm.ptr {llvm.nocapture, llvm.noundef}, %arg1: i32 {llvm.noundef}, %arg2: i32 {llvm.noundef}) attributes {dso_local, frame_pointer = #llvm.framePointerKind, memory_effects = #llvm.memory_effects, no_unwind, passthrough = ["mustprogress", "nofree", "norecurse", "nosync", ["no-trapping-math", "true"], ["stack-protector-buffer-size", "8"], ["target-cpu", "sm_52"], ["uniform-work-group-size", "true"]], target_cpu = "sm_52", target_features = #llvm.target_features<["+ptx80", "+sm_52"]>} {
%0 = llvm.mlir.constant(0 : i32) : i32
%1 = llvm.mlir.constant(2 : i32) : i32
%2 = llvm.mlir.constant(8 : i64) : i64
%3 = llvm.mlir.constant(16 : i64) : i64
%4 = llvm.mlir.constant(1 : i32) : i32
%5 = nvvm.read.ptx.sreg.ctaid.x : i32
%6 = llvm.icmp "slt" %5, %arg2 : i32
llvm.cond_br %6, ^bb1, ^bb3
^bb1: // pred: ^bb0
%7 = llvm.mul %arg1, %5 overflow : i32
%8 = llvm.sext %7 : i32 to i64
%9 = llvm.getelementptr inbounds %arg0[%8] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<"struct.Particle", (struct<"struct.Vec3", (f64, f64, f64)>, struct<"struct.Vec3", (f64, f64, f64)>, struct<"struct.Vec3", (f64, f64, f64)>)>
%10 = llvm.icmp "sgt" %arg1, %0 : i32
llvm.cond_br %10, ^bb2(%0 : i32), ^bb3
^bb2(%11: i32): // 2 preds: ^bb1, ^bb2
%12 = llvm.zext nneg %11 : i32 to i64
%13 = llvm.getelementptr inbounds|nuw %9[%12, 2] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<"struct.Particle", (struct<"struct.Vec3", (f64, f64, f64)>, struct<"struct.Vec3", (f64, f64, f64)>, struct<"struct.Vec3", (f64, f64, f64)>)>
%14 = llvm.load %13 {alignment = 8 : i64, tbaa = [#llvm.tbaa_tag, 0>}>, 0>}>, 0>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 8>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 16>}>, 0>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 0>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 8>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 16>}>, 24>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 0>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 8>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 16>}>, 48>}>, access_type = , 0>}>, 0>}>, offset = 48>]} : !llvm.ptr -> f64
%15 = llvm.fneg %14 {fastmathFlags = #llvm.fastmath} : f64
llvm.store %15, %13 {alignment = 8 : i64, tbaa = [#llvm.tbaa_tag, 0>}>, 0>}>, 0>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 8>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 16>}>, 0>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 0>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 8>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 16>}>, 24>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 0>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 8>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 16>}>, 48>}>, access_type = , 0>}>, 0>}>, offset = 48>]} : f64, !llvm.ptr
%16 = llvm.getelementptr inbounds|nuw %13[%2] : (!llvm.ptr, i64) -> !llvm.ptr, i8
%17 = llvm.load %16 {alignment = 8 : i64, tbaa = [#llvm.tbaa_tag, 0>}>, 0>}>, 0>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 8>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 16>}>, 0>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 0>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 8>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 16>}>, 24>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 0>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 8>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 16>}>, 48>}>, access_type = , 0>}>, 0>}>, offset = 56>]} : !llvm.ptr -> f64
%18 = llvm.fneg %17 {fastmathFlags = #llvm.fastmath} : f64
llvm.store %18, %16 {alignment = 8 : i64, tbaa = [#llvm.tbaa_tag, 0>}>, 0>}>, 0>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 8>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 16>}>, 0>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 0>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 8>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 16>}>, 24>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 0>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 8>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 16>}>, 48>}>, access_type = , 0>}>, 0>}>, offset = 56>]} : f64, !llvm.ptr
%19 = llvm.getelementptr inbounds|nuw %13[%3] : (!llvm.ptr, i64) -> !llvm.ptr, i8
%20 = llvm.load %19 {alignment = 8 : i64, tbaa = [#llvm.tbaa_tag, 0>}>, 0>}>, 0>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 8>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 16>}>, 0>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 0>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 8>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 16>}>, 24>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 0>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 8>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 16>}>, 48>}>, access_type = , 0>}>, 0>}>, offset = 64>]} : !llvm.ptr -> f64
%21 = llvm.fneg %20 {fastmathFlags = #llvm.fastmath} : f64
llvm.store %21, %19 {alignment = 8 : i64, tbaa = [#llvm.tbaa_tag, 0>}>, 0>}>, 0>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 8>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 16>}>, 0>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 0>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 8>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 16>}>, 24>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 0>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 8>, <#llvm.tbaa_type_desc, 0>}>, 0>}>, 16>}>, 48>}>, access_type = , 0>}>, 0>}>, offset = 64>]} : f64, !llvm.ptr
%22 = llvm.add %11, %4 overflow : i32
%23 = llvm.icmp "eq" %22, %arg1 : i32
llvm.cond_br %23, ^bb3, ^bb2(%22 : i32) {loop_annotation = #llvm.loop_annotation, mustProgress = true>}
^bb3: // 3 preds: ^bb0, ^bb1, ^bb2
llvm.return
}
}
passes to run: inline{default-pipeline=canonicalize max-iterations=4},sroa-wrappers{set_private=false},gpu-launch-recognition,canonicalize,libdevice-funcs-raise,canonicalize,parallel-lower{wrapParallelOps=true},llvm-to-memref-access,polygeist-mem2reg,canonicalize,convert-llvm-to-cf,canonicalize,polygeist-mem2reg,canonicalize,enzyme-lift-cf-to-scf,canonicalize,func.func(canonicalize-loops),llvm.func(canonicalize-loops),canonicalize-scf-for,canonicalize,affine-cfg,canonicalize,func.func(canonicalize-loops),llvm.func(canonicalize-loops),canonicalize,llvm-to-affine-access,canonicalize,delinearize-indexing,canonicalize,simplify-affine-exprs,affine-cfg,canonicalize,llvm-to-affine-access,canonicalize,func.func(affine-loop-invariant-code-motion),canonicalize,sort-memory,raise-affine-to-stablehlo{prefer_while_raising=false dump_failed_lockstep=true},canonicalize,arith-raise{stablehlo=true},symbol-dce,lower-affine,parallel-serialization,canonicalize,convert-polygeist-to-llvm{backend=xla-gpu}
src/external/isl/isl_space.c:3350: unexpected unnamed parameters
src/external/isl/isl_space.c:3350: unexpected unnamed parameters
src/external/isl/isl_space.c:3350: unexpected unnamed parameters
src/external/isl/isl_space.c:3350: unexpected unnamed parameters
failed to raise operand: of type 'i32' at index: 1
within %16 = "enzymexla.gpu_wrapper"(%15, %c1, %c1, %c256, %c1, %c1) ({
affine.parallel (%arg4, %arg5) = (0, 0) to (min(symbol(%4), symbol(%15)), 256) {
%17 = arith.index_castui %arg4 : index to i32
%18 = arith.muli %arg1, %17 : i32
%19 = arith.extsi %18 : i32 to i64
%20 = llvm.getelementptr inbounds %arg0[%19] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<"struct.Particle.1", (struct<"struct.Vec3.1", (f64, f64, f64)>, struct<"struct.Vec3.1", (f64, f64, f64)>, struct<"struct.Vec3.1", (f64, f64, f64)>)>
affine.if affine_set<()[s0] : (s0 - 1 >= 0)>()[%3] {
%21 = scf.while (%arg6 = %c1_i32) : (i32) -> i32 {
%22 = arith.addi %arg6, %c-1_i32 : i32
%23 = arith.extui %22 {nonNeg} : i32 to i64
%24 = llvm.getelementptr inbounds|nuw %20[%23, 2] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<"struct.Particle.1", (struct<"struct.Vec3.1", (f64, f64, f64)>, struct<"struct.Vec3.1", (f64, f64, f64)>, struct<"struct.Vec3.1", (f64, f64, f64)>)>
%25 = "enzymexla.pointer2memref"(%24) : (!llvm.ptr) -> memref
%26 = affine.load %25[0] : memref
%27 = arith.negf %26 {fastmathFlags = #llvm.fastmath} : f64
%28 = "enzymexla.pointer2memref"(%24) : (!llvm.ptr) -> memref
affine.store %27, %28[0] : memref
%29 = llvm.getelementptr inbounds|nuw %24[8] : (!llvm.ptr) -> !llvm.ptr, i8
%30 = "enzymexla.pointer2memref"(%29) : (!llvm.ptr) -> memref
%31 = affine.load %30[0] : memref
%32 = arith.negf %31 {fastmathFlags = #llvm.fastmath} : f64
%33 = "enzymexla.pointer2memref"(%29) : (!llvm.ptr) -> memref
affine.store %32, %33[0] : memref
%34 = llvm.getelementptr inbounds|nuw %24[16] : (!llvm.ptr) -> !llvm.ptr, i8
%35 = "enzymexla.pointer2memref"(%34) : (!llvm.ptr) -> memref
%36 = affine.load %35[0] : memref
%37 = arith.negf %36 {fastmathFlags = #llvm.fastmath} : f64
%38 = "enzymexla.pointer2memref"(%34) : (!llvm.ptr) -> memref
affine.store %37, %38[0] : memref
%39 = arith.cmpi ne, %arg6, %arg1 : i32
scf.condition(%39) %arg6 : i32
} do {
^bb0(%arg6: i32):
%22 = arith.addi %arg6, %c1_i32 : i32
scf.yield %22 : i32
}
}
}
"enzymexla.polygeist_yield"() : () -> ()
}) {passthrough = ["mustprogress", "nofree", "norecurse", "nosync", ["no-trapping-math", "true"], ["stack-protector-buffer-size", "8"], ["target-cpu", "sm_52"], ["uniform-work-group-size", "true"]], target_features = #llvm.target_features<["+ptx80", "+sm_52"]>} : (index, index, index, index, index, index) -> index
Pipeline failed:
```