Question on emulated `bfloat16` scalar code on Phoenix

[erwei-xilinx]

Hi team,

I came across an error when trying to compile a bfloat16 scalar code (x := x ^ 2) on Phoenix, compiled through MLIR-AIR and MLIR-AIE:

LLVM ERROR: unable to legalize instruction: %164:_(<2 x s16>) = G_FMUL %163:_, %163:_ (in function: core_0_2)

Please see the input IRs below:

MLIR-AIE:

    %core_0_2 = aie.core(%tile_0_2) {
      %c32 = arith.constant 32 : index
      %c1 = arith.constant 1 : index
      %c0 = arith.constant 0 : index
      cf.br ^bb1
    ^bb1:  // 2 preds: ^bb0, ^bb1
      aie.use_lock(%lock_0_2_3, AcquireGreaterEqual, 1)
      aie.use_lock(%lock_0_2_2, AcquireGreaterEqual, 1)
      scf.for %arg0 = %c0 to %c32 step %c1 {
        scf.for %arg1 = %c0 to %c32 step %c1 {
          %0 = memref.load %buf0[%arg0, %arg1] : memref<32x32xbf16, 2 : i32>
          %1 = arith.mulf %0, %0 : bf16
          memref.store %1, %buf1[%arg0, %arg1] : memref<32x32xbf16, 2 : i32>
        }
      }
      aie.use_lock(%lock_0_2, Release, 1)
      aie.use_lock(%lock_0_2_4, Release, 1)
      cf.br ^bb1
    } {elf_file = "gelu_seg_core_0_2.elf"}

LLVM IR

