test/Transforms/Coroutines/coro-async-dyn-align.ll

; RUN: opt < %s  -O0 -S | FileCheck  %s

target datalayout = "p:64:64:64"

%async.task = type { i64 }
%async.actor = type { i64 }
%async.fp = type <{ i32, i32 }>

%async.ctxt = type { i8*, void (i8*)* }

@my_other_async_function_fp = external global <{ i32, i32 }>
declare void @my_other_async_function(i8* %async.ctxt)

@my_async_function_fp = constant <{ i32, i32 }>
  <{ i32 trunc (
       i64 sub (
         i64 ptrtoint (void (i8*)* @my_async_function to i64),
         i64 ptrtoint (i32* getelementptr inbounds (<{ i32, i32 }>, <{ i32, i32 }>* @my_async_function_fp, i32 0, i32 1) to i64)
       )
     to i32),
     i32 32
}>

declare void @opaque(i64*)
declare i8* @llvm.coro.async.context.alloc(i8*, i8*)
declare void @llvm.coro.async.context.dealloc(i8*)
declare i8* @llvm.coro.async.resume()
declare token @llvm.coro.id.async(i32, i32, i32, i8*)
declare i8* @llvm.coro.begin(token, i8*)
declare i1 @llvm.coro.end.async(i8*, i1, ...)
declare i1 @llvm.coro.end(i8*, i1)
declare swiftcc void @asyncReturn(i8*)
declare swiftcc void @asyncSuspend(i8*)
declare {i8*} @llvm.coro.suspend.async(i32, i8*, i8*, ...)

define swiftcc void @my_async_function.my_other_async_function_fp.apply(i8* %fnPtr, i8* %async.ctxt) {
  %callee = bitcast i8* %fnPtr to void(i8*)*
  tail call swiftcc void %callee(i8* %async.ctxt)
  ret void
}

define i8* @__swift_async_resume_project_context(i8* %ctxt) {
entry:
  %resume_ctxt_addr = bitcast i8* %ctxt to i8**
  %resume_ctxt = load i8*, i8** %resume_ctxt_addr, align 8
  ret i8* %resume_ctxt
}


; CHECK: %my_async_function.Frame = type { i64, [48 x i8], i64, i64, [16 x i8], i8*, i64, i8* }
; CHECK: define swiftcc void @my_async_function
; CHECK:  [[T0:%.*]] = getelementptr inbounds %my_async_function.Frame, %my_async_function.Frame* %FramePtr, i32 0, i32 3
; CHECK:  [[T1:%.*]] = ptrtoint i64* [[T0]] to i64
; CHECK:  [[T2:%.*]] = add i64 [[T1]], 31
; CHECK:  [[T3:%.*]] = and i64 [[T2]], -32
; CHECK:  [[T4:%.*]] = inttoptr i64 [[T3]] to i64*
; CHECK:  [[T5:%.*]] = getelementptr inbounds %my_async_function.Frame, %my_async_function.Frame* %FramePtr, i32 0, i32 0
; CHECK:  [[T6:%.*]] = ptrtoint i64* [[T5]] to i64
; CHECK:  [[T7:%.*]] = add i64 [[T6]], 63
; CHECK:  [[T8:%.*]] = and i64 [[T7]], -64
; CHECK:  [[T9:%.*]] = inttoptr i64 [[T8]] to i64*
; CHECK:  store i64 2, i64* [[T4]]
; CHECK:  store i64 3, i64* [[T9]]

define swiftcc void @my_async_function(i8* swiftasync %async.ctxt) presplitcoroutine {
entry:
  %tmp = alloca i64, align 8
  %tmp2 = alloca i64, align 16
  %tmp3 = alloca i64, align 32
  %tmp4 = alloca i64, align 64

  %id = call token @llvm.coro.id.async(i32 32, i32 16, i32 0,
          i8* bitcast (<{i32, i32}>* @my_async_function_fp to i8*))
  %hdl = call i8* @llvm.coro.begin(token %id, i8* null)
  store i64 0, i64* %tmp
  store i64 1, i64* %tmp2
  store i64 2, i64* %tmp3
  store i64 3, i64* %tmp4

  %callee_context = call i8* @llvm.coro.async.context.alloc(i8* null, i8* null)
	%callee_context.0 = bitcast i8* %callee_context to %async.ctxt*
  %callee_context.return_to_caller.addr = getelementptr inbounds %async.ctxt, %async.ctxt* %callee_context.0, i32 0, i32 1
  %return_to_caller.addr = bitcast void(i8*)** %callee_context.return_to_caller.addr to i8**
  %resume.func_ptr = call i8* @llvm.coro.async.resume()
  store i8* %resume.func_ptr, i8** %return_to_caller.addr

  %callee = bitcast void(i8*)* @asyncSuspend to i8*
  %resume_proj_fun = bitcast i8*(i8*)* @__swift_async_resume_project_context to i8*
  %res = call {i8*} (i32, i8*, i8*, ...) @llvm.coro.suspend.async(i32 0,
                                                  i8* %resume.func_ptr,
                                                  i8* %resume_proj_fun,
                                                  void (i8*, i8*)* @my_async_function.my_other_async_function_fp.apply,
                                                  i8* %callee, i8* %callee_context)
  call void @opaque(i64* %tmp)
  call void @opaque(i64* %tmp2)
  call void @opaque(i64* %tmp3)
  call void @opaque(i64* %tmp4)
  call void @llvm.coro.async.context.dealloc(i8* %callee_context)
  tail call swiftcc void @asyncReturn(i8* %async.ctxt)
  call i1 (i8*, i1, ...) @llvm.coro.end.async(i8* %hdl, i1 0)
  unreachable
}