./bin/opt crash.ir -coro-early -coro-split -coro-elide -S

coro-crash.ir

target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"

; Function Attrs: nounwind
define internal i8* @coroutine_begin(i8* %0, i32 %1, i32 %2, i32 %3, i8* %4, i32 %5, i32 %6) #0 {
function:
  %7 = alloca i8*, align 8
  %8 = alloca i32, align 4
  %9 = alloca <4 x i32>, align 16
  %promise = alloca i32, align 4
  %10 = bitcast i32* %promise to i8*
  %11 = call token @llvm.coro.id(i32 0, i8* %10, i8* null, i8* null)
  %12 = call i32 @llvm.coro.size.i32()
  %13 = call i8* @coroutine_alloc_frame(i32 %12)
  %14 = call i8* @llvm.coro.begin(token %11, i8* %13)
  %15 = alloca <4 x float>, i64 3, align 16
  %16 = alloca <4 x i32>, align 16
  %17 = alloca <4 x i32>, align 16
  %18 = alloca <4 x i32>, align 16
  %19 = alloca <4 x i32>, align 16
  %20 = alloca <4 x i32>, align 16
  %21 = alloca <4 x i32>, align 16
  %22 = alloca <4 x i32>, align 16
  %23 = alloca <4 x i32>, align 16
  %24 = alloca <4 x i32>, align 16
  %25 = alloca <4 x i32>, align 16
  %26 = alloca <4 x i32>, align 16
  %27 = alloca <4 x i32>, align 16
  %28 = alloca <4 x float>, align 16
  %29 = alloca i32, align 4
  %30 = alloca i32, align 4
  %31 = alloca <4 x float>, align 16
  %32 = alloca <4 x float>, align 16
  %33 = alloca <4 x float>, align 16
  %34 = alloca <4 x float>, align 16
  %35 = alloca i32, align 4
  %36 = alloca <4 x float>, i64 128, align 16
  %37 = alloca <4 x i32>, align 16
  %38 = alloca i32, align 4
  %39 = alloca i32, align 4
  %40 = alloca <4 x float>, i64 128, align 16
  %41 = alloca <4 x i32>, align 16
  %42 = alloca i8*, align 8
  %43 = alloca <4 x i32>, align 16
  %44 = alloca i8**, align 8
  %45 = alloca <4 x i32>, align 16
  %46 = alloca i32, align 4
  %47 = alloca i32, align 4
  %48 = alloca i32, align 4
  %49 = alloca i8*, align 8
  %50 = alloca <4 x float>, align 16
  %51 = alloca i8*, align 8
  %52 = alloca <4 x float>, align 16
  %53 = alloca i32, align 4
  %54 = alloca i8*, align 8
  %55 = alloca <4 x float>, align 16
  %56 = alloca i32, align 4
  %57 = alloca <4 x i32>, align 16
  %58 = alloca <4 x i32>, align 16
  %59 = alloca <4 x i32>, align 16
  %60 = alloca i8*, align 8
  %61 = alloca <4 x i32>, align 16
  %62 = alloca i32, align 4
  %63 = alloca i32*, align 8
  %64 = alloca i8*, align 8
  %65 = alloca <4 x i32>, align 16
  %66 = alloca i32, align 4
  %67 = alloca <4 x i32>, align 16
  %68 = alloca <4 x i32>, align 16
  %69 = alloca i32, align 4
  %70 = alloca i32, align 4
  %71 = alloca i32, align 4
  %72 = alloca i32, align 4
  %73 = getelementptr i8, i8* %0, i64 0
  %74 = bitcast i8* %73 to i8**
  %75 = getelementptr i8, i8* %0, i64 32
  %76 = bitcast i8* %75 to i32*
  %77 = getelementptr i8, i8* %0, i64 124
  %78 = getelementptr i8, i8* %0, i64 256
  %79 = bitcast i8* %78 to i8**
  %80 = load i8*, i8** %79, align 1
  %81 = getelementptr i8, i8* %0, i64 120
  %82 = bitcast i8* %81 to i32*
  %83 = load i32, i32* %82, align 1
  %84 = getelementptr i8, i8* %0, i64 80
  %85 = bitcast i8* %84 to <4 x i32>*
  %86 = load <4 x i32>, <4 x i32>* %85, align 1
  %87 = insertelement <4 x i32> zeroinitializer, i32 %1, i32 0
  %88 = insertelement <4 x i32> %87, i32 %2, i32 1
  %89 = insertelement <4 x i32> %88, i32 %3, i32 2
  %90 = getelementptr i8, i8* %0, i64 96
  %91 = bitcast i8* %90 to <4 x i32>*
  %92 = load <4 x i32>, <4 x i32>* %91, align 1
  %93 = getelementptr i8, i8* %0, i64 116
  %94 = bitcast i8* %93 to i32*
  %95 = load i32, i32* %94, align 1
  %96 = getelementptr i8, i8* %0, i64 112
  %97 = bitcast i8* %96 to i32*
  %98 = load i32, i32* %97, align 1
  store i32 %2, i32* %72, align 4
  store i32 %3, i32* %71, align 4
  store i32 %2, i32* %70, align 4
  store i32 %1, i32* %69, align 4
  store i32 %5, i32* %66, align 4
  store i32* %76, i32** %63, align 8
  store i8* %0, i8** %60, align 8
  store <4 x i32> %92, <4 x i32>* %59, align 16
  store <4 x i32> %89, <4 x i32>* %57, align 16
  store i32 0, i32* %56, align 4
  store i8* %80, i8** %54, align 8
  store i32 %6, i32* %53, align 4
  store i8* %77, i8** %51, align 8
  store i8* %4, i8** %49, align 8
  store i32 %98, i32* %47, align 4
  store i32 %1, i32* %46, align 4
  store i8** %74, i8*** %44, align 8
  store i8* %4, i8** %42, align 8
  store i32 %95, i32* %38, align 4
  store i32 %83, i32* %35, align 4
  store i32 0, i32* %30, align 4
  store i32 %3, i32* %29, align 4
  store <4 x i32> %86, <4 x i32>* %25, align 16
  br label %99