module attributes {llvm.target_triple = "aie2"} {
  llvm.mlir.global external @buf0() {addr_space = 0 : i32} : !llvm.array<32 x array<32 x bf16>>
  llvm.mlir.global external @buf1() {addr_space = 0 : i32} : !llvm.array<32 x array<32 x bf16>>
  llvm.mlir.global external @buf2() {addr_space = 0 : i32} : !llvm.array<32 x array<32 x bf16>>
  llvm.mlir.global external @buf3() {addr_space = 0 : i32} : !llvm.array<32 x array<32 x bf16>>
  llvm.func @debug_i32(i32) attributes {sym_visibility = "private"}
  llvm.func @llvm.aie2.put.ms(i32, i32) attributes {sym_visibility = "private"}
  llvm.func @llvm.aie2.get.ss() -> !llvm.struct<(i32, i32)> attributes {sym_visibility = "private"}
  llvm.func @llvm.aie2.mcd.write.vec(vector<16xi32>, i32) attributes {sym_visibility = "private"}
  llvm.func @llvm.aie2.scd.read.vec(i32) -> vector<16xi32> attributes {sym_visibility = "private"}
  llvm.func @llvm.aie2.acquire(i32, i32) attributes {sym_visibility = "private"}
  llvm.func @llvm.aie2.release(i32, i32) attributes {sym_visibility = "private"}
  llvm.mlir.global external @air_channel_3() {addr_space = 0 : i32} : !llvm.array<32 x array<32 x bf16>>
  llvm.mlir.global external @air_channel_0() {addr_space = 0 : i32} : !llvm.array<32 x array<32 x bf16>>
  llvm.func @core_0_2() {
    %0 = llvm.mlir.addressof @buf1 : !llvm.ptr
    %1 = llvm.mlir.addressof @buf0 : !llvm.ptr
    %2 = llvm.mlir.constant(48 : i32) : i32
    %3 = llvm.mlir.constant(51 : i32) : i32
    %4 = llvm.mlir.constant(50 : i32) : i32
    %5 = llvm.mlir.constant(49 : i32) : i32
    %6 = llvm.mlir.constant(1 : i32) : i32
    %7 = llvm.mlir.constant(-1 : i32) : i32
    %8 = llvm.mlir.constant(32 : index) : i64
    %9 = llvm.mlir.constant(1 : index) : i64
    %10 = llvm.mlir.constant(0 : index) : i64
    llvm.br ^bb1
  ^bb1:  // 2 preds: ^bb0, ^bb6
    llvm.call @llvm.aie2.acquire(%5, %7) : (i32, i32) -> ()
    llvm.call @llvm.aie2.acquire(%4, %7) : (i32, i32) -> ()
    llvm.br ^bb2(%10 : i64)
  ^bb2(%11: i64):  // 2 preds: ^bb1, ^bb5
    %12 = llvm.icmp "slt" %11, %8 : i64
    llvm.cond_br %12, ^bb3(%10 : i64), ^bb6
  ^bb3(%13: i64):  // 2 preds: ^bb2, ^bb4
    %14 = llvm.icmp "slt" %13, %8 : i64
    llvm.cond_br %14, ^bb4, ^bb5
  ^bb4:  // pred: ^bb3
    %15 = llvm.getelementptr %1[0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<32 x array<32 x bf16>>
    %16 = llvm.mul %11, %8 overflow<nsw, nuw> : i64
    %17 = llvm.add %16, %13 overflow<nsw, nuw> : i64
    %18 = llvm.getelementptr inbounds|nuw %15[%17] : (!llvm.ptr, i64) -> !llvm.ptr, bf16
    %19 = llvm.load %18 : !llvm.ptr -> bf16
    %20 = llvm.fmul %19, %19 : bf16
    %21 = llvm.getelementptr %0[0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<32 x array<32 x bf16>>
    %22 = llvm.getelementptr inbounds|nuw %21[%17] : (!llvm.ptr, i64) -> !llvm.ptr, bf16
    llvm.store %20, %22 : bf16, !llvm.ptr
    %23 = llvm.add %13, %9 : i64
    llvm.br ^bb3(%23 : i64)
  ^bb5:  // pred: ^bb3
    %24 = llvm.add %11, %9 : i64
    llvm.br ^bb2(%24 : i64)
  ^bb6:  // pred: ^bb2
    llvm.call @llvm.aie2.release(%3, %6) : (i32, i32) -> ()
    llvm.call @llvm.aie2.release(%2, %6) : (i32, i32) -> ()
    llvm.br ^bb1
  }
}

Could you please advise on how to get around this issue? Or is there a reason why this code pattern isn't supported?

[erwei-xilinx]

Here is the input IR for llc:

; ModuleID = '/home/erweiw/mlir-air/workspace/debug_gelu/air_project/input.llpeanohack.ll'
source_filename = "LLVMDialectModule"
target datalayout = "e-m:e-p:20:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-f32:32:32-i64:32-f64:32-a:0:32-n32"
target triple = "aie2"

@buf0 = external local_unnamed_addr global [32 x [32 x float]]
@buf1 = external local_unnamed_addr global [32 x [32 x float]]

; Function Attrs: nounwind
declare void @llvm.aie2.acquire(i32, i32) #0

; Function Attrs: nounwind
declare void @llvm.aie2.release(i32, i32) #0

; Function Attrs: noreturn nounwind
define void @core_0_2() local_unnamed_addr #1 {
  br label %1

1:                                                ; preds = %137, %0
  tail call void @llvm.aie2.acquire(i32 49, i32 -1)
  tail call void @llvm.aie2.acquire(i32 50, i32 -1)
  br label %.preheader

.preheader:                                       ; preds = %134, %1
  %2 = phi i64 [ 0, %1 ], [ %135, %134 ]
  %3 = shl nuw nsw i64 %2, 5
  br label %4

4:                                                ; preds = %4, %.preheader
  %5 = phi i64 [ 0, %.preheader ], [ %33, %4 ]
  %6 = add nuw nsw i64 %5, %3
  %7 = trunc i64 %6 to i20
  %8 = getelementptr inbounds float, ptr @buf0, i20 %7
  %9 = load float, ptr %8, align 4
  %10 = fmul float %9, %9
  %11 = getelementptr inbounds float, ptr @buf1, i20 %7
  store float %10, ptr %11, align 4
  %12 = or disjoint i64 %5, 1
  %13 = add nuw nsw i64 %12, %3
  %14 = trunc i64 %13 to i20
  %15 = getelementptr inbounds float, ptr @buf0, i20 %14
  %16 = load float, ptr %15, align 4
  %17 = fmul float %16, %16
  %18 = getelementptr inbounds float, ptr @buf1, i20 %14
  store float %17, ptr %18, align 4
  %19 = or disjoint i64 %5, 2
  %20 = add nuw nsw i64 %19, %3
  %21 = trunc i64 %20 to i20
  %22 = getelementptr inbounds float, ptr @buf0, i20 %21
  %23 = load float, ptr %22, align 4
  %24 = fmul float %23, %23
  %25 = getelementptr inbounds float, ptr @buf1, i20 %21
  store float %24, ptr %25, align 4
  %26 = or disjoint i64 %5, 3
  %27 = add nuw nsw i64 %26, %3
  %28 = trunc i64 %27 to i20
  %29 = getelementptr inbounds float, ptr @buf0, i20 %28
  %30 = load float, ptr %29, align 4
  %31 = fmul float %30, %30
  %32 = getelementptr inbounds float, ptr @buf1, i20 %28
  store float %31, ptr %32, align 4
  %33 = add nuw nsw i64 %5, 4
  %34 = icmp ult i64 %26, 31
  br i1 %34, label %4, label %.preheader.1

.preheader.1:                                     ; preds = %4
  %35 = shl i64 %2, 5
  %36 = or disjoint i64 %35, 32
  br label %37

37:                                               ; preds = %37, %.preheader.1
  %38 = phi i64 [ 0, %.preheader.1 ], [ %66, %37 ]
  %39 = add nuw nsw i64 %38, %36
  %40 = trunc i64 %39 to i20
  %41 = getelementptr inbounds float, ptr @buf0, i20 %40
  %42 = load float, ptr %41, align 4
  %43 = fmul float %42, %42
  %44 = getelementptr inbounds float, ptr @buf1, i20 %40
  store float %43, ptr %44, align 4
  %45 = or disjoint i64 %38, 1
  %46 = add nuw nsw i64 %45, %36
  %47 = trunc i64 %46 to i20
  %48 = getelementptr inbounds float, ptr @buf0, i20 %47
  %49 = load float, ptr %48, align 4
  %50 = fmul float %49, %49
  %51 = getelementptr inbounds float, ptr @buf1, i20 %47
  store float %50, ptr %51, align 4
  %52 = or disjoint i64 %38, 2
  %53 = add nuw nsw i64 %52, %36
  %54 = trunc i64 %53 to i20
  %55 = getelementptr inbounds float, ptr @buf0, i20 %54
  %56 = load float, ptr %55, align 4
  %57 = fmul float %56, %56
  %58 = getelementptr inbounds float, ptr @buf1, i20 %54
  store float %57, ptr %58, align 4
  %59 = or disjoint i64 %38, 3
  %60 = add nuw nsw i64 %59, %36
  %61 = trunc i64 %60 to i20
  %62 = getelementptr inbounds float, ptr @buf0, i20 %61
  %63 = load float, ptr %62, align 4
  %64 = fmul float %63, %63
  %65 = getelementptr inbounds float, ptr @buf1, i20 %61
  store float %64, ptr %65, align 4
  %66 = add nuw nsw i64 %38, 4
  %67 = icmp ult i64 %59, 31
  br i1 %67, label %37, label %.preheader.2

.preheader.2:                                     ; preds = %37
  %68 = shl i64 %2, 5
  %69 = or disjoint i64 %68, 64
  br label %70

70:                                               ; preds = %70, %.preheader.2
  %71 = phi i64 [ 0, %.preheader.2 ], [ %99, %70 ]
  %72 = add nuw nsw i64 %71, %69
  %73 = trunc i64 %72 to i20
  %74 = getelementptr inbounds float, ptr @buf0, i20 %73
  %75 = load float, ptr %74, align 4
  %76 = fmul float %75, %75
  %77 = getelementptr inbounds float, ptr @buf1, i20 %73
  store float %76, ptr %77, align 4
  %78 = or disjoint i64 %71, 1
  %79 = add nuw nsw i64 %78, %69
  %80 = trunc i64 %79 to i20
  %81 = getelementptr inbounds float, ptr @buf0, i20 %80
  %82 = load float, ptr %81, align 4
  %83 = fmul float %82, %82
  %84 = getelementptr inbounds float, ptr @buf1, i20 %80
  store float %83, ptr %84, align 4
  %85 = or disjoint i64 %71, 2
  %86 = add nuw nsw i64 %85, %69
  %87 = trunc i64 %86 to i20
  %88 = getelementptr inbounds float, ptr @buf0, i20 %87
  %89 = load float, ptr %88, align 4
  %90 = fmul float %89, %89
  %91 = getelementptr inbounds float, ptr @buf1, i20 %87
  store float %90, ptr %91, align 4
  %92 = or disjoint i64 %71, 3
  %93 = add nuw nsw i64 %92, %69
  %94 = trunc i64 %93 to i20
  %95 = getelementptr inbounds float, ptr @buf0, i20 %94
  %96 = load float, ptr %95, align 4
  %97 = fmul float %96, %96
  %98 = getelementptr inbounds float, ptr @buf1, i20 %94
  store float %97, ptr %98, align 4
  %99 = add nuw nsw i64 %71, 4
  %100 = icmp ult i64 %92, 31
  br i1 %100, label %70, label %.preheader.3

.preheader.3:                                     ; preds = %70
  %101 = or disjoint i64 %2, 3
  %102 = shl nuw nsw i64 %101, 5
  br label %103

103:                                              ; preds = %103, %.preheader.3
  %104 = phi i64 [ 0, %.preheader.3 ], [ %132, %103 ]
  %105 = add nuw nsw i64 %104, %102
  %106 = trunc i64 %105 to i20
  %107 = getelementptr inbounds float, ptr @buf0, i20 %106
  %108 = load float, ptr %107, align 4
  %109 = fmul float %108, %108
  %110 = getelementptr inbounds float, ptr @buf1, i20 %106
  store float %109, ptr %110, align 4
  %111 = or disjoint i64 %104, 1
  %112 = add nuw nsw i64 %111, %102
  %113 = trunc i64 %112 to i20
  %114 = getelementptr inbounds float, ptr @buf0, i20 %113
  %115 = load float, ptr %114, align 4
  %116 = fmul float %115, %115
  %117 = getelementptr inbounds float, ptr @buf1, i20 %113
  store float %116, ptr %117, align 4
  %118 = or disjoint i64 %104, 2
  %119 = add nuw nsw i64 %118, %102
  %120 = trunc i64 %119 to i20
  %121 = getelementptr inbounds float, ptr @buf0, i20 %120
  %122 = load float, ptr %121, align 4
  %123 = fmul float %122, %122
  %124 = getelementptr inbounds float, ptr @buf1, i20 %120
  store float %123, ptr %124, align 4
  %125 = or disjoint i64 %104, 3
  %126 = add nuw nsw i64 %125, %102
  %127 = trunc i64 %126 to i20
  %128 = getelementptr inbounds float, ptr @buf0, i20 %127
  %129 = load float, ptr %128, align 4
  %130 = fmul float %129, %129
  %131 = getelementptr inbounds float, ptr @buf1, i20 %127
  store float %130, ptr %131, align 4
  %132 = add nuw nsw i64 %104, 4
  %133 = icmp ult i64 %125, 31
  br i1 %133, label %103, label %134

134:                                              ; preds = %103
  %135 = add nuw nsw i64 %2, 4
  %136 = icmp ult i64 %101, 31
  br i1 %136, label %.preheader, label %137

137:                                              ; preds = %134
  tail call void @llvm.aie2.release(i32 51, i32 1)
  tail call void @llvm.aie2.release(i32 48, i32 1)
  br label %1
}

attributes #0 = { nounwind }
attributes #1 = { noreturn nounwind }

!llvm.module.flags = !{!0}

!0 = !{i32 2, !"Debug Info Version", i32 3}

[konstantinschwarz]

Hi @erwei-xilinx, I tried compiling the provided LLVM IR with llc -O2 -o - crash.ll, and it compiled successfully.
I also don't see any fmul with vector types in IR. It looks like this is operating on float, not bfloat16.
Are you sure this is the IR that is given to Peano?

[erwei-xilinx]

Apologies--the llvm ir I posted was indeed the wrong one. I was testing it with float32 in August, and indeed the design works with float32. I forgot about that.

Below is the bfloat16 version:

; ModuleID = '/home/erweiw/mlir-air/workspace/debug_gelu/air_project/input.llpeanohack.ll'
source_filename = "LLVMDialectModule"
target datalayout = "e-m:e-p:20:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-f32:32:32-i64:32-f64:32-a:0:32-n32"
target triple = "aie2"

@buf0 = external local_unnamed_addr global [32 x [32 x bfloat]]
@buf1 = external local_unnamed_addr global [32 x [32 x bfloat]]

; Function Attrs: nounwind
declare void @llvm.aie2.acquire(i32, i32) #0

; Function Attrs: nounwind
declare void @llvm.aie2.release(i32, i32) #0

; Function Attrs: noreturn nounwind
define void @core_0_2() local_unnamed_addr #1 {
  br label %1

1:                                                ; preds = %85, %0
  tail call void @llvm.aie2.acquire(i32 49, i32 -1)
  tail call void @llvm.aie2.acquire(i32 50, i32 -1)
  br label %.preheader

.preheader:                                       ; preds = %1, %.preheader
  %2 = phi i64 [ 0, %1 ], [ %83, %.preheader ]
  %3 = shl nuw nsw i64 %2, 5
  %4 = trunc i64 %3 to i20
  %5 = getelementptr inbounds bfloat, ptr @buf0, i20 %4
  %wide.load = load <2 x bfloat>, ptr %5, align 2
  %6 = fmul <2 x bfloat> %wide.load, %wide.load
  %7 = getelementptr inbounds bfloat, ptr @buf1, i20 %4
  store <2 x bfloat> %6, ptr %7, align 2
  %8 = trunc i64 %3 to i20
  %9 = or disjoint i20 %8, 2
  %10 = getelementptr inbounds bfloat, ptr @buf0, i20 %9
  %wide.load.1 = load <2 x bfloat>, ptr %10, align 2
  %11 = fmul <2 x bfloat> %wide.load.1, %wide.load.1
  %12 = getelementptr inbounds bfloat, ptr @buf1, i20 %9
  store <2 x bfloat> %11, ptr %12, align 2
  %13 = trunc i64 %3 to i20
  %14 = or disjoint i20 %13, 4
  %15 = getelementptr inbounds bfloat, ptr @buf0, i20 %14
  %wide.load.2 = load <2 x bfloat>, ptr %15, align 2
  %16 = fmul <2 x bfloat> %wide.load.2, %wide.load.2
  %17 = getelementptr inbounds bfloat, ptr @buf1, i20 %14
  store <2 x bfloat> %16, ptr %17, align 2
  %18 = trunc i64 %3 to i20
  %19 = or disjoint i20 %18, 6
  %20 = getelementptr inbounds bfloat, ptr @buf0, i20 %19
  %wide.load.3 = load <2 x bfloat>, ptr %20, align 2
  %21 = fmul <2 x bfloat> %wide.load.3, %wide.load.3
  %22 = getelementptr inbounds bfloat, ptr @buf1, i20 %19
  store <2 x bfloat> %21, ptr %22, align 2
  %23 = trunc i64 %3 to i20
  %24 = or disjoint i20 %23, 8
  %25 = getelementptr inbounds bfloat, ptr @buf0, i20 %24
  %wide.load.4 = load <2 x bfloat>, ptr %25, align 2
  %26 = fmul <2 x bfloat> %wide.load.4, %wide.load.4
  %27 = getelementptr inbounds bfloat, ptr @buf1, i20 %24
  store <2 x bfloat> %26, ptr %27, align 2
  %28 = trunc i64 %3 to i20
  %29 = or disjoint i20 %28, 10
  %30 = getelementptr inbounds bfloat, ptr @buf0, i20 %29
  %wide.load.5 = load <2 x bfloat>, ptr %30, align 2
  %31 = fmul <2 x bfloat> %wide.load.5, %wide.load.5
  %32 = getelementptr inbounds bfloat, ptr @buf1, i20 %29
  store <2 x bfloat> %31, ptr %32, align 2
  %33 = trunc i64 %3 to i20
  %34 = or disjoint i20 %33, 12
  %35 = getelementptr inbounds bfloat, ptr @buf0, i20 %34
  %wide.load.6 = load <2 x bfloat>, ptr %35, align 2
  %36 = fmul <2 x bfloat> %wide.load.6, %wide.load.6
  %37 = getelementptr inbounds bfloat, ptr @buf1, i20 %34
  store <2 x bfloat> %36, ptr %37, align 2
  %38 = trunc i64 %3 to i20
  %39 = or disjoint i20 %38, 14
  %40 = getelementptr inbounds bfloat, ptr @buf0, i20 %39
  %wide.load.7 = load <2 x bfloat>, ptr %40, align 2
  %41 = fmul <2 x bfloat> %wide.load.7, %wide.load.7
  %42 = getelementptr inbounds bfloat, ptr @buf1, i20 %39
  store <2 x bfloat> %41, ptr %42, align 2
  %43 = trunc i64 %3 to i20
  %44 = or disjoint i20 %43, 16
  %45 = getelementptr inbounds bfloat, ptr @buf0, i20 %44
  %wide.load.8 = load <2 x bfloat>, ptr %45, align 2
  %46 = fmul <2 x bfloat> %wide.load.8, %wide.load.8
  %47 = getelementptr inbounds bfloat, ptr @buf1, i20 %44
  store <2 x bfloat> %46, ptr %47, align 2
  %48 = trunc i64 %3 to i20
  %49 = or disjoint i20 %48, 18
  %50 = getelementptr inbounds bfloat, ptr @buf0, i20 %49
  %wide.load.9 = load <2 x bfloat>, ptr %50, align 2
  %51 = fmul <2 x bfloat> %wide.load.9, %wide.load.9
  %52 = getelementptr inbounds bfloat, ptr @buf1, i20 %49
  store <2 x bfloat> %51, ptr %52, align 2
  %53 = trunc i64 %3 to i20
  %54 = or disjoint i20 %53, 20
  %55 = getelementptr inbounds bfloat, ptr @buf0, i20 %54
  %wide.load.10 = load <2 x bfloat>, ptr %55, align 2
  %56 = fmul <2 x bfloat> %wide.load.10, %wide.load.10
  %57 = getelementptr inbounds bfloat, ptr @buf1, i20 %54
  store <2 x bfloat> %56, ptr %57, align 2
  %58 = trunc i64 %3 to i20
  %59 = or disjoint i20 %58, 22
  %60 = getelementptr inbounds bfloat, ptr @buf0, i20 %59
  %wide.load.11 = load <2 x bfloat>, ptr %60, align 2
  %61 = fmul <2 x bfloat> %wide.load.11, %wide.load.11
  %62 = getelementptr inbounds bfloat, ptr @buf1, i20 %59
  store <2 x bfloat> %61, ptr %62, align 2
  %63 = trunc i64 %3 to i20
  %64 = or disjoint i20 %63, 24
  %65 = getelementptr inbounds bfloat, ptr @buf0, i20 %64
  %wide.load.12 = load <2 x bfloat>, ptr %65, align 2
  %66 = fmul <2 x bfloat> %wide.load.12, %wide.load.12
  %67 = getelementptr inbounds bfloat, ptr @buf1, i20 %64
  store <2 x bfloat> %66, ptr %67, align 2
  %68 = trunc i64 %3 to i20
  %69 = or disjoint i20 %68, 26
  %70 = getelementptr inbounds bfloat, ptr @buf0, i20 %69
  %wide.load.13 = load <2 x bfloat>, ptr %70, align 2
  %71 = fmul <2 x bfloat> %wide.load.13, %wide.load.13
  %72 = getelementptr inbounds bfloat, ptr @buf1, i20 %69
  store <2 x bfloat> %71, ptr %72, align 2
  %73 = trunc i64 %3 to i20
  %74 = or disjoint i20 %73, 28
  %75 = getelementptr inbounds bfloat, ptr @buf0, i20 %74
  %wide.load.14 = load <2 x bfloat>, ptr %75, align 2
  %76 = fmul <2 x bfloat> %wide.load.14, %wide.load.14
  %77 = getelementptr inbounds bfloat, ptr @buf1, i20 %74
  store <2 x bfloat> %76, ptr %77, align 2
  %78 = trunc i64 %3 to i20
  %79 = or disjoint i20 %78, 30
  %80 = getelementptr inbounds bfloat, ptr @buf0, i20 %79
  %wide.load.15 = load <2 x bfloat>, ptr %80, align 2
  %81 = fmul <2 x bfloat> %wide.load.15, %wide.load.15
  %82 = getelementptr inbounds bfloat, ptr @buf1, i20 %79
  store <2 x bfloat> %81, ptr %82, align 2
  %83 = add nuw nsw i64 %2, 1
  %84 = icmp ult i64 %2, 31
  br i1 %84, label %.preheader, label %85

85:                                               ; preds = %.preheader
  tail call void @llvm.aie2.release(i32 51, i32 1)
  tail call void @llvm.aie2.release(i32 48, i32 1)
  br label %1
}

attributes #0 = { nounwind }
attributes #1 = { noreturn nounwind }

!llvm.module.flags = !{!0}

!0 = !{i32 2, !"Debug Info Version", i32 3}