99:                                               ; preds = %resume, %function
  %100 = load i32, i32* %53, align 4
  %101 = load i32, i32* %30, align 4
  %102 = icmp slt i32 %101, %100
  br i1 %102, label %103, label %187

103:                                              ; preds = %99
  %104 = load i32, i32* %30, align 4
  %105 = load i32, i32* %66, align 4
  %106 = add i32 %105, %104
  %107 = mul i32 %106, 4
  %108 = load <4 x i32>, <4 x i32>* %24, align 16
  %109 = insertelement <4 x i32> %108, i32 %107, i32 0
  %110 = shufflevector <4 x i32> %109, <4 x i32> %109, <4 x i32> zeroinitializer
  store <4 x i32> %110, <4 x i32>* %24, align 16
  %111 = load <4 x i32>, <4 x i32>* %24, align 16
  %112 = add <4 x i32> %111, <i32 0, i32 1, i32 2, i32 3>
  %113 = load i32, i32* %35, align 4
  %114 = load <4 x i32>, <4 x i32>* %23, align 16
  %115 = insertelement <4 x i32> %114, i32 %113, i32 0
  %116 = shufflevector <4 x i32> %115, <4 x i32> %115, <4 x i32> zeroinitializer
  store <4 x i32> %116, <4 x i32>* %23, align 16
  %117 = load <4 x i32>, <4 x i32>* %23, align 16
  %118 = icmp slt <4 x i32> %112, %117
  %119 = sext <4 x i1> %118 to <4 x i32>
  %120 = load i8*, i8** %60, align 8
  %121 = getelementptr i8, i8* %120, i64 80
  %122 = bitcast i8* %121 to <4 x i32>*
  %123 = load <4 x i32>, <4 x i32>* %122, align 1
  %124 = getelementptr i8, i8* %120, i64 96
  %125 = bitcast i8* %124 to <4 x i32>*
  %126 = load <4 x i32>, <4 x i32>* %125, align 1
  %127 = extractelement <4 x i32> %126, i32 0
  %128 = extractelement <4 x i32> %126, i32 1
  %129 = mul i32 %127, %128
  %130 = load <4 x i32>, <4 x i32>* %22, align 16
  %131 = insertelement <4 x i32> %130, i32 %129, i32 0
  %132 = shufflevector <4 x i32> %131, <4 x i32> %131, <4 x i32> zeroinitializer
  store <4 x i32> %132, <4 x i32>* %22, align 16
  %133 = load <4 x i32>, <4 x i32>* %22, align 16
  %134 = sdiv <4 x i32> %112, %133
  %135 = mul i32 %127, %128
  %136 = load <4 x i32>, <4 x i32>* %21, align 16
  %137 = insertelement <4 x i32> %136, i32 %135, i32 0
  %138 = shufflevector <4 x i32> %137, <4 x i32> %137, <4 x i32> zeroinitializer
  store <4 x i32> %138, <4 x i32>* %21, align 16
  %139 = load <4 x i32>, <4 x i32>* %21, align 16
  %140 = mul <4 x i32> %134, %139
  %141 = sub <4 x i32> %112, %140
  %142 = load <4 x i32>, <4 x i32>* %20, align 16
  %143 = insertelement <4 x i32> %142, i32 %127, i32 0
  %144 = shufflevector <4 x i32> %143, <4 x i32> %143, <4 x i32> zeroinitializer
  store <4 x i32> %144, <4 x i32>* %20, align 16
  %145 = load <4 x i32>, <4 x i32>* %20, align 16
  %146 = sdiv <4 x i32> %141, %145
  %147 = load <4 x i32>, <4 x i32>* %19, align 16
  %148 = insertelement <4 x i32> %147, i32 %127, i32 0
  %149 = shufflevector <4 x i32> %148, <4 x i32> %148, <4 x i32> zeroinitializer
  store <4 x i32> %149, <4 x i32>* %19, align 16
  %150 = load <4 x i32>, <4 x i32>* %19, align 16
  %151 = mul <4 x i32> %146, %150
  %152 = sub <4 x i32> %141, %151
  %153 = load i32, i32* %29, align 4
  %154 = load i32, i32* %72, align 4
  %155 = load i32, i32* %46, align 4
  %156 = insertelement <4 x i32> zeroinitializer, i32 %155, i32 0
  %157 = insertelement <4 x i32> %156, i32 %154, i32 1
  %158 = insertelement <4 x i32> %157, i32 %153, i32 2
  %159 = mul <4 x i32> %126, %158
  %160 = extractelement <4 x i32> %159, i32 0
  %161 = load <4 x i32>, <4 x i32>* %18, align 16
  %162 = insertelement <4 x i32> %161, i32 %160, i32 0
  %163 = shufflevector <4 x i32> %162, <4 x i32> %162, <4 x i32> zeroinitializer
  store <4 x i32> %163, <4 x i32>* %18, align 16
  %164 = load <4 x i32>, <4 x i32>* %18, align 16
  %165 = add <4 x i32> %164, %152
  %166 = extractelement <4 x i32> %159, i32 1
  %167 = load <4 x i32>, <4 x i32>* %17, align 16
  %168 = insertelement <4 x i32> %167, i32 %166, i32 0
  %169 = shufflevector <4 x i32> %168, <4 x i32> %168, <4 x i32> zeroinitializer
  store <4 x i32> %169, <4 x i32>* %17, align 16
  %170 = load <4 x i32>, <4 x i32>* %17, align 16
  %171 = add <4 x i32> %170, %146
  %172 = extractelement <4 x i32> %159, i32 2
  %173 = load <4 x i32>, <4 x i32>* %16, align 16
  %174 = insertelement <4 x i32> %173, i32 %172, i32 0
  %175 = shufflevector <4 x i32> %174, <4 x i32> %174, <4 x i32> zeroinitializer
  store <4 x i32> %175, <4 x i32>* %16, align 16
  %176 = load <4 x i32>, <4 x i32>* %16, align 16
  %177 = add <4 x i32> %176, %134
  store <4 x i32> %112, <4 x i32>* %27, align 16
  store i32 %106, i32* %62, align 4
  store <4 x i32> %152, <4 x i32>* %67, align 16
  store <4 x i32> %146, <4 x i32>* %68, align 16
  store <4 x i32> %134, <4 x i32>* %37, align 16
  store <4 x i32> %165, <4 x i32>* %41, align 16
  store <4 x i32> %171, <4 x i32>* %43, align 16
  store <4 x i32> %177, <4 x i32>* %45, align 16
  %178 = bitcast <4 x i32> %165 to <4 x float>
  %179 = getelementptr <4 x float>, <4 x float>* %15, i64 0
  store <4 x float> %178, <4 x float>* %179, align 1
  %180 = bitcast <4 x i32> %171 to <4 x float>
  %181 = getelementptr <4 x float>, <4 x float>* %15, i64 1
  store <4 x float> %180, <4 x float>* %181, align 1
  %182 = bitcast <4 x i32> %177 to <4 x float>
  %183 = getelementptr <4 x float>, <4 x float>* %15, i64 2
  store <4 x float> %182, <4 x float>* %183, align 1
  %184 = getelementptr <4 x float>, <4 x float>* %15, i64 0
  %185 = bitcast <4 x float>* %184 to i8*
  fence acq_rel
  store <4 x i32> zeroinitializer, <4 x i32>* %9, align 16
  store i32 0, i32* %8, align 4
  store i8* %185, i8** %7, align 8
  store i32 0, i32* %promise, align 4
  %186 = call i8 @llvm.coro.suspend(token none, i1 false)
  switch i8 %186, label %suspend [
    i8 0, label %resume
    i8 1, label %destroy
  ]

187:                                              ; preds = %99
  br label %end

suspend:                                          ; preds = %103, %destroy, %end
  %188 = call i1 @llvm.coro.end(i8* %14, i1 false)
  ret i8* %14

end:                                              ; preds = %187
  %189 = call i8 @llvm.coro.suspend(token none, i1 true)
  switch i8 %189, label %suspend [
    i8 1, label %destroy
  ]

destroy:                                          ; preds = %103, %end
  %190 = call i8* @llvm.coro.free(token %11, i8* %14)
  call void @coroutine_free_frame(i8* %190)
  br label %suspend

resume:                                           ; preds = %103
  %191 = load i32, i32* %30, align 4
  %192 = add i32 %191, 1
  store i32 %192, i32* %30, align 4
  br label %99
}

; Function Attrs: nounwind
define internal i1 @coroutine_await(i8* %0, i32* %1) #0 {
co_await:
  %done1 = call i1 @llvm.coro.done(i8* %0)
  br i1 %done1, label %done, label %resume

done:                                             ; preds = %co_await
  ret i1 false

resume:                                           ; preds = %co_await
  %2 = call i8* @llvm.coro.promise(i8* %0, i32 4, i1 false)
  %3 = bitcast i8* %2 to i32*
  %4 = load i32, i32* %3, align 4
  store i32 %4, i32* %1, align 4
  call void @llvm.coro.resume(i8* %0)
  ret i1 true
}

; Function Attrs: nounwind
define internal void @coroutine_destroy(i8* %0) #0 {
  call void @llvm.coro.destroy(i8* %0)
  ret void
}

; Function Attrs: argmemonly nounwind readonly
declare token @llvm.coro.id(i32, i8* readnone, i8* nocapture readonly, i8*) #1

; Function Attrs: nounwind readnone
declare i32 @llvm.coro.size.i32() #2

; Function Attrs: nounwind
declare i8* @llvm.coro.begin(token, i8* writeonly) #0

declare void @llvm.coro.resume(i8*)

; Function Attrs: nounwind
declare i1 @llvm.coro.end(i8*, i1) #0

; Function Attrs: argmemonly nounwind readonly
declare i8* @llvm.coro.free(token, i8* nocapture readonly) #1

declare void @llvm.coro.destroy(i8*)

; Function Attrs: nounwind readnone
declare i8* @llvm.coro.promise(i8* nocapture, i32, i1) #2

; Function Attrs: argmemonly nounwind
declare i1 @llvm.coro.done(i8* nocapture readonly) #3

; Function Attrs: nounwind
declare i8 @llvm.coro.suspend(token, i1) #0

declare i8* @coroutine_alloc_frame(i32)

declare void @coroutine_free_frame(i8*)

attributes #0 = { nounwind }
attributes #1 = { argmemonly nounwind readonly }
attributes #2 = { nounwind readnone }
attributes #3 = { argmemonly nounwind }