[llvm] a0d2fc1 - [Coroutines] Convert tests to opaque pointers (NFC)
Nikita Popov via llvm-commits
llvm-commits at lists.llvm.org
Thu Apr 20 08:24:10 PDT 2023
Author: Nikita Popov
Date: 2023-04-20T17:24:01+02:00
New Revision: a0d2fc126efd85a4712681e7ec04a04171557475
URL: https://github.com/llvm/llvm-project/commit/a0d2fc126efd85a4712681e7ec04a04171557475
DIFF: https://github.com/llvm/llvm-project/commit/a0d2fc126efd85a4712681e7ec04a04171557475.diff
LOG: [Coroutines] Convert tests to opaque pointers (NFC)
Added:
Modified:
llvm/test/Transforms/Coroutines/ArgAddr.ll
llvm/test/Transforms/Coroutines/coro-alloc-with-param-O0.ll
llvm/test/Transforms/Coroutines/coro-alloc-with-param-O2.ll
llvm/test/Transforms/Coroutines/coro-alloca-01.ll
llvm/test/Transforms/Coroutines/coro-alloca-02.ll
llvm/test/Transforms/Coroutines/coro-alloca-03.ll
llvm/test/Transforms/Coroutines/coro-alloca-04.ll
llvm/test/Transforms/Coroutines/coro-alloca-07.ll
llvm/test/Transforms/Coroutines/coro-async-dyn-align.ll
llvm/test/Transforms/Coroutines/coro-async-nomerge.ll
llvm/test/Transforms/Coroutines/coro-catchswitch.ll
llvm/test/Transforms/Coroutines/coro-debug-O2.ll
llvm/test/Transforms/Coroutines/coro-debug-coro-frame.ll
llvm/test/Transforms/Coroutines/coro-debug-dbg.values-not_used_in_frame.ll
llvm/test/Transforms/Coroutines/coro-debug-dbg.values.ll
llvm/test/Transforms/Coroutines/coro-debug-frame-variable.ll
llvm/test/Transforms/Coroutines/coro-debug.ll
llvm/test/Transforms/Coroutines/coro-eh-aware-edge-split-00.ll
llvm/test/Transforms/Coroutines/coro-eh-aware-edge-split-01.ll
llvm/test/Transforms/Coroutines/coro-eh-aware-edge-split-02.ll
llvm/test/Transforms/Coroutines/coro-frame-arrayalloca.ll
llvm/test/Transforms/Coroutines/coro-frame-reuse-alloca-02.ll
llvm/test/Transforms/Coroutines/coro-frame-reuse-alloca-04.ll
llvm/test/Transforms/Coroutines/coro-frame-reuse-alloca-05.ll
llvm/test/Transforms/Coroutines/coro-frame.ll
llvm/test/Transforms/Coroutines/coro-heap-elide.ll
llvm/test/Transforms/Coroutines/coro-padding.ll
llvm/test/Transforms/Coroutines/coro-param-copy.ll
llvm/test/Transforms/Coroutines/coro-resume-destroy.ll
llvm/test/Transforms/Coroutines/coro-retcon-frame.ll
llvm/test/Transforms/Coroutines/coro-spill-corobegin.ll
llvm/test/Transforms/Coroutines/coro-spill-defs-before-corobegin.ll
llvm/test/Transforms/Coroutines/coro-spill-promise.ll
llvm/test/Transforms/Coroutines/coro-split-00.ll
llvm/test/Transforms/Coroutines/coro-split-02.ll
llvm/test/Transforms/Coroutines/coro-split-eh-00.ll
llvm/test/Transforms/Coroutines/coro-split-eh-01.ll
llvm/test/Transforms/Coroutines/coro-split-hidden.ll
llvm/test/Transforms/Coroutines/coro-split-sink-lifetime-01.ll
llvm/test/Transforms/Coroutines/coro-split-sink-lifetime-03.ll
llvm/test/Transforms/Coroutines/coro-split-sink-lifetime-04.ll
llvm/test/Transforms/Coroutines/coro-zero-alloca.ll
llvm/test/Transforms/Coroutines/no-suspend.ll
Removed:
################################################################################
diff --git a/llvm/test/Transforms/Coroutines/ArgAddr.ll b/llvm/test/Transforms/Coroutines/ArgAddr.ll
index 6041c5d17d6b7..a06dd66da1c58 100644
--- a/llvm/test/Transforms/Coroutines/ArgAddr.ll
+++ b/llvm/test/Transforms/Coroutines/ArgAddr.ll
@@ -1,78 +1,75 @@
; Need to move users of allocas that were moved into the coroutine frame after
; coro.begin.
-; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
-define nonnull i8* @f(i32 %n) presplitcoroutine {
+define nonnull ptr @f(i32 %n) presplitcoroutine {
; CHECK-LABEL: @f(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[ID:%.*]] = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* bitcast ([3 x void (%f.Frame*)*]* @f.resumers to i8*))
+; CHECK-NEXT: [[ID:%.*]] = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr @f.resumers)
; CHECK-NEXT: [[N_ADDR:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 [[N:%.*]], i32* [[N_ADDR]], align 4
-; CHECK-NEXT: [[CALL:%.*]] = tail call i8* @malloc(i32 24)
-; CHECK-NEXT: [[TMP0:%.*]] = tail call noalias nonnull i8* @llvm.coro.begin(token [[ID]], i8* [[CALL]])
-; CHECK-NEXT: [[FRAMEPTR:%.*]] = bitcast i8* [[TMP0]] to %f.Frame*
-; CHECK-NEXT: [[RESUME_ADDR:%.*]] = getelementptr inbounds [[F_FRAME:%.*]], %f.Frame* [[FRAMEPTR]], i32 0, i32 0
-; CHECK-NEXT: store void (%f.Frame*)* @f.resume, void (%f.Frame*)** [[RESUME_ADDR]], align 8
-; CHECK-NEXT: [[DESTROY_ADDR:%.*]] = getelementptr inbounds [[F_FRAME]], %f.Frame* [[FRAMEPTR]], i32 0, i32 1
-; CHECK-NEXT: store void (%f.Frame*)* @f.destroy, void (%f.Frame*)** [[DESTROY_ADDR]], align 8
-; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds [[F_FRAME]], %f.Frame* [[FRAMEPTR]], i32 0, i32 2
-; CHECK-NEXT: [[TMP2:%.*]] = load i32, i32* [[N_ADDR]], align 4
-; CHECK-NEXT: store i32 [[TMP2]], i32* [[TMP1]], align 4
+; CHECK-NEXT: store i32 [[N:%.*]], ptr [[N_ADDR]], align 4
+; CHECK-NEXT: [[CALL:%.*]] = tail call ptr @malloc(i32 24)
+; CHECK-NEXT: [[TMP0:%.*]] = tail call noalias nonnull ptr @llvm.coro.begin(token [[ID]], ptr [[CALL]])
+; CHECK-NEXT: store ptr @f.resume, ptr [[TMP0]], align 8
+; CHECK-NEXT: [[DESTROY_ADDR:%.*]] = getelementptr inbounds [[F_FRAME:%.*]], ptr [[TMP0]], i32 0, i32 1
+; CHECK-NEXT: store ptr @f.destroy, ptr [[DESTROY_ADDR]], align 8
+; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds [[F_FRAME]], ptr [[TMP0]], i32 0, i32 2
+; CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[N_ADDR]], align 4
+; CHECK-NEXT: store i32 [[TMP2]], ptr [[TMP1]], align 4
;
entry:
- %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null);
+ %id = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null);
%n.addr = alloca i32
- store i32 %n, i32* %n.addr ; this needs to go after coro.begin
+ store i32 %n, ptr %n.addr ; this needs to go after coro.begin
%0 = tail call i32 @llvm.coro.size.i32()
- %call = tail call i8* @malloc(i32 %0)
- %1 = tail call noalias nonnull i8* @llvm.coro.begin(token %id, i8* %call)
- %2 = bitcast i32* %n.addr to i8*
- call void @ctor(i8* %2)
+ %call = tail call ptr @malloc(i32 %0)
+ %1 = tail call noalias nonnull ptr @llvm.coro.begin(token %id, ptr %call)
+ call void @ctor(ptr %n.addr)
br label %for.cond
for.cond:
- %3 = load i32, i32* %n.addr
- %dec = add nsw i32 %3, -1
- store i32 %dec, i32* %n.addr
- call void @print(i32 %3)
- %4 = call i8 @llvm.coro.suspend(token none, i1 false)
- %conv = sext i8 %4 to i32
+ %2 = load i32, ptr %n.addr
+ %dec = add nsw i32 %2, -1
+ store i32 %dec, ptr %n.addr
+ call void @print(i32 %2)
+ %3 = call i8 @llvm.coro.suspend(token none, i1 false)
+ %conv = sext i8 %3 to i32
switch i32 %conv, label %coro_Suspend [
i32 0, label %for.cond
i32 1, label %coro_Cleanup
]
coro_Cleanup:
- %5 = call i8* @llvm.coro.free(token %id, i8* nonnull %1)
- call void @free(i8* %5)
+ %4 = call ptr @llvm.coro.free(token %id, ptr nonnull %1)
+ call void @free(ptr %4)
br label %coro_Suspend
coro_Suspend:
- call i1 @llvm.coro.end(i8* null, i1 false)
- ret i8* %1
+ call i1 @llvm.coro.end(ptr null, i1 false)
+ ret ptr %1
}
; CHECK-LABEL: @main
define i32 @main() {
entry:
- %hdl = call i8* @f(i32 4)
- call void @llvm.coro.resume(i8* %hdl)
- call void @llvm.coro.resume(i8* %hdl)
- call void @llvm.coro.destroy(i8* %hdl)
+ %hdl = call ptr @f(i32 4)
+ call void @llvm.coro.resume(ptr %hdl)
+ call void @llvm.coro.resume(ptr %hdl)
+ call void @llvm.coro.destroy(ptr %hdl)
ret i32 0
}
-declare i8* @malloc(i32)
-declare void @free(i8*)
+declare ptr @malloc(i32)
+declare void @free(ptr)
declare void @print(i32)
-declare void @ctor(i8* nocapture readonly)
+declare void @ctor(ptr nocapture readonly)
-declare token @llvm.coro.id(i32, i8*, i8*, i8*)
+declare token @llvm.coro.id(i32, ptr, ptr, ptr)
declare i32 @llvm.coro.size.i32()
-declare i8* @llvm.coro.begin(token, i8*)
+declare ptr @llvm.coro.begin(token, ptr)
declare i8 @llvm.coro.suspend(token, i1)
-declare i8* @llvm.coro.free(token, i8*)
-declare i1 @llvm.coro.end(i8*, i1)
+declare ptr @llvm.coro.free(token, ptr)
+declare i1 @llvm.coro.end(ptr, i1)
-declare void @llvm.coro.resume(i8*)
-declare void @llvm.coro.destroy(i8*)
+declare void @llvm.coro.resume(ptr)
+declare void @llvm.coro.destroy(ptr)
diff --git a/llvm/test/Transforms/Coroutines/coro-alloc-with-param-O0.ll b/llvm/test/Transforms/Coroutines/coro-alloc-with-param-O0.ll
index a482ca43a42c3..31118c4c25770 100644
--- a/llvm/test/Transforms/Coroutines/coro-alloc-with-param-O0.ll
+++ b/llvm/test/Transforms/Coroutines/coro-alloc-with-param-O0.ll
@@ -1,17 +1,17 @@
; Check that we can handle the case when both alloc function and
; the user body consume the same argument.
-; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
; using copy of this (as it would happen under -O0)
-define i8* @f_copy(i64 %this_arg) presplitcoroutine {
+define ptr @f_copy(i64 %this_arg) presplitcoroutine {
entry:
%this.addr = alloca i64
- store i64 %this_arg, i64* %this.addr
- %this = load i64, i64* %this.addr
- %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
+ store i64 %this_arg, ptr %this.addr
+ %this = load i64, ptr %this.addr
+ %id = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
%size = call i32 @llvm.coro.size.i32()
- %alloc = call i8* @myAlloc(i64 %this, i32 %size)
- %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
+ %alloc = call ptr @myAlloc(i64 %this, i32 %size)
+ %hdl = call ptr @llvm.coro.begin(token %id, ptr %alloc)
%0 = call i8 @llvm.coro.suspend(token none, i1 false)
switch i8 %0, label %suspend [i8 0, label %resume
i8 1, label %cleanup]
@@ -20,43 +20,43 @@ resume:
br label %cleanup
cleanup:
- %mem = call i8* @llvm.coro.free(token %id, i8* %hdl)
- call void @free(i8* %mem)
+ %mem = call ptr @llvm.coro.free(token %id, ptr %hdl)
+ call void @free(ptr %mem)
br label %suspend
suspend:
- call i1 @llvm.coro.end(i8* %hdl, i1 0)
- ret i8* %hdl
+ call i1 @llvm.coro.end(ptr %hdl, i1 0)
+ ret ptr %hdl
}
; See if %this was added to the frame
-; CHECK: %f_copy.Frame = type { void (%f_copy.Frame*)*, void (%f_copy.Frame*)*, i64, i1 }
+; CHECK: %f_copy.Frame = type { ptr, ptr, i64, i1 }
; See that %this is spilled into the frame
-; CHECK-LABEL: define i8* @f_copy(i64 %this_arg)
+; CHECK-LABEL: define ptr @f_copy(i64 %this_arg)
; CHECK: %this.addr = alloca i64, align 8
-; CHECK: store i64 %this_arg, i64* %this.addr, align 4
-; CHECK: %this.spill.addr = getelementptr inbounds %f_copy.Frame, %f_copy.Frame* %FramePtr, i32 0, i32 2
-; CHECK: store i64 %this_arg, i64* %this.spill.addr
-; CHECK: ret i8* %hdl
+; CHECK: store i64 %this_arg, ptr %this.addr, align 4
+; CHECK: %this.spill.addr = getelementptr inbounds %f_copy.Frame, ptr %hdl, i32 0, i32 2
+; CHECK: store i64 %this_arg, ptr %this.spill.addr
+; CHECK: ret ptr %hdl
; See that %this was loaded from the frame
; CHECK-LABEL: @f_copy.resume(
-; CHECK: %this.reload = load i64, i64* %this.reload.addr
+; CHECK: %this.reload = load i64, ptr %this.reload.addr
; CHECK: call void @print2(i64 %this.reload)
; CHECK: ret void
-declare i8* @llvm.coro.free(token, i8*)
+declare ptr @llvm.coro.free(token, ptr)
declare i32 @llvm.coro.size.i32()
declare i8 @llvm.coro.suspend(token, i1)
-declare void @llvm.coro.resume(i8*)
-declare void @llvm.coro.destroy(i8*)
+declare void @llvm.coro.resume(ptr)
+declare void @llvm.coro.destroy(ptr)
-declare token @llvm.coro.id(i32, i8*, i8*, i8*)
+declare token @llvm.coro.id(i32, ptr, ptr, ptr)
declare i1 @llvm.coro.alloc(token)
-declare i8* @llvm.coro.begin(token, i8*)
-declare i1 @llvm.coro.end(i8*, i1)
+declare ptr @llvm.coro.begin(token, ptr)
+declare i1 @llvm.coro.end(ptr, i1)
-declare noalias i8* @myAlloc(i64, i32)
+declare noalias ptr @myAlloc(i64, i32)
declare double @print(double)
declare void @print2(i64)
-declare void @free(i8*)
+declare void @free(ptr)
diff --git a/llvm/test/Transforms/Coroutines/coro-alloc-with-param-O2.ll b/llvm/test/Transforms/Coroutines/coro-alloc-with-param-O2.ll
index 57b0a6b1d33e2..9eae6cc2cfa7e 100644
--- a/llvm/test/Transforms/Coroutines/coro-alloc-with-param-O2.ll
+++ b/llvm/test/Transforms/Coroutines/coro-alloc-with-param-O2.ll
@@ -1,14 +1,14 @@
; Check that we can handle the case when both alloc function and
; the user body consume the same argument.
-; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
; using this directly (as it would happen under -O2)
-define i8* @f_direct(i64 %this) presplitcoroutine {
+define ptr @f_direct(i64 %this) presplitcoroutine {
entry:
- %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
+ %id = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
%size = call i32 @llvm.coro.size.i32()
- %alloc = call i8* @myAlloc(i64 %this, i32 %size)
- %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
+ %alloc = call ptr @myAlloc(i64 %this, i32 %size)
+ %hdl = call ptr @llvm.coro.begin(token %id, ptr %alloc)
%0 = call i8 @llvm.coro.suspend(token none, i1 false)
switch i8 %0, label %suspend [i8 0, label %resume
i8 1, label %cleanup]
@@ -17,41 +17,41 @@ resume:
br label %cleanup
cleanup:
- %mem = call i8* @llvm.coro.free(token %id, i8* %hdl)
- call void @free(i8* %mem)
+ %mem = call ptr @llvm.coro.free(token %id, ptr %hdl)
+ call void @free(ptr %mem)
br label %suspend
suspend:
- call i1 @llvm.coro.end(i8* %hdl, i1 0)
- ret i8* %hdl
+ call i1 @llvm.coro.end(ptr %hdl, i1 0)
+ ret ptr %hdl
}
; See if %this was added to the frame
-; CHECK: %f_direct.Frame = type { void (%f_direct.Frame*)*, void (%f_direct.Frame*)*, i64, i1 }
+; CHECK: %f_direct.Frame = type { ptr, ptr, i64, i1 }
; See that %this is spilled into the frame
-; CHECK-LABEL: define i8* @f_direct(i64 %this)
-; CHECK: %this.spill.addr = getelementptr inbounds %f_direct.Frame, %f_direct.Frame* %FramePtr, i32 0, i32 2
-; CHECK: store i64 %this, i64* %this.spill.addr
-; CHECK: ret i8* %hdl
+; CHECK-LABEL: define ptr @f_direct(i64 %this)
+; CHECK: %this.spill.addr = getelementptr inbounds %f_direct.Frame, ptr %hdl, i32 0, i32 2
+; CHECK: store i64 %this, ptr %this.spill.addr
+; CHECK: ret ptr %hdl
; See that %this was loaded from the frame
; CHECK-LABEL: @f_direct.resume(
-; CHECK: %this.reload = load i64, i64* %this.reload.addr
+; CHECK: %this.reload = load i64, ptr %this.reload.addr
; CHECK: call void @print2(i64 %this.reload)
; CHECK: ret void
-declare i8* @llvm.coro.free(token, i8*)
+declare ptr @llvm.coro.free(token, ptr)
declare i32 @llvm.coro.size.i32()
declare i8 @llvm.coro.suspend(token, i1)
-declare void @llvm.coro.resume(i8*)
-declare void @llvm.coro.destroy(i8*)
+declare void @llvm.coro.resume(ptr)
+declare void @llvm.coro.destroy(ptr)
-declare token @llvm.coro.id(i32, i8*, i8*, i8*)
+declare token @llvm.coro.id(i32, ptr, ptr, ptr)
declare i1 @llvm.coro.alloc(token)
-declare i8* @llvm.coro.begin(token, i8*)
-declare i1 @llvm.coro.end(i8*, i1)
+declare ptr @llvm.coro.begin(token, ptr)
+declare i1 @llvm.coro.end(ptr, i1)
-declare noalias i8* @myAlloc(i64, i32)
+declare noalias ptr @myAlloc(i64, i32)
declare double @print(double)
declare void @print2(i64)
-declare void @free(i8*)
+declare void @free(ptr)
diff --git a/llvm/test/Transforms/Coroutines/coro-alloca-01.ll b/llvm/test/Transforms/Coroutines/coro-alloca-01.ll
index f0aa3974ef85c..9ba39491776ea 100644
--- a/llvm/test/Transforms/Coroutines/coro-alloca-01.ll
+++ b/llvm/test/Transforms/Coroutines/coro-alloca-01.ll
@@ -1,66 +1,62 @@
; Tests that CoroSplit can succesfully determine allocas should live on the frame
; if their aliases are used across suspension points through PHINode.
-; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
-define i8* @f(i1 %n) presplitcoroutine {
+define ptr @f(i1 %n) presplitcoroutine {
entry:
%x = alloca i64
%y = alloca i64
- %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
+ %id = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
%size = call i32 @llvm.coro.size.i32()
- %alloc = call i8* @malloc(i32 %size)
- %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
+ %alloc = call ptr @malloc(i32 %size)
+ %hdl = call ptr @llvm.coro.begin(token %id, ptr %alloc)
br i1 %n, label %flag_true, label %flag_false
flag_true:
- %x.alias = bitcast i64* %x to i32*
br label %merge
flag_false:
- %y.alias = bitcast i64* %y to i32*
br label %merge
merge:
- %alias_phi = phi i32* [ %x.alias, %flag_true ], [ %y.alias, %flag_false ]
+ %alias_phi = phi ptr [ %x, %flag_true ], [ %y, %flag_false ]
%sp1 = call i8 @llvm.coro.suspend(token none, i1 false)
switch i8 %sp1, label %suspend [i8 0, label %resume
i8 1, label %cleanup]
resume:
- call void @print(i32* %alias_phi)
+ call void @print(ptr %alias_phi)
br label %cleanup
cleanup:
- %mem = call i8* @llvm.coro.free(token %id, i8* %hdl)
- call void @free(i8* %mem)
+ %mem = call ptr @llvm.coro.free(token %id, ptr %hdl)
+ call void @free(ptr %mem)
br label %suspend
suspend:
- call i1 @llvm.coro.end(i8* %hdl, i1 0)
- ret i8* %hdl
+ call i1 @llvm.coro.end(ptr %hdl, i1 0)
+ ret ptr %hdl
}
; both %x and %y, as well as %alias_phi would all go to the frame.
-; CHECK: %f.Frame = type { void (%f.Frame*)*, void (%f.Frame*)*, i64, i64, i32*, i1 }
+; CHECK: %f.Frame = type { ptr, ptr, i64, i64, ptr, i1 }
; CHECK-LABEL: @f(
-; CHECK: %x.reload.addr = getelementptr inbounds %f.Frame, %f.Frame* %FramePtr, i32 0, i32 2
-; CHECK: %y.reload.addr = getelementptr inbounds %f.Frame, %f.Frame* %FramePtr, i32 0, i32 3
-; CHECK: %x.alias = bitcast i64* %x.reload.addr to i32*
-; CHECK: %y.alias = bitcast i64* %y.reload.addr to i32*
-; CHECK: %alias_phi = select i1 %n, i32* %x.alias, i32* %y.alias
-; CHECK: %alias_phi.spill.addr = getelementptr inbounds %f.Frame, %f.Frame* %FramePtr, i32 0, i32 4
-; CHECK: store i32* %alias_phi, i32** %alias_phi.spill.addr, align 8
+; CHECK: %x.reload.addr = getelementptr inbounds %f.Frame, ptr %hdl, i32 0, i32 2
+; CHECK: %y.reload.addr = getelementptr inbounds %f.Frame, ptr %hdl, i32 0, i32 3
+; CHECK: %alias_phi = phi ptr [ %y.reload.addr, %merge.from.flag_false ], [ %x.reload.addr, %entry ]
+; CHECK: %alias_phi.spill.addr = getelementptr inbounds %f.Frame, ptr %hdl, i32 0, i32 4
+; CHECK: store ptr %alias_phi, ptr %alias_phi.spill.addr, align 8
-declare i8* @llvm.coro.free(token, i8*)
+declare ptr @llvm.coro.free(token, ptr)
declare i32 @llvm.coro.size.i32()
declare i8 @llvm.coro.suspend(token, i1)
-declare void @llvm.coro.resume(i8*)
-declare void @llvm.coro.destroy(i8*)
+declare void @llvm.coro.resume(ptr)
+declare void @llvm.coro.destroy(ptr)
-declare token @llvm.coro.id(i32, i8*, i8*, i8*)
+declare token @llvm.coro.id(i32, ptr, ptr, ptr)
declare i1 @llvm.coro.alloc(token)
-declare i8* @llvm.coro.begin(token, i8*)
-declare i1 @llvm.coro.end(i8*, i1)
+declare ptr @llvm.coro.begin(token, ptr)
+declare i1 @llvm.coro.end(ptr, i1)
-declare void @print(i32*)
-declare noalias i8* @malloc(i32)
-declare void @free(i8*)
+declare void @print(ptr)
+declare noalias ptr @malloc(i32)
+declare void @free(ptr)
diff --git a/llvm/test/Transforms/Coroutines/coro-alloca-02.ll b/llvm/test/Transforms/Coroutines/coro-alloca-02.ll
index b620cba68d6d5..76d9a0126382e 100644
--- a/llvm/test/Transforms/Coroutines/coro-alloca-02.ll
+++ b/llvm/test/Transforms/Coroutines/coro-alloca-02.ll
@@ -1,53 +1,51 @@
; Tests that if an alloca is escaped through storing the address,
; the alloac will be put on the frame.
-; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
-define i8* @f() presplitcoroutine {
+define ptr @f() presplitcoroutine {
entry:
%x = alloca i64
- %y = alloca i32*
- %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
+ %y = alloca ptr
+ %id = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
%size = call i32 @llvm.coro.size.i32()
- %alloc = call i8* @malloc(i32 %size)
- %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
- %x.alias = bitcast i64* %x to i32*
- store i32* %x.alias, i32** %y
+ %alloc = call ptr @malloc(i32 %size)
+ %hdl = call ptr @llvm.coro.begin(token %id, ptr %alloc)
+ store ptr %x, ptr %y
%sp1 = call i8 @llvm.coro.suspend(token none, i1 false)
switch i8 %sp1, label %suspend [i8 0, label %resume
i8 1, label %cleanup]
resume:
- %x1 = load i32*, i32** %y
- call void @print(i32* %x1)
+ %x1 = load ptr, ptr %y
+ call void @print(ptr %x1)
br label %cleanup
cleanup:
- %mem = call i8* @llvm.coro.free(token %id, i8* %hdl)
- call void @free(i8* %mem)
+ %mem = call ptr @llvm.coro.free(token %id, ptr %hdl)
+ call void @free(ptr %mem)
br label %suspend
suspend:
- call i1 @llvm.coro.end(i8* %hdl, i1 0)
- ret i8* %hdl
+ call i1 @llvm.coro.end(ptr %hdl, i1 0)
+ ret ptr %hdl
}
-; CHECK: %f.Frame = type { void (%f.Frame*)*, void (%f.Frame*)*, i64, i32*, i1 }
-; CHECK-LABEL: define i8* @f()
-; CHECK: %x.reload.addr = getelementptr inbounds %f.Frame, %f.Frame* %FramePtr, i32 0, i32 2
-; CHECK: %y.reload.addr = getelementptr inbounds %f.Frame, %f.Frame* %FramePtr, i32 0, i32 3
-; CHECK: %x.alias = bitcast i64* %x.reload.addr to i32*
-; CHECK: store i32* %x.alias, i32** %y.reload.addr, align 8
+; CHECK: %f.Frame = type { ptr, ptr, i64, ptr, i1 }
+; CHECK-LABEL: define ptr @f()
+; CHECK: %x.reload.addr = getelementptr inbounds %f.Frame, ptr %hdl, i32 0, i32 2
+; CHECK: %y.reload.addr = getelementptr inbounds %f.Frame, ptr %hdl, i32 0, i32 3
+; CHECK: store ptr %x.reload.addr, ptr %y.reload.addr, align 8
-declare i8* @llvm.coro.free(token, i8*)
+declare ptr @llvm.coro.free(token, ptr)
declare i32 @llvm.coro.size.i32()
declare i8 @llvm.coro.suspend(token, i1)
-declare void @llvm.coro.resume(i8*)
-declare void @llvm.coro.destroy(i8*)
+declare void @llvm.coro.resume(ptr)
+declare void @llvm.coro.destroy(ptr)
-declare token @llvm.coro.id(i32, i8*, i8*, i8*)
+declare token @llvm.coro.id(i32, ptr, ptr, ptr)
declare i1 @llvm.coro.alloc(token)
-declare i8* @llvm.coro.begin(token, i8*)
-declare i1 @llvm.coro.end(i8*, i1)
+declare ptr @llvm.coro.begin(token, ptr)
+declare i1 @llvm.coro.end(ptr, i1)
-declare void @print(i32*)
-declare noalias i8* @malloc(i32)
-declare void @free(i8*)
+declare void @print(ptr)
+declare noalias ptr @malloc(i32)
+declare void @free(ptr)
diff --git a/llvm/test/Transforms/Coroutines/coro-alloca-03.ll b/llvm/test/Transforms/Coroutines/coro-alloca-03.ll
index 17bdddb4bb5d8..ec76a8a553654 100644
--- a/llvm/test/Transforms/Coroutines/coro-alloca-03.ll
+++ b/llvm/test/Transforms/Coroutines/coro-alloca-03.ll
@@ -1,18 +1,16 @@
; Tests that allocas escaped through function calls will live on the frame.
-; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
-define i8* @f() presplitcoroutine {
+define ptr @f() presplitcoroutine {
entry:
%x = alloca i64
%y = alloca i64
- %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
+ %id = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
%size = call i32 @llvm.coro.size.i32()
- %alloc = call i8* @malloc(i32 %size)
- %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
- %x.alias = bitcast i64* %x to i32*
- call void @capture_call(i32* %x.alias)
- %y.alias = bitcast i64* %y to i32*
- call void @nocapture_call(i32* %y.alias)
+ %alloc = call ptr @malloc(i32 %size)
+ %hdl = call ptr @llvm.coro.begin(token %id, ptr %alloc)
+ call void @capture_call(ptr %x)
+ call void @nocapture_call(ptr %y)
%sp1 = call i8 @llvm.coro.suspend(token none, i1 false)
switch i8 %sp1, label %suspend [i8 0, label %resume
i8 1, label %cleanup]
@@ -20,37 +18,35 @@ resume:
br label %cleanup
cleanup:
- %mem = call i8* @llvm.coro.free(token %id, i8* %hdl)
- call void @free(i8* %mem)
+ %mem = call ptr @llvm.coro.free(token %id, ptr %hdl)
+ call void @free(ptr %mem)
br label %suspend
suspend:
- call i1 @llvm.coro.end(i8* %hdl, i1 0)
- ret i8* %hdl
+ call i1 @llvm.coro.end(ptr %hdl, i1 0)
+ ret ptr %hdl
}
; %x needs to go to the frame since it's escaped; %y will stay as local since it doesn't escape.
-; CHECK: %f.Frame = type { void (%f.Frame*)*, void (%f.Frame*)*, i64, i1 }
-; CHECK-LABEL: define i8* @f()
+; CHECK: %f.Frame = type { ptr, ptr, i64, i1 }
+; CHECK-LABEL: define ptr @f()
; CHECK: %y = alloca i64, align 8
-; CHECK: %x.reload.addr = getelementptr inbounds %f.Frame, %f.Frame* %FramePtr, i32 0, i32 2
-; CHECK: %x.alias = bitcast i64* %x.reload.addr to i32*
-; CHECK: call void @capture_call(i32* %x.alias)
-; CHECK: %y.alias = bitcast i64* %y to i32*
-; CHECK: call void @nocapture_call(i32* %y.alias)
+; CHECK: %x.reload.addr = getelementptr inbounds %f.Frame, ptr %hdl, i32 0, i32 2
+; CHECK: call void @capture_call(ptr %x.reload.addr)
+; CHECK: call void @nocapture_call(ptr %y)
-declare i8* @llvm.coro.free(token, i8*)
+declare ptr @llvm.coro.free(token, ptr)
declare i32 @llvm.coro.size.i32()
declare i8 @llvm.coro.suspend(token, i1)
-declare void @llvm.coro.resume(i8*)
-declare void @llvm.coro.destroy(i8*)
+declare void @llvm.coro.resume(ptr)
+declare void @llvm.coro.destroy(ptr)
-declare token @llvm.coro.id(i32, i8*, i8*, i8*)
+declare token @llvm.coro.id(i32, ptr, ptr, ptr)
declare i1 @llvm.coro.alloc(token)
-declare i8* @llvm.coro.begin(token, i8*)
-declare i1 @llvm.coro.end(i8*, i1)
+declare ptr @llvm.coro.begin(token, ptr)
+declare i1 @llvm.coro.end(ptr, i1)
-declare void @capture_call(i32*)
-declare void @nocapture_call(i32* nocapture)
-declare noalias i8* @malloc(i32)
-declare void @free(i8*)
+declare void @capture_call(ptr)
+declare void @nocapture_call(ptr nocapture)
+declare noalias ptr @malloc(i32)
+declare void @free(ptr)
diff --git a/llvm/test/Transforms/Coroutines/coro-alloca-04.ll b/llvm/test/Transforms/Coroutines/coro-alloca-04.ll
index 80407be548eee..e528d81986f10 100644
--- a/llvm/test/Transforms/Coroutines/coro-alloca-04.ll
+++ b/llvm/test/Transforms/Coroutines/coro-alloca-04.ll
@@ -1,64 +1,60 @@
; Tests that CoroSplit can succesfully determine allocas should live on the frame
; if their aliases are used across suspension points through PHINode.
-; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
-define i8* @f(i1 %n) presplitcoroutine {
+define ptr @f(i1 %n) presplitcoroutine {
entry:
%x = alloca i64
br i1 %n, label %flag_true, label %flag_false
flag_true:
- %x.alias1 = bitcast i64* %x to i32*
br label %merge
flag_false:
- %x.alias2 = bitcast i64* %x to i32*
br label %merge
merge:
- %alias_phi = phi i32* [ %x.alias1, %flag_true ], [ %x.alias2, %flag_false ]
- %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
+ %alias_phi = phi ptr [ %x, %flag_true ], [ %x, %flag_false ]
+ %id = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
%size = call i32 @llvm.coro.size.i32()
- %alloc = call i8* @malloc(i32 %size)
- %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
+ %alloc = call ptr @malloc(i32 %size)
+ %hdl = call ptr @llvm.coro.begin(token %id, ptr %alloc)
%sp1 = call i8 @llvm.coro.suspend(token none, i1 false)
switch i8 %sp1, label %suspend [i8 0, label %resume
i8 1, label %cleanup]
resume:
- call void @print(i32* %alias_phi)
+ call void @print(ptr %alias_phi)
br label %cleanup
cleanup:
- %mem = call i8* @llvm.coro.free(token %id, i8* %hdl)
- call void @free(i8* %mem)
+ %mem = call ptr @llvm.coro.free(token %id, ptr %hdl)
+ call void @free(ptr %mem)
br label %suspend
suspend:
- call i1 @llvm.coro.end(i8* %hdl, i1 0)
- ret i8* %hdl
+ call i1 @llvm.coro.end(ptr %hdl, i1 0)
+ ret ptr %hdl
}
; both %x and %alias_phi would go to the frame.
-; CHECK: %f.Frame = type { void (%f.Frame*)*, void (%f.Frame*)*, i64, i32*, i1 }
+; CHECK: %f.Frame = type { ptr, ptr, i64, ptr, i1 }
; CHECK-LABEL: @f(
-; CHECK: store void (%f.Frame*)* @f.destroy, void (%f.Frame*)** %destroy.addr
-; CHECK-NEXT: %0 = getelementptr inbounds %f.Frame, %f.Frame* %FramePtr, i32 0, i32 2
-; CHECK-NEXT: %1 = bitcast i64* %0 to i8*
-; CHECK-NEXT: %2 = bitcast i8* %1 to i32*
-; CHECK: %alias_phi.spill.addr = getelementptr inbounds %f.Frame, %f.Frame* %FramePtr, i32 0, i32 3
-; CHECK-NEXT: store i32* %2, i32** %alias_phi.spill.addr
+; CHECK: store ptr @f.destroy, ptr %destroy.addr
+; CHECK-NEXT: %0 = getelementptr inbounds %f.Frame, ptr %hdl, i32 0, i32 2
+; CHECK: %alias_phi.spill.addr = getelementptr inbounds %f.Frame, ptr %hdl, i32 0, i32 3
+; CHECK-NEXT: store ptr %0, ptr %alias_phi.spill.addr
-declare i8* @llvm.coro.free(token, i8*)
+declare ptr @llvm.coro.free(token, ptr)
declare i32 @llvm.coro.size.i32()
declare i8 @llvm.coro.suspend(token, i1)
-declare void @llvm.coro.resume(i8*)
-declare void @llvm.coro.destroy(i8*)
+declare void @llvm.coro.resume(ptr)
+declare void @llvm.coro.destroy(ptr)
-declare token @llvm.coro.id(i32, i8*, i8*, i8*)
+declare token @llvm.coro.id(i32, ptr, ptr, ptr)
declare i1 @llvm.coro.alloc(token)
-declare i8* @llvm.coro.begin(token, i8*)
-declare i1 @llvm.coro.end(i8*, i1)
+declare ptr @llvm.coro.begin(token, ptr)
+declare i1 @llvm.coro.end(ptr, i1)
-declare void @print(i32*)
-declare noalias i8* @malloc(i32)
-declare void @free(i8*)
+declare void @print(ptr)
+declare noalias ptr @malloc(i32)
+declare void @free(ptr)
diff --git a/llvm/test/Transforms/Coroutines/coro-alloca-07.ll b/llvm/test/Transforms/Coroutines/coro-alloca-07.ll
index 7f71180e29ff6..57dde64be6759 100644
--- a/llvm/test/Transforms/Coroutines/coro-alloca-07.ll
+++ b/llvm/test/Transforms/Coroutines/coro-alloca-07.ll
@@ -1,103 +1,92 @@
; Tests that CoroSplit can succesfully determine allocas should live on the frame
; if their aliases are used across suspension points through PHINode.
-; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
-define i8* @f(i1 %n) presplitcoroutine {
+define ptr @f(i1 %n) presplitcoroutine {
entry:
%x = alloca i64
%y = alloca i64
- %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
+ %id = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
%size = call i32 @llvm.coro.size.i32()
- %alloc = call i8* @malloc(i32 %size)
- %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
+ %alloc = call ptr @malloc(i32 %size)
+ %hdl = call ptr @llvm.coro.begin(token %id, ptr %alloc)
br i1 %n, label %flag_true, label %flag_false
flag_true:
- %x.alias = bitcast i64* %x to i8*
- call void @llvm.lifetime.start.p0i8(i64 8, i8* %x.alias)
+ call void @llvm.lifetime.start.p0(i64 8, ptr %x)
br label %merge
flag_false:
- %y.alias = bitcast i64* %y to i8*
- call void @llvm.lifetime.start.p0i8(i64 8, i8* %y.alias)
+ call void @llvm.lifetime.start.p0(i64 8, ptr %y)
br label %merge
merge:
- %alias_phi = phi i8* [ %x.alias, %flag_true ], [ %y.alias, %flag_false ]
- store i8 1, i8* %alias_phi
+ %alias_phi = phi ptr [ %x, %flag_true ], [ %y, %flag_false ]
+ store i8 1, ptr %alias_phi
%sp1 = call i8 @llvm.coro.suspend(token none, i1 false)
switch i8 %sp1, label %suspend [i8 0, label %resume
i8 1, label %cleanup]
resume:
- call void @print(i8* %alias_phi)
+ call void @print(ptr %alias_phi)
br label %cleanup
cleanup:
- %mem = call i8* @llvm.coro.free(token %id, i8* %hdl)
- call void @free(i8* %mem)
+ %mem = call ptr @llvm.coro.free(token %id, ptr %hdl)
+ call void @free(ptr %mem)
br label %suspend
suspend:
- call i1 @llvm.coro.end(i8* %hdl, i1 0)
- ret i8* %hdl
+ call i1 @llvm.coro.end(ptr %hdl, i1 0)
+ ret ptr %hdl
}
-declare i8* @llvm.coro.free(token, i8*)
+declare ptr @llvm.coro.free(token, ptr)
declare i32 @llvm.coro.size.i32()
declare i8 @llvm.coro.suspend(token, i1)
-declare void @llvm.coro.resume(i8*)
-declare void @llvm.coro.destroy(i8*)
+declare void @llvm.coro.resume(ptr)
+declare void @llvm.coro.destroy(ptr)
-declare token @llvm.coro.id(i32, i8*, i8*, i8*)
+declare token @llvm.coro.id(i32, ptr, ptr, ptr)
declare i1 @llvm.coro.alloc(token)
-declare i8* @llvm.coro.begin(token, i8*)
-declare i1 @llvm.coro.end(i8*, i1)
+declare ptr @llvm.coro.begin(token, ptr)
+declare i1 @llvm.coro.end(ptr, i1)
-declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
+declare void @llvm.lifetime.start.p0(i64, ptr nocapture)
-declare void @print(i8*)
-declare noalias i8* @malloc(i32)
-declare void @free(i8*)
+declare void @print(ptr)
+declare noalias ptr @malloc(i32)
+declare void @free(ptr)
; Verify that both x and y are put in the frame.
-; CHECK: %f.Frame = type { void (%f.Frame*)*, void (%f.Frame*)*, i64, i64, i8*, i1 }
+; CHECK: %f.Frame = type { ptr, ptr, i64, i64, ptr, i1 }
; CHECK-LABEL: @f(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[ID:%.*]] = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* bitcast ([3 x void (%f.Frame*)*]* @f.resumers to i8*))
-; CHECK-NEXT: [[ALLOC:%.*]] = call i8* @malloc(i32 48)
-; CHECK-NEXT: [[HDL:%.*]] = call noalias nonnull i8* @llvm.coro.begin(token [[ID]], i8* [[ALLOC]])
-; CHECK-NEXT: [[FRAMEPTR:%.*]] = bitcast i8* [[HDL]] to %f.Frame*
-; CHECK-NEXT: [[RESUME_ADDR:%.*]] = getelementptr inbounds [[F_FRAME:%.*]], %f.Frame* [[FRAMEPTR]], i32 0, i32 0
-; CHECK-NEXT: store void (%f.Frame*)* @f.resume, void (%f.Frame*)** [[RESUME_ADDR]], align 8
-; CHECK-NEXT: [[DESTROY_ADDR:%.*]] = getelementptr inbounds [[F_FRAME]], %f.Frame* [[FRAMEPTR]], i32 0, i32 1
-; CHECK-NEXT: store void (%f.Frame*)* @f.destroy, void (%f.Frame*)** [[DESTROY_ADDR]], align 8
-; CHECK-NEXT: [[X_RELOAD_ADDR:%.*]] = getelementptr inbounds [[F_FRAME]], %f.Frame* [[FRAMEPTR]], i32 0, i32 2
-; CHECK-NEXT: [[Y_RELOAD_ADDR:%.*]] = getelementptr inbounds [[F_FRAME]], %f.Frame* [[FRAMEPTR]], i32 0, i32 3
-; CHECK-NEXT: br i1 [[N:%.*]], label [[FLAG_TRUE:%.*]], label [[FLAG_FALSE:%.*]]
-; CHECK: flag_true:
-; CHECK-NEXT: [[X_ALIAS:%.*]] = bitcast i64* [[X_RELOAD_ADDR]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[X_ALIAS]])
+; CHECK-NEXT: [[ID:%.*]] = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr @f.resumers)
+; CHECK-NEXT: [[ALLOC:%.*]] = call ptr @malloc(i32 48)
+; CHECK-NEXT: [[HDL:%.*]] = call noalias nonnull ptr @llvm.coro.begin(token [[ID]], ptr [[ALLOC]])
+; CHECK-NEXT: store ptr @f.resume, ptr [[HDL]], align 8
+; CHECK-NEXT: [[DESTROY_ADDR:%.*]] = getelementptr inbounds [[F_FRAME:%f.Frame]], ptr [[HDL]], i32 0, i32 1
+; CHECK-NEXT: store ptr @f.destroy, ptr [[DESTROY_ADDR]], align 8
+; CHECK-NEXT: [[X_RELOAD_ADDR:%.*]] = getelementptr inbounds [[F_FRAME]], ptr [[HDL]], i32 0, i32 2
+; CHECK-NEXT: [[Y_RELOAD_ADDR:%.*]] = getelementptr inbounds [[F_FRAME]], ptr [[HDL]], i32 0, i32 3
+; CHECK-NEXT: br i1 [[N:%.*]], label [[MERGE:%.*]], label [[MERGE_FROM_FLAG_FALSE:%.*]]
+; CHECK: merge.from.flag_false:
; CHECK-NEXT: br label [[MERGE:%.*]]
-; CHECK: flag_false:
-; CHECK-NEXT: [[Y_ALIAS:%.*]] = bitcast i64* [[Y_RELOAD_ADDR]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[Y_ALIAS]])
-; CHECK-NEXT: br label [[MERGE]]
; CHECK: merge:
-; CHECK-NEXT: [[ALIAS_PHI:%.*]] = phi i8* [ [[X_ALIAS]], [[FLAG_TRUE]] ], [ [[Y_ALIAS]], [[FLAG_FALSE]] ]
-; CHECK-NEXT: [[ALIAS_PHI_SPILL_ADDR:%.*]] = getelementptr inbounds [[F_FRAME]], %f.Frame* [[FRAMEPTR]], i32 0, i32 4
-; CHECK-NEXT: store i8* [[ALIAS_PHI]], i8** [[ALIAS_PHI_SPILL_ADDR]], align 8
-; CHECK-NEXT: store i8 1, i8* [[ALIAS_PHI]], align 1
-; CHECK-NEXT: [[INDEX_ADDR1:%.*]] = getelementptr inbounds [[F_FRAME]], %f.Frame* [[FRAMEPTR]], i32 0, i32 5
-; CHECK-NEXT: store i1 false, i1* [[INDEX_ADDR1]], align 1
-; CHECK-NEXT: ret i8* [[HDL]]
+; CHECK-NEXT: [[ALIAS_PHI:%.*]] = phi ptr [ [[Y_RELOAD_ADDR]], [[MERGE_FROM_FLAG_FALSE]] ], [ [[X_RELOAD_ADDR]], [[ENTRY:%.*]] ]
+; CHECK-NEXT: [[ALIAS_PHI_SPILL_ADDR:%.*]] = getelementptr inbounds [[F_FRAME]], ptr [[HDL]], i32 0, i32 4
+; CHECK-NEXT: store ptr [[ALIAS_PHI]], ptr [[ALIAS_PHI_SPILL_ADDR]], align 8
+; CHECK-NEXT: store i8 1, ptr [[ALIAS_PHI]], align 1
+; CHECK-NEXT: [[INDEX_ADDR1:%.*]] = getelementptr inbounds [[F_FRAME]], ptr [[HDL]], i32 0, i32 5
+; CHECK-NEXT: store i1 false, ptr [[INDEX_ADDR1]], align 1
+; CHECK-NEXT: ret ptr [[HDL]]
;
;
; CHECK-LABEL: @f.resume(
; CHECK-NEXT: entry.resume:
-; CHECK-NEXT: [[VFRAME:%.*]] = bitcast %f.Frame* [[FRAMEPTR:%.*]] to i8*
-; CHECK-NEXT: [[ALIAS_PHI_RELOAD_ADDR:%.*]] = getelementptr inbounds [[F_FRAME:%.*]], %f.Frame* [[FRAMEPTR]], i32 0, i32 4
-; CHECK-NEXT: [[ALIAS_PHI_RELOAD:%.*]] = load i8*, i8** [[ALIAS_PHI_RELOAD_ADDR]], align 8
-; CHECK-NEXT: call void @print(i8* [[ALIAS_PHI_RELOAD]])
-; CHECK-NEXT: call void @free(i8* [[VFRAME]])
+; CHECK-NEXT: [[ALIAS_PHI_RELOAD_ADDR:%.*]] = getelementptr inbounds [[F_FRAME:%.*]], ptr [[HDL]], i32 0, i32 4
+; CHECK-NEXT: [[ALIAS_PHI_RELOAD:%.*]] = load ptr, ptr [[ALIAS_PHI_RELOAD_ADDR]], align 8
+; CHECK-NEXT: call void @print(ptr [[ALIAS_PHI_RELOAD]])
+; CHECK-NEXT: call void @free(ptr [[FRAMEPTR:%.*]])
; CHECK-NEXT: ret void
diff --git a/llvm/test/Transforms/Coroutines/coro-async-dyn-align.ll b/llvm/test/Transforms/Coroutines/coro-async-dyn-align.ll
index de7384207a57e..e962dc7090445 100644
--- a/llvm/test/Transforms/Coroutines/coro-async-dyn-align.ll
+++ b/llvm/test/Transforms/Coroutines/coro-async-dyn-align.ll
@@ -1,4 +1,4 @@
-; RUN: opt -opaque-pointers=0 < %s -O0 -S | FileCheck %s
+; RUN: opt < %s -O0 -S | FileCheck %s
target datalayout = "p:64:64:64"
@@ -6,63 +6,61 @@ target datalayout = "p:64:64:64"
%async.actor = type { i64 }
%async.fp = type <{ i32, i32 }>
-%async.ctxt = type { i8*, void (i8*)* }
+%async.ctxt = type { ptr, ptr }
@my_other_async_function_fp = external global <{ i32, i32 }>
-declare void @my_other_async_function(i8* %async.ctxt)
+declare void @my_other_async_function(ptr %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)
+ i64 ptrtoint (ptr @my_async_function to i64),
+ i64 ptrtoint (ptr getelementptr inbounds (<{ i32, i32 }>, ptr @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*, ...)
+declare void @opaque(ptr)
+declare ptr @llvm.coro.async.context.alloc(ptr, ptr)
+declare void @llvm.coro.async.context.dealloc(ptr)
+declare ptr @llvm.coro.async.resume()
+declare token @llvm.coro.id.async(i32, i32, i32, ptr)
+declare ptr @llvm.coro.begin(token, ptr)
+declare i1 @llvm.coro.end.async(ptr, i1, ...)
+declare i1 @llvm.coro.end(ptr, i1)
+declare swiftcc void @asyncReturn(ptr)
+declare swiftcc void @asyncSuspend(ptr)
+declare {ptr} @llvm.coro.suspend.async(i32, ptr, ptr, ...)
-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)
+define swiftcc void @my_async_function.my_other_async_function_fp.apply(ptr %fnPtr, ptr %async.ctxt) {
+ tail call swiftcc void %fnPtr(ptr %async.ctxt)
ret void
}
-define i8* @__swift_async_resume_project_context(i8* %ctxt) {
+define ptr @__swift_async_resume_project_context(ptr %ctxt) {
entry:
- %resume_ctxt_addr = bitcast i8* %ctxt to i8**
- %resume_ctxt = load i8*, i8** %resume_ctxt_addr, align 8
- ret i8* %resume_ctxt
+ %resume_ctxt = load ptr, ptr %ctxt, align 8
+ ret ptr %resume_ctxt
}
-; CHECK: %my_async_function.Frame = type { i64, [48 x i8], i64, i64, [16 x i8], i8*, i64, i8* }
+; CHECK: %my_async_function.Frame = type { i64, [48 x i8], i64, i64, [16 x i8], ptr, i64, ptr }
; 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: [[T0:%.*]] = getelementptr inbounds %my_async_function.Frame, ptr %async.ctx.frameptr, i32 0, i32 3
+; CHECK: [[T1:%.*]] = ptrtoint ptr [[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: [[T4:%.*]] = inttoptr i64 [[T3]] to ptr
+; CHECK: [[FP:%.*]] = getelementptr inbounds %my_async_function.Frame, ptr %async.ctx.frameptr, i32 0, i32 0
+; CHECK: [[T6:%.*]] = ptrtoint ptr [[FP]] 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]]
+; CHECK: [[T9:%.*]] = inttoptr i64 [[T8]] to ptr
+; CHECK: store i64 2, ptr [[T4]]
+; CHECK: store i64 3, ptr [[T9]]
-define swiftcc void @my_async_function(i8* swiftasync %async.ctxt) presplitcoroutine {
+define swiftcc void @my_async_function(ptr swiftasync %async.ctxt) presplitcoroutine {
entry:
%tmp = alloca i64, align 8
%tmp2 = alloca i64, align 16
@@ -70,33 +68,29 @@ entry:
%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
+ ptr @my_async_function_fp)
+ %hdl = call ptr @llvm.coro.begin(token %id, ptr null)
+ store i64 0, ptr %tmp
+ store i64 1, ptr %tmp2
+ store i64 2, ptr %tmp3
+ store i64 3, ptr %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_context = call ptr @llvm.coro.async.context.alloc(ptr null, ptr null)
+ %callee_context.return_to_caller.addr = getelementptr inbounds %async.ctxt, ptr %callee_context, i32 0, i32 1
+ %resume.func_ptr = call ptr @llvm.coro.async.resume()
+ store ptr %resume.func_ptr, ptr %callee_context.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)
+ %res = call {ptr} (i32, ptr, ptr, ...) @llvm.coro.suspend.async(i32 0,
+ ptr %resume.func_ptr,
+ ptr @__swift_async_resume_project_context,
+ ptr @my_async_function.my_other_async_function_fp.apply,
+ ptr @asyncSuspend, ptr %callee_context)
+ call void @opaque(ptr %tmp)
+ call void @opaque(ptr %tmp2)
+ call void @opaque(ptr %tmp3)
+ call void @opaque(ptr %tmp4)
+ call void @llvm.coro.async.context.dealloc(ptr %callee_context)
+ tail call swiftcc void @asyncReturn(ptr %async.ctxt)
+ call i1 (ptr, i1, ...) @llvm.coro.end.async(ptr %hdl, i1 0)
unreachable
}
diff --git a/llvm/test/Transforms/Coroutines/coro-async-nomerge.ll b/llvm/test/Transforms/Coroutines/coro-async-nomerge.ll
index b6578b4224108..ac39704b93da5 100644
--- a/llvm/test/Transforms/Coroutines/coro-async-nomerge.ll
+++ b/llvm/test/Transforms/Coroutines/coro-async-nomerge.ll
@@ -1,80 +1,79 @@
-; RUN: opt -opaque-pointers=0 < %s -O2 -S
-; RUN: opt -opaque-pointers=0 -S -hoist-common-insts -hoist-common-insts -passes=simplifycfg < %s | FileCheck %s --check-prefixes=CHECK
+; RUN: opt < %s -O2 -S
+; RUN: opt -S -hoist-common-insts -hoist-common-insts -passes=simplifycfg < %s | FileCheck %s --check-prefixes=CHECK
target datalayout = "p:64:64:64"
%swift.async_func_pointer = type <{ i32, i32 }>
-%swift.context = type { %swift.context*, void (%swift.context*)* }
+%swift.context = type { ptr, ptr }
declare void @f()
declare void @g()
-declare i8* @llvm.coro.async.resume()
-declare { i8* } @llvm.coro.suspend.async.sl_p0i8s(i32, i8*, i8*, ...)
-declare i8* @llvm.coro.begin(token, i8* writeonly)
-declare token @llvm.coro.id.async(i32, i32, i32, i8*)
+declare ptr @llvm.coro.async.resume()
+declare { ptr } @llvm.coro.suspend.async.sl_p0i8s(i32, ptr, ptr, ...)
+declare ptr @llvm.coro.begin(token, ptr writeonly)
+declare token @llvm.coro.id.async(i32, i32, i32, ptr)
-declare i1 @llvm.coro.end.async(i8*, i1, ...)
+declare i1 @llvm.coro.end.async(ptr, i1, ...)
-define linkonce_odr hidden i8* @__swift_async_resume_get_context(i8* %0) {
+define linkonce_odr hidden ptr @__swift_async_resume_get_context(ptr %0) {
entry:
- ret i8* %0
+ ret ptr %0
}
- at repoTU = hidden global %swift.async_func_pointer <{ i32 trunc (i64 sub (i64 ptrtoint (void (%swift.context*, i1)* @repo to i64), i64 ptrtoint (%swift.async_func_pointer* @repoTU to i64)) to i32), i32 16 }>, align 8
+ at repoTU = hidden global %swift.async_func_pointer <{ i32 trunc (i64 sub (i64 ptrtoint (ptr @repo to i64), i64 ptrtoint (ptr @repoTU to i64)) to i32), i32 16 }>, align 8
; This test used to crash in optimized mode because simplify cfg would sink the
; suspend.async() instruction into a common successor block.
; CHECK: swifttailcc void @repo
-; CHECK:llvm.coro.suspend.async.sl_p0i8s
+; CHECK:llvm.coro.suspend.async.sl_p0s
; CHECK: br
-; CHECK:llvm.coro.suspend.async.sl_p0i8s
+; CHECK:llvm.coro.suspend.async.sl_p0s
; CHECK: br
; CHECK: ret
-define hidden swifttailcc void @repo(%swift.context* swiftasync %0, i1 %cond) {
+define hidden swifttailcc void @repo(ptr swiftasync %0, i1 %cond) {
entry:
- %tok = call token @llvm.coro.id.async(i32 16, i32 16, i32 0, i8* bitcast (%swift.async_func_pointer* @repoTU to i8*))
- %id = call i8* @llvm.coro.begin(token %tok, i8* null)
+ %tok = call token @llvm.coro.id.async(i32 16, i32 16, i32 0, ptr @repoTU)
+ %id = call ptr @llvm.coro.begin(token %tok, ptr null)
br i1 %cond, label %bb1, label %bb2
bb1:
call void @f()
- %ptr0 = call i8* @llvm.coro.async.resume()
+ %ptr0 = call ptr @llvm.coro.async.resume()
call void @f()
; Simplifycfg must not sink the suspend instruction.
- %t3 = call { i8* } (i32, i8*, i8*, ...) @llvm.coro.suspend.async.sl_p0i8s(i32 0, i8* %ptr0, i8* bitcast (i8* (i8*)* @__swift_async_resume_get_context to i8*), i8* bitcast (void (i8*, %swift.context*)* @repo.1 to i8*), i8* %ptr0, %swift.context* %0)
+ %t3 = call { ptr } (i32, ptr, ptr, ...) @llvm.coro.suspend.async.sl_p0i8s(i32 0, ptr %ptr0, ptr @__swift_async_resume_get_context, ptr @repo.1, ptr %ptr0, ptr %0)
br label %tailblock
bb2:
call void @g()
- %ptr1 = call i8* @llvm.coro.async.resume()
+ %ptr1 = call ptr @llvm.coro.async.resume()
call void @g()
; Simplifycfg must not sink the suspend instruction.
- %t4 = call { i8* } (i32, i8*, i8*, ...) @llvm.coro.suspend.async.sl_p0i8s(i32 0, i8* %ptr1, i8* bitcast (i8* (i8*)* @__swift_async_resume_get_context to i8*), i8* bitcast (void (i8*, %swift.context*)* @repo.1 to i8*), i8* %ptr1, %swift.context* %0)
+ %t4 = call { ptr } (i32, ptr, ptr, ...) @llvm.coro.suspend.async.sl_p0i8s(i32 0, ptr %ptr1, ptr @__swift_async_resume_get_context, ptr @repo.1, ptr %ptr1, ptr %0)
br label %tailblock
tailblock:
- %t = call i1 (i8*, i1, ...) @llvm.coro.end.async(i8* %id, i1 false, void (i8*, %swift.context*)* @repo.0, i8* bitcast (void (%swift.context*)* @return to i8*), %swift.context* %0)
+ %t = call i1 (ptr, i1, ...) @llvm.coro.end.async(ptr %id, i1 false, ptr @repo.0, ptr @return, ptr %0)
unreachable
}
-define internal swifttailcc void @repo.0(i8* %0, %swift.context* %1) {
+define internal swifttailcc void @repo.0(ptr %0, ptr %1) {
entry:
- %2 = bitcast i8* %0 to void (%swift.context*)*
- musttail call swifttailcc void %2(%swift.context* swiftasync %1)
+ musttail call swifttailcc void %0(ptr swiftasync %1)
ret void
}
-declare swifttailcc void @swift_task_switch(%swift.context*, i8*)
+declare swifttailcc void @swift_task_switch(ptr, ptr)
-define internal swifttailcc void @repo.1(i8* %0, %swift.context* %1) {
+define internal swifttailcc void @repo.1(ptr %0, ptr %1) {
entry:
- musttail call swifttailcc void @swift_task_switch(%swift.context* swiftasync %1, i8* %0)
+ musttail call swifttailcc void @swift_task_switch(ptr swiftasync %1, ptr %0)
ret void
}
-declare swifttailcc void @return(%swift.context* swiftasync)
+declare swifttailcc void @return(ptr swiftasync)
- at repoTU2 = hidden global %swift.async_func_pointer <{ i32 trunc (i64 sub (i64 ptrtoint (void (%swift.context*, i1)* @repo2 to i64), i64 ptrtoint (%swift.async_func_pointer* @repoTU2 to i64)) to i32), i32 16 }>, align 8
+ at repoTU2 = hidden global %swift.async_func_pointer <{ i32 trunc (i64 sub (i64 ptrtoint (ptr @repo2 to i64), i64 ptrtoint (ptr @repoTU2 to i64)) to i32), i32 16 }>, align 8
; This test used to crash in optimized mode because simplify cfg would hoist the
; async.resume() instruction into a common block.
@@ -84,38 +83,38 @@ declare swifttailcc void @return(%swift.context* swiftasync)
; CHECK: br i1
; CHECK: @llvm.coro.async.resume()
-; CHECK: llvm.coro.suspend.async.sl_p0i8s
+; CHECK: llvm.coro.suspend.async.sl_p0s
; CHECK: br
; CHECK:@llvm.coro.async.resume()
-; CHECK:llvm.coro.suspend.async.sl_p0i8s
+; CHECK:llvm.coro.suspend.async.sl_p0s
; CHECK: br
; CHECK: ret
-define hidden swifttailcc void @repo2(%swift.context* swiftasync %0, i1 %cond) {
+define hidden swifttailcc void @repo2(ptr swiftasync %0, i1 %cond) {
entry:
- %tok = call token @llvm.coro.id.async(i32 16, i32 16, i32 0, i8* bitcast (%swift.async_func_pointer* @repoTU2 to i8*))
- %id = call i8* @llvm.coro.begin(token %tok, i8* null)
+ %tok = call token @llvm.coro.id.async(i32 16, i32 16, i32 0, ptr @repoTU2)
+ %id = call ptr @llvm.coro.begin(token %tok, ptr null)
br i1 %cond, label %bb1, label %bb2
bb1:
; Simplifycfg must not hoist the resume instruction.
- %ptr0 = call i8* @llvm.coro.async.resume()
+ %ptr0 = call ptr @llvm.coro.async.resume()
call void @f()
- %t3 = call { i8* } (i32, i8*, i8*, ...) @llvm.coro.suspend.async.sl_p0i8s(i32 0, i8* %ptr0, i8* bitcast (i8* (i8*)* @__swift_async_resume_get_context to i8*), i8* bitcast (void (i8*, %swift.context*)* @repo.1 to i8*), i8* %ptr0, %swift.context* %0)
+ %t3 = call { ptr } (i32, ptr, ptr, ...) @llvm.coro.suspend.async.sl_p0i8s(i32 0, ptr %ptr0, ptr @__swift_async_resume_get_context, ptr @repo.1, ptr %ptr0, ptr %0)
call void @f()
br label %tailblock
bb2:
; Simplifycfg must not hoist the resume instruction.
- %ptr1 = call i8* @llvm.coro.async.resume()
+ %ptr1 = call ptr @llvm.coro.async.resume()
call void @g()
- %t4 = call { i8* } (i32, i8*, i8*, ...) @llvm.coro.suspend.async.sl_p0i8s(i32 0, i8* %ptr1, i8* bitcast (i8* (i8*)* @__swift_async_resume_get_context to i8*), i8* bitcast (void (i8*, %swift.context*)* @repo.1 to i8*), i8* %ptr1, %swift.context* %0)
+ %t4 = call { ptr } (i32, ptr, ptr, ...) @llvm.coro.suspend.async.sl_p0i8s(i32 0, ptr %ptr1, ptr @__swift_async_resume_get_context, ptr @repo.1, ptr %ptr1, ptr %0)
call void @g()
br label %tailblock
tailblock:
- %t = call i1 (i8*, i1, ...) @llvm.coro.end.async(i8* %id, i1 false, void (i8*, %swift.context*)* @repo.0, i8* bitcast (void (%swift.context*)* @return to i8*), %swift.context* %0)
+ %t = call i1 (ptr, i1, ...) @llvm.coro.end.async(ptr %id, i1 false, ptr @repo.0, ptr @return, ptr %0)
unreachable
}
diff --git a/llvm/test/Transforms/Coroutines/coro-catchswitch.ll b/llvm/test/Transforms/Coroutines/coro-catchswitch.ll
index 7b523b52cbe01..dca9a754c9f6c 100644
--- a/llvm/test/Transforms/Coroutines/coro-catchswitch.ll
+++ b/llvm/test/Transforms/Coroutines/coro-catchswitch.ll
@@ -1,5 +1,5 @@
; Verifies that we can insert the spill for a PHI preceding the catchswitch
-; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
target triple = "i686-pc-windows-msvc"
@@ -7,10 +7,10 @@ target triple = "i686-pc-windows-msvc"
; CHECK-LABEL: define void @f(
define void @f(i1 %cond) presplitcoroutine personality i32 0 {
entry:
- %id = call token @llvm.coro.id(i32 8, i8* null, i8* null, i8* null)
+ %id = call token @llvm.coro.id(i32 8, ptr null, ptr null, ptr null)
%size = call i32 @llvm.coro.size.i32()
- %alloc = call i8* @malloc(i32 %size)
- %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
+ %alloc = call ptr @malloc(i32 %size)
+ %hdl = call ptr @llvm.coro.begin(token %id, ptr %alloc)
br i1 %cond, label %if.else, label %if.then
if.then:
@@ -31,15 +31,15 @@ catch.dispatch: ; preds = %if.else, %if.then
; CHECK: catch.dispatch:
; CHECK: %val = phi i32 [ 2, %if.else ], [ 1, %if.then ]
; CHECK: %[[Pad:.+]] = cleanuppad within none []
-; CHECK: %val.spill.addr = getelementptr inbounds %f.Frame, %f.Frame* %FramePtr, i32 0, i32 2
-; CHECK: store i32 %val, i32* %val.spill.addr
+; CHECK: %val.spill.addr = getelementptr inbounds %f.Frame, ptr %hdl, i32 0, i32 2
+; CHECK: store i32 %val, ptr %val.spill.addr
; CHECK: cleanupret from %[[Pad]] unwind label %[[Switch:.+]]
; CHECK: [[Switch]]:
; CHECK: %switch = catchswitch within none [label %catch] unwind to caller
catch: ; preds = %catch.dispatch
- %pad = catchpad within %switch [i8* null, i32 64, i8* null]
+ %pad = catchpad within %switch [ptr null, i32 64, ptr null]
catchret from %pad to label %suspend
suspend:
@@ -54,7 +54,7 @@ resume: ; preds = %await2.suspend
br label %coro.ret
coro.ret:
- call i1 @llvm.coro.end(i8* %hdl, i1 0)
+ call i1 @llvm.coro.end(ptr %hdl, i1 0)
ret void
cleanuppad:
@@ -63,26 +63,26 @@ cleanuppad:
}
; Function Attrs: argmemonly nounwind readonly
-declare token @llvm.coro.id(i32, i8* readnone, i8* nocapture readonly, i8*) #1
+declare token @llvm.coro.id(i32, ptr readnone, ptr nocapture readonly, ptr) #1
; Function Attrs: nounwind
declare i1 @llvm.coro.alloc(token) #2
; Function Attrs: nobuiltin
declare i32 @llvm.coro.size.i32() #4
-declare i8* @llvm.coro.begin(token, i8* writeonly) #2
-declare token @llvm.coro.save(i8*)
+declare ptr @llvm.coro.begin(token, ptr writeonly) #2
+declare token @llvm.coro.save(ptr)
declare i8 @llvm.coro.suspend(token, i1)
declare void @may_throw1()
declare void @may_throw2()
declare void @print(i32)
-declare noalias i8* @malloc(i32)
-declare void @free(i8*)
+declare noalias ptr @malloc(i32)
+declare void @free(ptr)
-declare i1 @llvm.coro.end(i8*, i1) #2
+declare i1 @llvm.coro.end(ptr, i1) #2
; Function Attrs: nobuiltin nounwind
; Function Attrs: argmemonly nounwind readonly
-declare i8* @llvm.coro.free(token, i8* nocapture readonly) #1
+declare ptr @llvm.coro.free(token, ptr nocapture readonly) #1
diff --git a/llvm/test/Transforms/Coroutines/coro-debug-O2.ll b/llvm/test/Transforms/Coroutines/coro-debug-O2.ll
index 869403b2b1d31..e857b0ddf2876 100644
--- a/llvm/test/Transforms/Coroutines/coro-debug-O2.ll
+++ b/llvm/test/Transforms/Coroutines/coro-debug-O2.ll
@@ -1,10 +1,10 @@
-; RUN: opt -opaque-pointers=0 < %s -passes='module(coro-early),cgscc(coro-split<reuse-storage>),function(sroa)' -S | FileCheck %s
+; RUN: opt < %s -passes='module(coro-early),cgscc(coro-split<reuse-storage>),function(sroa)' -S | FileCheck %s
; Checks whether the dbg.declare for `__promise` remains valid under O2.
; CHECK-LABEL: define internal fastcc void @f.resume({{.*}})
; CHECK: entry.resume:
-; CHECK: call void @llvm.dbg.declare(metadata %f.Frame* %FramePtr, metadata ![[PROMISEVAR_RESUME:[0-9]+]], metadata !DIExpression(
+; CHECK: call void @llvm.dbg.declare(metadata ptr %begin, metadata ![[PROMISEVAR_RESUME:[0-9]+]], metadata !DIExpression(
;
; CHECK: ![[PROMISEVAR_RESUME]] = !DILocalVariable(name: "__promise"
%promise_type = type { i32, i32, double }
@@ -12,31 +12,29 @@
define void @f() presplitcoroutine !dbg !8 {
entry:
%__promise = alloca %promise_type, align 8
- %0 = bitcast %promise_type* %__promise to i8*
- %id = call token @llvm.coro.id(i32 16, i8* %0, i8* null, i8* null)
+ %id = call token @llvm.coro.id(i32 16, ptr %__promise, ptr null, ptr null)
%alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %alloc, label %coro.alloc, label %coro.init
coro.alloc: ; preds = %entry
%size = call i64 @llvm.coro.size.i64()
- %memory = call i8* @new(i64 %size)
+ %memory = call ptr @new(i64 %size)
br label %coro.init
coro.init: ; preds = %coro.alloc, %entry
- %phi.entry.alloc = phi i8* [ null, %entry ], [ %memory, %coro.alloc ]
- %begin = call i8* @llvm.coro.begin(token %id, i8* %phi.entry.alloc)
- call void @llvm.dbg.declare(metadata %promise_type* %__promise, metadata !6, metadata !DIExpression()), !dbg !18
- %i.i = getelementptr inbounds %promise_type, %promise_type* %__promise, i64 0, i32 0
- store i32 1, i32* %i.i, align 8
- %j.i = getelementptr inbounds %promise_type, %promise_type* %__promise, i64 0, i32 1
- store i32 2, i32* %j.i, align 4
- %k.i = getelementptr inbounds %promise_type, %promise_type* %__promise, i64 0, i32 2
- store double 3.000000e+00, double* %k.i, align 8
+ %phi.entry.alloc = phi ptr [ null, %entry ], [ %memory, %coro.alloc ]
+ %begin = call ptr @llvm.coro.begin(token %id, ptr %phi.entry.alloc)
+ call void @llvm.dbg.declare(metadata ptr %__promise, metadata !6, metadata !DIExpression()), !dbg !18
+ store i32 1, ptr %__promise, align 8
+ %j.i = getelementptr inbounds %promise_type, ptr %__promise, i64 0, i32 1
+ store i32 2, ptr %j.i, align 4
+ %k.i = getelementptr inbounds %promise_type, ptr %__promise, i64 0, i32 2
+ store double 3.000000e+00, ptr %k.i, align 8
%ready = call i1 @await_ready()
br i1 %ready, label %init.ready, label %init.suspend
init.suspend: ; preds = %coro.init
- %save = call token @llvm.coro.save(i8* null)
+ %save = call token @llvm.coro.save(ptr null)
call void @await_suspend()
%suspend = call i8 @llvm.coro.suspend(token %save, i1 false)
switch i8 %suspend, label %coro.ret [
@@ -53,8 +51,8 @@ init.ready: ; preds = %init.suspend, %coro
br i1 %ready.again, label %await.ready, label %await.suspend
await.suspend: ; preds = %init.ready
- %save.again = call token @llvm.coro.save(i8* null)
- %from.address = call i8* @from_address(i8* %begin)
+ %save.again = call token @llvm.coro.save(ptr null)
+ %from.address = call ptr @from_address(ptr %begin)
call void @await_suspend()
%suspend.again = call i8 @llvm.coro.suspend(token %save.again, i1 false)
switch i8 %suspend.again, label %coro.ret [
@@ -76,8 +74,8 @@ coro.final: ; preds = %await.ready
br i1 %coro.final.await_ready, label %final.ready, label %final.suspend
final.suspend: ; preds = %coro.final
- %final.suspend.coro.save = call token @llvm.coro.save(i8* null)
- %final.suspend.from_address = call i8* @from_address(i8* %begin)
+ %final.suspend.coro.save = call token @llvm.coro.save(ptr null)
+ %final.suspend.from_address = call ptr @from_address(ptr %begin)
call void @await_suspend()
%final.suspend.coro.suspend = call i8 @llvm.coro.suspend(token %final.suspend.coro.save, i1 true)
switch i8 %final.suspend.coro.suspend, label %coro.ret [
@@ -94,12 +92,12 @@ final.ready: ; preds = %final.suspend, %cor
cleanup: ; preds = %final.ready, %final.cleanup, %await.cleanup, %init.cleanup
%cleanup.dest.slot.0 = phi i32 [ 0, %final.ready ], [ 2, %final.cleanup ], [ 2, %await.cleanup ], [ 2, %init.cleanup ]
- %free.memory = call i8* @llvm.coro.free(token %id, i8* %begin)
- %free = icmp ne i8* %free.memory, null
+ %free.memory = call ptr @llvm.coro.free(token %id, ptr %begin)
+ %free = icmp ne ptr %free.memory, null
br i1 %free, label %coro.free, label %after.coro.free
coro.free: ; preds = %cleanup
- call void @delete(i8* %free.memory)
+ call void @delete(ptr %free.memory)
br label %after.coro.free
after.coro.free: ; preds = %coro.free, %cleanup
@@ -112,7 +110,7 @@ cleanup.cont: ; preds = %after.coro.free
br label %coro.ret
coro.ret: ; preds = %cleanup.cont, %after.coro.free, %final.suspend, %await.suspend, %init.suspend
- %end = call i1 @llvm.coro.end(i8* null, i1 false)
+ %end = call i1 @llvm.coro.end(ptr null, i1 false)
ret void
unreachable: ; preds = %after.coro.free
@@ -121,22 +119,22 @@ unreachable: ; preds = %after.coro.free
}
declare void @llvm.dbg.declare(metadata, metadata, metadata)
-declare token @llvm.coro.id(i32, i8* readnone, i8* nocapture readonly, i8*)
+declare token @llvm.coro.id(i32, ptr readnone, ptr nocapture readonly, ptr)
declare i1 @llvm.coro.alloc(token)
declare i64 @llvm.coro.size.i64()
-declare token @llvm.coro.save(i8*)
-declare i8* @llvm.coro.begin(token, i8* writeonly)
+declare token @llvm.coro.save(ptr)
+declare ptr @llvm.coro.begin(token, ptr writeonly)
declare i8 @llvm.coro.suspend(token, i1)
-declare i8* @llvm.coro.free(token, i8* nocapture readonly)
-declare i1 @llvm.coro.end(i8*, i1)
+declare ptr @llvm.coro.free(token, ptr nocapture readonly)
+declare i1 @llvm.coro.end(ptr, i1)
-declare i8* @new(i64)
-declare void @delete(i8*)
+declare ptr @new(i64)
+declare void @delete(ptr)
declare i1 @await_ready()
declare void @await_suspend()
declare void @await_resume()
declare void @print(i32)
-declare i8* @from_address(i8*)
+declare ptr @from_address(ptr)
declare void @return_void()
declare void @final_suspend()
diff --git a/llvm/test/Transforms/Coroutines/coro-debug-coro-frame.ll b/llvm/test/Transforms/Coroutines/coro-debug-coro-frame.ll
index 3da63b222efc4..dada825379137 100644
--- a/llvm/test/Transforms/Coroutines/coro-debug-coro-frame.ll
+++ b/llvm/test/Transforms/Coroutines/coro-debug-coro-frame.ll
@@ -1,17 +1,16 @@
-; RUN: opt -opaque-pointers=0 < %s -passes='module(coro-early),cgscc(coro-split,coro-split)' -S | FileCheck %s
+; RUN: opt < %s -passes='module(coro-early),cgscc(coro-split,coro-split)' -S | FileCheck %s
; Checks whether the dbg.declare for `__coro_frame` are created.
; CHECK-LABEL: define void @f(
; CHECK: coro.init:
-; CHECK: %[[begin:.*]] = call noalias nonnull i8* @llvm.coro.begin(
-; CHECK: call void @llvm.dbg.declare(metadata i8* %[[begin]], metadata ![[CORO_FRAME:[0-9]+]], metadata !DIExpression())
-; CHECK: %[[FramePtr:.*]] = bitcast i8* %[[begin]] to
+; CHECK: %[[begin:.*]] = call noalias nonnull ptr @llvm.coro.begin(
+; CHECK: call void @llvm.dbg.declare(metadata ptr %[[begin]], metadata ![[CORO_FRAME:[0-9]+]], metadata !DIExpression())
;
; CHECK: define internal fastcc void @f.resume(
; CHECK: entry.resume:
-; CHECK: %[[FramePtr_RESUME:.*]] = alloca %f.Frame*
-; CHECK: call void @llvm.dbg.declare(metadata %f.Frame** %[[FramePtr_RESUME]], metadata ![[CORO_FRAME_IN_RESUME:[0-9]+]], metadata !DIExpression(DW_OP_deref)
+; CHECK: %[[FramePtr_RESUME:.*]] = alloca ptr
+; CHECK: call void @llvm.dbg.declare(metadata ptr %[[FramePtr_RESUME]], metadata ![[CORO_FRAME_IN_RESUME:[0-9]+]], metadata !DIExpression(DW_OP_deref)
;
; CHECK-DAG: ![[FILE:[0-9]+]] = !DIFile(filename: "coro-debug.cpp"
; CHECK-DAG: ![[RAMP:[0-9]+]] = distinct !DISubprogram(name: "foo", linkageName: "_Z3foov",
@@ -33,8 +32,6 @@
; CHECK-DAG: ![[I64_BASE]] = !DIBasicType(name: "__int_64", size: 64, encoding: DW_ATE_signed, flags: DIFlagArtificial)
; CHECK-DAG: ![[DOUBLE_1]] = !DIDerivedType(tag: DW_TAG_member, name: "__double__2", scope: ![[FRAME_TYPE]], file: ![[FILE]], line: [[PROMISE_VAR_LINE]], baseType: ![[DOUBLE_BASE:[0-9]+]]{{.*}}, flags: DIFlagArtificial
; CHECK-DAG: ![[DOUBLE_BASE]] = !DIBasicType(name: "__double_", size: 64, encoding: DW_ATE_float, flags: DIFlagArtificial)
-; CHECK-DAG: ![[INT64_PTR]] = !DIDerivedType(tag: DW_TAG_member, name: "__int_64_Ptr_3",{{.*}} baseType: ![[INT64_PTR_BASE:[0-9]+]]
-; CHECK-DAG: ![[INT64_PTR_BASE]] = !DIDerivedType(tag: DW_TAG_pointer_type, name: "__int_64_Ptr", baseType: null, size: 64, align: 64
; CHECK-DAG: ![[INT32_2]] = !DIDerivedType(tag: DW_TAG_member, name: "__int_32_4", scope: ![[FRAME_TYPE]], file: ![[FILE]], line: [[PROMISE_VAR_LINE]], baseType: ![[I32_BASE:[0-9]+]]{{.*}}, flags: DIFlagArtificial
; CHECK-DAG: ![[I32_BASE]] = !DIBasicType(name: "__int_32", size: 32, encoding: DW_ATE_signed, flags: DIFlagArtificial)
; CHECK-DAG: ![[INT32_3]] = !DIDerivedType(tag: DW_TAG_member, name: "__int_32_5", scope: ![[FRAME_TYPE]], file: ![[FILE]], line: [[PROMISE_VAR_LINE]], baseType: ![[I32_BASE]]
@@ -58,7 +55,6 @@
; CHECK-DAG: ![[VECTOR_TYPE_IN_BAR]] = !DIDerivedType(tag: DW_TAG_member, name: "_0", scope: ![[FRAME_TYPE_IN_BAR]], file: ![[FILE]], line: [[BAR_LINE]], baseType: ![[VECTOR_TYPE_BASE]]
; CHECK-DAG: ![[INT64_IN_BAR]] = !DIDerivedType(tag: DW_TAG_member, name: "__int_64_1", scope: ![[FRAME_TYPE_IN_BAR]], file: ![[FILE]], line: [[BAR_LINE]], baseType: ![[I64_BASE]]
; CHECK-DAG: ![[DOUBLE_IN_BAR]] = !DIDerivedType(tag: DW_TAG_member, name: "__double__2", scope: ![[FRAME_TYPE_IN_BAR]], file: ![[FILE]], line: [[BAR_LINE]], baseType: ![[DOUBLE_BASE]]
-; CHECK-DAG: ![[INT64_PTR_IN_BAR]] = !DIDerivedType(tag: DW_TAG_member, name: "__int_64_Ptr_3", scope: ![[FRAME_TYPE_IN_BAR]], file: ![[FILE]], line: [[BAR_LINE]], baseType: ![[INT64_PTR_BASE]]
; CHECK-DAG: ![[INT32_IN_BAR]] = !DIDerivedType(tag: DW_TAG_member, name: "__int_32_4", scope: ![[FRAME_TYPE_IN_BAR]], file: ![[FILE]], line: [[BAR_LINE]], baseType: ![[I32_BASE]]
; CHECK-DAG: ![[STRUCT_IN_BAR]] = !DIDerivedType(tag: DW_TAG_member, name: "struct_big_structure_5", scope: ![[FRAME_TYPE_IN_BAR]], file: ![[FILE]], line: [[BAR_LINE]], baseType: ![[STRUCT_BASE_IN_BAR:[0-9]+]]
; CHECK-DAG: ![[STRUCT_BASE_IN_BAR]] = !DICompositeType(tag: DW_TAG_structure_type, name: "struct_big_structure", scope: ![[FRAME_TYPE_IN_BAR]], file: ![[FILE]], line: [[BAR_LINE]],{{.*}}, align: 64
@@ -67,60 +63,59 @@
%promise_type = type { i32, i32, double }
%struct.big_structure = type { [500 x i8] }
-declare void @produce(%struct.big_structure*)
-declare void @consume(%struct.big_structure*)
-declare void @produce_vector(<4 x i32> *)
-declare void @consume_vector(<4 x i32> *)
-declare void @produce_vectori5(<5 x i1> *)
-declare void @consume_vectori5(<5 x i1> *)
-declare void @produce_vectori9(<9 x i1> *)
-declare void @consume_vectori9(<9 x i1> *)
-declare void @pi32(i32*)
-declare void @pi64(i64*)
-declare void @pdouble(double*)
-declare void @pi64p(i64**)
-
-define void @f(i32 %a, i32 %b, i64 %c, double %d, i64* %e) presplitcoroutine !dbg !8 {
+declare void @produce(ptr)
+declare void @consume(ptr)
+declare void @produce_vector(ptr)
+declare void @consume_vector(ptr)
+declare void @produce_vectori5(ptr)
+declare void @consume_vectori5(ptr)
+declare void @produce_vectori9(ptr)
+declare void @consume_vectori9(ptr)
+declare void @pi32(ptr)
+declare void @pi64(ptr)
+declare void @pdouble(ptr)
+declare void @pi64p(ptr)
+
+define void @f(i32 %a, i32 %b, i64 %c, double %d, ptr %e) presplitcoroutine !dbg !8 {
entry:
%__promise = alloca %promise_type, align 8
- %0 = bitcast %promise_type* %__promise to i8*
%a.alloc = alloca i32, align 4
%b.alloc = alloca i32, align 4
%c.alloc = alloca i64, align 4
%d.alloc = alloca double, align 4
- %e.alloc = alloca i64*, align 4
- store i32 %a, i32* %a.alloc
- store i32 %b, i32* %b.alloc
- store i64 %c, i64* %c.alloc
- store double %d, double* %d.alloc
- store i64* %e, i64** %e.alloc
+ %e.alloc = alloca ptr, align 4
+ store i32 %a, ptr %a.alloc
+ store i32 %b, ptr %b.alloc
+ store i64 %c, ptr %c.alloc
+ store double %d, ptr %d.alloc
+ store ptr %e, ptr %e.alloc
%struct.data = alloca %struct.big_structure, align 1
- call void @produce(%struct.big_structure* %struct.data)
+ call void @produce(ptr %struct.data)
; We treat vector type as unresolved type now for test coverage.
%unresolved_data = alloca <4 x i32>
- call void @produce_vector(<4 x i32> *%unresolved_data)
+ call void @produce_vector(ptr %unresolved_data)
%unresolved_data2 = alloca <5 x i1>
- call void @produce_vectori5(<5 x i1> *%unresolved_data2)
+ call void @produce_vectori5(ptr %unresolved_data2)
%unresolved_data3 = alloca <9 x i1>
- call void @produce_vectori9(<9 x i1> *%unresolved_data3)
- %id = call token @llvm.coro.id(i32 16, i8* %0, i8* null, i8* null)
+ call void @produce_vectori9(ptr %unresolved_data3)
+ %id = call token @llvm.coro.id(i32 16, ptr %__promise, ptr null, ptr null)
%alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %alloc, label %coro.alloc, label %coro.init
coro.alloc: ; preds = %entry
%size = call i64 @llvm.coro.size.i64()
- %memory = call i8* @new(i64 %size)
+ %memory = call ptr @new(i64 %size)
br label %coro.init
coro.init: ; preds = %coro.alloc, %entry
- %phi.entry.alloc = phi i8* [ null, %entry ], [ %memory, %coro.alloc ]
- %begin = call i8* @llvm.coro.begin(token %id, i8* %phi.entry.alloc)
- call void @llvm.dbg.declare(metadata %promise_type* %__promise, metadata !6, metadata !DIExpression()), !dbg !18
+ %phi.entry.alloc = phi ptr [ null, %entry ], [ %memory, %coro.alloc ]
+ %begin = call ptr @llvm.coro.begin(token %id, ptr %phi.entry.alloc)
+ call void @llvm.dbg.declare(metadata ptr %__promise, metadata !6, metadata !DIExpression()), !dbg !18
%ready = call i1 @await_ready()
br i1 %ready, label %init.ready, label %init.suspend
init.suspend: ; preds = %coro.init
- %save = call token @llvm.coro.save(i8* null)
+ %save = call token @llvm.coro.save(ptr null)
call void @await_suspend()
%suspend = call i8 @llvm.coro.suspend(token %save, i1 false)
switch i8 %suspend, label %coro.ret [
@@ -137,8 +132,8 @@ init.ready: ; preds = %init.suspend, %coro
br i1 %ready.again, label %await.ready, label %await.suspend
await.suspend: ; preds = %init.ready
- %save.again = call token @llvm.coro.save(i8* null)
- %from.address = call i8* @from_address(i8* %begin)
+ %save.again = call token @llvm.coro.save(ptr null)
+ %from.address = call ptr @from_address(ptr %begin)
call void @await_suspend()
%suspend.again = call i8 @llvm.coro.suspend(token %save.again, i1 false)
switch i8 %suspend.again, label %coro.ret [
@@ -151,21 +146,20 @@ await.cleanup: ; preds = %await.suspend
await.ready: ; preds = %await.suspend, %init.ready
call void @await_resume()
- %i.i = getelementptr inbounds %promise_type, %promise_type* %__promise, i64 0, i32 0
- store i32 1, i32* %i.i, align 8
- %j.i = getelementptr inbounds %promise_type, %promise_type* %__promise, i64 0, i32 1
- store i32 2, i32* %j.i, align 4
- %k.i = getelementptr inbounds %promise_type, %promise_type* %__promise, i64 0, i32 2
- store double 3.000000e+00, double* %k.i, align 8
- call void @consume(%struct.big_structure* %struct.data)
- call void @consume_vector(<4 x i32> *%unresolved_data)
- call void @consume_vectori5(<5 x i1> *%unresolved_data2)
- call void @consume_vectori9(<9 x i1> *%unresolved_data3)
- call void @pi32(i32* %a.alloc)
- call void @pi32(i32* %b.alloc)
- call void @pi64(i64* %c.alloc)
- call void @pdouble(double* %d.alloc)
- call void @pi64p(i64** %e.alloc)
+ store i32 1, ptr %__promise, align 8
+ %j.i = getelementptr inbounds %promise_type, ptr %__promise, i64 0, i32 1
+ store i32 2, ptr %j.i, align 4
+ %k.i = getelementptr inbounds %promise_type, ptr %__promise, i64 0, i32 2
+ store double 3.000000e+00, ptr %k.i, align 8
+ call void @consume(ptr %struct.data)
+ call void @consume_vector(ptr %unresolved_data)
+ call void @consume_vectori5(ptr %unresolved_data2)
+ call void @consume_vectori9(ptr %unresolved_data3)
+ call void @pi32(ptr %a.alloc)
+ call void @pi32(ptr %b.alloc)
+ call void @pi64(ptr %c.alloc)
+ call void @pdouble(ptr %d.alloc)
+ call void @pi64p(ptr %e.alloc)
call void @return_void()
br label %coro.final
@@ -175,8 +169,8 @@ coro.final: ; preds = %await.ready
br i1 %coro.final.await_ready, label %final.ready, label %final.suspend
final.suspend: ; preds = %coro.final
- %final.suspend.coro.save = call token @llvm.coro.save(i8* null)
- %final.suspend.from_address = call i8* @from_address(i8* %begin)
+ %final.suspend.coro.save = call token @llvm.coro.save(ptr null)
+ %final.suspend.from_address = call ptr @from_address(ptr %begin)
call void @await_suspend()
%final.suspend.coro.suspend = call i8 @llvm.coro.suspend(token %final.suspend.coro.save, i1 true)
switch i8 %final.suspend.coro.suspend, label %coro.ret [
@@ -193,12 +187,12 @@ final.ready: ; preds = %final.suspend, %cor
cleanup: ; preds = %final.ready, %final.cleanup, %await.cleanup, %init.cleanup
%cleanup.dest.slot.0 = phi i32 [ 0, %final.ready ], [ 2, %final.cleanup ], [ 2, %await.cleanup ], [ 2, %init.cleanup ]
- %free.memory = call i8* @llvm.coro.free(token %id, i8* %begin)
- %free = icmp ne i8* %free.memory, null
+ %free.memory = call ptr @llvm.coro.free(token %id, ptr %begin)
+ %free = icmp ne ptr %free.memory, null
br i1 %free, label %coro.free, label %after.coro.free
coro.free: ; preds = %cleanup
- call void @delete(i8* %free.memory)
+ call void @delete(ptr %free.memory)
br label %after.coro.free
after.coro.free: ; preds = %coro.free, %cleanup
@@ -211,7 +205,7 @@ cleanup.cont: ; preds = %after.coro.free
br label %coro.ret
coro.ret: ; preds = %cleanup.cont, %after.coro.free, %final.suspend, %await.suspend, %init.suspend
- %end = call i1 @llvm.coro.end(i8* null, i1 false)
+ %end = call i1 @llvm.coro.end(ptr null, i1 false)
ret void
unreachable: ; preds = %after.coro.free
@@ -220,41 +214,40 @@ unreachable: ; preds = %after.coro.free
}
; bar is used to check that we wouldn't create duplicate DIType
-define void @bar(i32 %a, i64 %c, double %d, i64* %e) presplitcoroutine !dbg !19 {
+define void @bar(i32 %a, i64 %c, double %d, ptr %e) presplitcoroutine !dbg !19 {
entry:
%__promise = alloca %promise_type, align 8
- %0 = bitcast %promise_type* %__promise to i8*
%a.alloc = alloca i32, align 4
%c.alloc = alloca i64, align 4
%d.alloc = alloca double, align 4
- %e.alloc = alloca i64*, align 4
- store i32 %a, i32* %a.alloc
- store i64 %c, i64* %c.alloc
- store double %d, double* %d.alloc
- store i64* %e, i64** %e.alloc
+ %e.alloc = alloca ptr, align 4
+ store i32 %a, ptr %a.alloc
+ store i64 %c, ptr %c.alloc
+ store double %d, ptr %d.alloc
+ store ptr %e, ptr %e.alloc
%struct.data = alloca %struct.big_structure, align 1
- call void @produce(%struct.big_structure* %struct.data)
+ call void @produce(ptr %struct.data)
; We treat vector type as unresolved type now for test coverage.
%unresolved_data = alloca <4 x i32>
- call void @produce_vector(<4 x i32> *%unresolved_data)
- %id = call token @llvm.coro.id(i32 16, i8* %0, i8* null, i8* null)
+ call void @produce_vector(ptr %unresolved_data)
+ %id = call token @llvm.coro.id(i32 16, ptr %__promise, ptr null, ptr null)
%alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %alloc, label %coro.alloc, label %coro.init
coro.alloc: ; preds = %entry
%size = call i64 @llvm.coro.size.i64()
- %memory = call i8* @new(i64 %size)
+ %memory = call ptr @new(i64 %size)
br label %coro.init
coro.init: ; preds = %coro.alloc, %entry
- %phi.entry.alloc = phi i8* [ null, %entry ], [ %memory, %coro.alloc ]
- %begin = call i8* @llvm.coro.begin(token %id, i8* %phi.entry.alloc)
- call void @llvm.dbg.declare(metadata %promise_type* %__promise, metadata !21, metadata !DIExpression()), !dbg !22
+ %phi.entry.alloc = phi ptr [ null, %entry ], [ %memory, %coro.alloc ]
+ %begin = call ptr @llvm.coro.begin(token %id, ptr %phi.entry.alloc)
+ call void @llvm.dbg.declare(metadata ptr %__promise, metadata !21, metadata !DIExpression()), !dbg !22
%ready = call i1 @await_ready()
br i1 %ready, label %init.ready, label %init.suspend
init.suspend: ; preds = %coro.init
- %save = call token @llvm.coro.save(i8* null)
+ %save = call token @llvm.coro.save(ptr null)
call void @await_suspend()
%suspend = call i8 @llvm.coro.suspend(token %save, i1 false)
switch i8 %suspend, label %coro.ret [
@@ -271,8 +264,8 @@ init.ready: ; preds = %init.suspend, %coro
br i1 %ready.again, label %await.ready, label %await.suspend
await.suspend: ; preds = %init.ready
- %save.again = call token @llvm.coro.save(i8* null)
- %from.address = call i8* @from_address(i8* %begin)
+ %save.again = call token @llvm.coro.save(ptr null)
+ %from.address = call ptr @from_address(ptr %begin)
call void @await_suspend()
%suspend.again = call i8 @llvm.coro.suspend(token %save.again, i1 false)
switch i8 %suspend.again, label %coro.ret [
@@ -285,18 +278,17 @@ await.cleanup: ; preds = %await.suspend
await.ready: ; preds = %await.suspend, %init.ready
call void @await_resume()
- %i.i = getelementptr inbounds %promise_type, %promise_type* %__promise, i64 0, i32 0
- store i32 1, i32* %i.i, align 8
- %j.i = getelementptr inbounds %promise_type, %promise_type* %__promise, i64 0, i32 1
- store i32 2, i32* %j.i, align 4
- %k.i = getelementptr inbounds %promise_type, %promise_type* %__promise, i64 0, i32 2
- store double 3.000000e+00, double* %k.i, align 8
- call void @consume(%struct.big_structure* %struct.data)
- call void @consume_vector(<4 x i32> *%unresolved_data)
- call void @pi32(i32* %a.alloc)
- call void @pi64(i64* %c.alloc)
- call void @pdouble(double* %d.alloc)
- call void @pi64p(i64** %e.alloc)
+ store i32 1, ptr %__promise, align 8
+ %j.i = getelementptr inbounds %promise_type, ptr %__promise, i64 0, i32 1
+ store i32 2, ptr %j.i, align 4
+ %k.i = getelementptr inbounds %promise_type, ptr %__promise, i64 0, i32 2
+ store double 3.000000e+00, ptr %k.i, align 8
+ call void @consume(ptr %struct.data)
+ call void @consume_vector(ptr %unresolved_data)
+ call void @pi32(ptr %a.alloc)
+ call void @pi64(ptr %c.alloc)
+ call void @pdouble(ptr %d.alloc)
+ call void @pi64p(ptr %e.alloc)
call void @return_void()
br label %coro.final
@@ -306,8 +298,8 @@ coro.final: ; preds = %await.ready
br i1 %coro.final.await_ready, label %final.ready, label %final.suspend
final.suspend: ; preds = %coro.final
- %final.suspend.coro.save = call token @llvm.coro.save(i8* null)
- %final.suspend.from_address = call i8* @from_address(i8* %begin)
+ %final.suspend.coro.save = call token @llvm.coro.save(ptr null)
+ %final.suspend.from_address = call ptr @from_address(ptr %begin)
call void @await_suspend()
%final.suspend.coro.suspend = call i8 @llvm.coro.suspend(token %final.suspend.coro.save, i1 true)
switch i8 %final.suspend.coro.suspend, label %coro.ret [
@@ -324,12 +316,12 @@ final.ready: ; preds = %final.suspend, %cor
cleanup: ; preds = %final.ready, %final.cleanup, %await.cleanup, %init.cleanup
%cleanup.dest.slot.0 = phi i32 [ 0, %final.ready ], [ 2, %final.cleanup ], [ 2, %await.cleanup ], [ 2, %init.cleanup ]
- %free.memory = call i8* @llvm.coro.free(token %id, i8* %begin)
- %free = icmp ne i8* %free.memory, null
+ %free.memory = call ptr @llvm.coro.free(token %id, ptr %begin)
+ %free = icmp ne ptr %free.memory, null
br i1 %free, label %coro.free, label %after.coro.free
coro.free: ; preds = %cleanup
- call void @delete(i8* %free.memory)
+ call void @delete(ptr %free.memory)
br label %after.coro.free
after.coro.free: ; preds = %coro.free, %cleanup
@@ -342,7 +334,7 @@ cleanup.cont: ; preds = %after.coro.free
br label %coro.ret
coro.ret: ; preds = %cleanup.cont, %after.coro.free, %final.suspend, %await.suspend, %init.suspend
- %end = call i1 @llvm.coro.end(i8* null, i1 false)
+ %end = call i1 @llvm.coro.end(ptr null, i1 false)
ret void
unreachable: ; preds = %after.coro.free
@@ -351,22 +343,22 @@ unreachable: ; preds = %after.coro.free
}
declare void @llvm.dbg.declare(metadata, metadata, metadata)
-declare token @llvm.coro.id(i32, i8* readnone, i8* nocapture readonly, i8*)
+declare token @llvm.coro.id(i32, ptr readnone, ptr nocapture readonly, ptr)
declare i1 @llvm.coro.alloc(token)
declare i64 @llvm.coro.size.i64()
-declare token @llvm.coro.save(i8*)
-declare i8* @llvm.coro.begin(token, i8* writeonly)
+declare token @llvm.coro.save(ptr)
+declare ptr @llvm.coro.begin(token, ptr writeonly)
declare i8 @llvm.coro.suspend(token, i1)
-declare i8* @llvm.coro.free(token, i8* nocapture readonly)
-declare i1 @llvm.coro.end(i8*, i1)
+declare ptr @llvm.coro.free(token, ptr nocapture readonly)
+declare i1 @llvm.coro.end(ptr, i1)
-declare i8* @new(i64)
-declare void @delete(i8*)
+declare ptr @new(i64)
+declare void @delete(ptr)
declare i1 @await_ready()
declare void @await_suspend()
declare void @await_resume()
declare void @print(i32)
-declare i8* @from_address(i8*)
+declare ptr @from_address(ptr)
declare void @return_void()
declare void @final_suspend()
diff --git a/llvm/test/Transforms/Coroutines/coro-debug-dbg.values-not_used_in_frame.ll b/llvm/test/Transforms/Coroutines/coro-debug-dbg.values-not_used_in_frame.ll
index d2e82d68bb92a..d90e255d290ad 100644
--- a/llvm/test/Transforms/Coroutines/coro-debug-dbg.values-not_used_in_frame.ll
+++ b/llvm/test/Transforms/Coroutines/coro-debug-dbg.values-not_used_in_frame.ll
@@ -1,8 +1,8 @@
; Tests whether resume function would remain dbg.value infomation if corresponding values are not used in the frame.
-; RUN: opt -opaque-pointers=0 < %s -passes='module(coro-early),cgscc(coro-split,coro-split)' -S | FileCheck %s
+; RUN: opt < %s -passes='module(coro-early),cgscc(coro-split,coro-split)' -S | FileCheck %s
;
; This file is based on coro-debug-frame-variable.ll.
-; CHECK: define internal fastcc void @f.resume(%f.Frame* noundef nonnull align 16 dereferenceable(80) %FramePtr) !dbg ![[RESUME_FN_DBG_NUM:[0-9]+]]
+; CHECK: define internal fastcc void @f.resume(ptr noundef nonnull align 16 dereferenceable(80) %begin) !dbg ![[RESUME_FN_DBG_NUM:[0-9]+]]
; CHECK: await.ready:
; CHECK: call void @llvm.dbg.value(metadata i32 undef, metadata ![[IVAR_RESUME:[0-9]+]], metadata !DIExpression(
; CHECK: call void @llvm.dbg.value(metadata i32 undef, metadata ![[JVAR_RESUME:[0-9]+]], metadata !DIExpression(
@@ -17,23 +17,23 @@ define void @f(i32 %i, i32 %j) presplitcoroutine !dbg !8 {
entry:
%__promise = alloca i8, align 8
%x = alloca [10 x i32], align 16
- %id = call token @llvm.coro.id(i32 16, i8* %__promise, i8* null, i8* null)
+ %id = call token @llvm.coro.id(i32 16, ptr %__promise, ptr null, ptr null)
%alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %alloc, label %coro.alloc, label %coro.init
coro.alloc: ; preds = %entry
%size = call i64 @llvm.coro.size.i64()
- %memory = call i8* @new(i64 %size)
+ %memory = call ptr @new(i64 %size)
br label %coro.init
coro.init: ; preds = %coro.alloc, %entry
- %phi.entry.alloc = phi i8* [ null, %entry ], [ %memory, %coro.alloc ]
- %begin = call i8* @llvm.coro.begin(token %id, i8* %phi.entry.alloc)
+ %phi.entry.alloc = phi ptr [ null, %entry ], [ %memory, %coro.alloc ]
+ %begin = call ptr @llvm.coro.begin(token %id, ptr %phi.entry.alloc)
%ready = call i1 @await_ready()
br i1 %ready, label %init.ready, label %init.suspend
init.suspend: ; preds = %coro.init
- %save = call token @llvm.coro.save(i8* null)
+ %save = call token @llvm.coro.save(ptr null)
call void @await_suspend()
%suspend = call i8 @llvm.coro.suspend(token %save, i1 false)
switch i8 %suspend, label %coro.ret [
@@ -49,16 +49,15 @@ init.ready: ; preds = %init.suspend, %coro
call void @llvm.dbg.value(metadata i32 0, metadata !6, metadata !DIExpression()), !dbg !11
%i.init.ready.inc = add nsw i32 0, 1
call void @llvm.dbg.value(metadata i32 %i.init.ready.inc, metadata !6, metadata !DIExpression()), !dbg !11
- call void @llvm.dbg.declare(metadata [10 x i32]* %x, metadata !12, metadata !DIExpression()), !dbg !17
- %memset = bitcast [10 x i32]* %x to i8*, !dbg !17
- call void @llvm.memset.p0i8.i64(i8* align 16 %memset, i8 0, i64 40, i1 false), !dbg !17
+ call void @llvm.dbg.declare(metadata ptr %x, metadata !12, metadata !DIExpression()), !dbg !17
+ call void @llvm.memset.p0.i64(ptr align 16 %x, i8 0, i64 40, i1 false), !dbg !17
call void @print(i32 %i.init.ready.inc)
%ready.again = call zeroext i1 @await_ready()
br i1 %ready.again, label %await.ready, label %await.suspend
await.suspend: ; preds = %init.ready
- %save.again = call token @llvm.coro.save(i8* null)
- %from.address = call i8* @from_address(i8* %begin)
+ %save.again = call token @llvm.coro.save(ptr null)
+ %from.address = call ptr @from_address(ptr %begin)
call void @await_suspend()
%suspend.again = call i8 @llvm.coro.suspend(token %save.again, i1 false)
switch i8 %suspend.again, label %coro.ret [
@@ -72,10 +71,9 @@ await.cleanup: ; preds = %await.suspend
await.ready: ; preds = %await.suspend, %init.ready
call void @await_resume()
call void @llvm.dbg.value(metadata i32 0, metadata !18, metadata !DIExpression()), !dbg !11
- %arrayidx0 = getelementptr inbounds [10 x i32], [10 x i32]* %x, i64 0, i64 0, !dbg !19
- store i32 1, i32* %arrayidx0, align 16, !dbg !20
- %arrayidx1 = getelementptr inbounds [10 x i32], [10 x i32]* %x, i64 0, i64 1, !dbg !21
- store i32 2, i32* %arrayidx1, align 4, !dbg !22
+ store i32 1, ptr %x, align 16, !dbg !20
+ %arrayidx1 = getelementptr inbounds [10 x i32], ptr %x, i64 0, i64 1, !dbg !21
+ store i32 2, ptr %arrayidx1, align 4, !dbg !22
%i.await.ready.inc = add nsw i32 %i.init.ready.inc, 1
call void @llvm.dbg.value(metadata i32 %i, metadata !6, metadata !DIExpression()), !dbg !11
call void @llvm.dbg.value(metadata i32 %j, metadata !18, metadata !DIExpression()), !dbg !11
@@ -89,8 +87,8 @@ coro.final: ; preds = %await.ready
br i1 %coro.final.await_ready, label %final.ready, label %final.suspend
final.suspend: ; preds = %coro.final
- %final.suspend.coro.save = call token @llvm.coro.save(i8* null)
- %final.suspend.from_address = call i8* @from_address(i8* %begin)
+ %final.suspend.coro.save = call token @llvm.coro.save(ptr null)
+ %final.suspend.from_address = call ptr @from_address(ptr %begin)
call void @await_suspend()
%final.suspend.coro.suspend = call i8 @llvm.coro.suspend(token %final.suspend.coro.save, i1 true)
switch i8 %final.suspend.coro.suspend, label %coro.ret [
@@ -107,12 +105,12 @@ final.ready: ; preds = %final.suspend, %cor
cleanup: ; preds = %final.ready, %final.cleanup, %await.cleanup, %init.cleanup
%cleanup.dest.slot.0 = phi i32 [ 0, %final.ready ], [ 2, %final.cleanup ], [ 2, %await.cleanup ], [ 2, %init.cleanup ]
- %free.memory = call i8* @llvm.coro.free(token %id, i8* %begin)
- %free = icmp ne i8* %free.memory, null
+ %free.memory = call ptr @llvm.coro.free(token %id, ptr %begin)
+ %free = icmp ne ptr %free.memory, null
br i1 %free, label %coro.free, label %after.coro.free
coro.free: ; preds = %cleanup
- call void @delete(i8* %free.memory)
+ call void @delete(ptr %free.memory)
br label %after.coro.free
after.coro.free: ; preds = %coro.free, %cleanup
@@ -125,7 +123,7 @@ cleanup.cont: ; preds = %after.coro.free
br label %coro.ret
coro.ret: ; preds = %cleanup.cont, %after.coro.free, %final.suspend, %await.suspend, %init.suspend
- %end = call i1 @llvm.coro.end(i8* null, i1 false)
+ %end = call i1 @llvm.coro.end(ptr null, i1 false)
ret void
unreachable: ; preds = %after.coro.free
@@ -136,7 +134,7 @@ unreachable: ; preds = %after.coro.free
declare void @llvm.dbg.declare(metadata, metadata, metadata) #0
; Function Attrs: argmemonly nounwind readonly
-declare token @llvm.coro.id(i32, i8* readnone, i8* nocapture readonly, i8*) #1
+declare token @llvm.coro.id(i32, ptr readnone, ptr nocapture readonly, ptr) #1
; Function Attrs: nounwind
declare i1 @llvm.coro.alloc(token) #2
@@ -145,23 +143,23 @@ declare i1 @llvm.coro.alloc(token) #2
declare i64 @llvm.coro.size.i64() #3
; Function Attrs: nounwind
-declare token @llvm.coro.save(i8*) #2
+declare token @llvm.coro.save(ptr) #2
; Function Attrs: nounwind
-declare i8* @llvm.coro.begin(token, i8* writeonly) #2
+declare ptr @llvm.coro.begin(token, ptr writeonly) #2
; Function Attrs: nounwind
declare i8 @llvm.coro.suspend(token, i1) #2
; Function Attrs: argmemonly nounwind readonly
-declare i8* @llvm.coro.free(token, i8* nocapture readonly) #1
+declare ptr @llvm.coro.free(token, ptr nocapture readonly) #1
; Function Attrs: nounwind
-declare i1 @llvm.coro.end(i8*, i1) #2
+declare i1 @llvm.coro.end(ptr, i1) #2
-declare i8* @new(i64)
+declare ptr @new(i64)
-declare void @delete(i8*)
+declare void @delete(ptr)
declare i1 @await_ready()
@@ -171,14 +169,14 @@ declare void @await_resume()
declare void @print(i32)
-declare i8* @from_address(i8*)
+declare ptr @from_address(ptr)
declare void @return_void()
declare void @final_suspend()
; Function Attrs: argmemonly nofree nosync nounwind willreturn writeonly
-declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i1 immarg) #4
+declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i1 immarg) #4
; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
declare void @llvm.dbg.value(metadata, metadata, metadata) #0
diff --git a/llvm/test/Transforms/Coroutines/coro-debug-dbg.values.ll b/llvm/test/Transforms/Coroutines/coro-debug-dbg.values.ll
index 5c01c71bf790d..1d0233c0617fa 100644
--- a/llvm/test/Transforms/Coroutines/coro-debug-dbg.values.ll
+++ b/llvm/test/Transforms/Coroutines/coro-debug-dbg.values.ll
@@ -1,14 +1,14 @@
; Tests whether resume function would remain dbg.value infomation.
-; RUN: opt -opaque-pointers=0 < %s -passes='module(coro-early),cgscc(coro-split,coro-split)' -S | FileCheck %s
+; RUN: opt < %s -passes='module(coro-early),cgscc(coro-split,coro-split)' -S | FileCheck %s
;
; This file is based on coro-debug-frame-variable.ll.
-; CHECK: define internal fastcc void @f.resume(%f.Frame* noundef nonnull align 16 dereferenceable(80) %FramePtr) !dbg ![[RESUME_FN_DBG_NUM:[0-9]+]]
+; CHECK: define internal fastcc void @f.resume(ptr noundef nonnull align 16 dereferenceable(80) %begin) !dbg ![[RESUME_FN_DBG_NUM:[0-9]+]]
; CHECK: init.ready:
-; CHECK: call void @llvm.dbg.value(metadata %f.Frame** %FramePtr.debug, metadata ![[XVAR_RESUME:[0-9]+]],
+; CHECK: call void @llvm.dbg.value(metadata ptr %begin.debug, metadata ![[XVAR_RESUME:[0-9]+]],
; CHECK: await.ready:
-; CHECK: call void @llvm.dbg.value(metadata %f.Frame** %FramePtr.debug, metadata ![[SPILL_RESUME:[0-9]+]]
-; CHECK: call void @llvm.dbg.value(metadata %f.Frame** %FramePtr.debug, metadata ![[IVAR_RESUME:[0-9]+]], metadata !DIExpression(
-; CHECK: call void @llvm.dbg.value(metadata %f.Frame** %FramePtr.debug, metadata ![[JVAR_RESUME:[0-9]+]], metadata !DIExpression(
+; CHECK: call void @llvm.dbg.value(metadata ptr %begin.debug, metadata ![[SPILL_RESUME:[0-9]+]]
+; CHECK: call void @llvm.dbg.value(metadata ptr %begin.debug, metadata ![[IVAR_RESUME:[0-9]+]], metadata !DIExpression(
+; CHECK: call void @llvm.dbg.value(metadata ptr %begin.debug, metadata ![[JVAR_RESUME:[0-9]+]], metadata !DIExpression(
;
; CHECK: ![[RESUME_FN_DBG_NUM]] = distinct !DISubprogram(name: "foo", linkageName: "_Z3foov"
; CHECK: ![[IVAR_RESUME]] = !DILocalVariable(name: "i"
@@ -24,23 +24,23 @@ entry:
%__promise = alloca i8, align 8
%x = alloca [10 x i32], align 16
%produced = call i32 @value_producer()
- %id = call token @llvm.coro.id(i32 16, i8* %__promise, i8* null, i8* null)
+ %id = call token @llvm.coro.id(i32 16, ptr %__promise, ptr null, ptr null)
%alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %alloc, label %coro.alloc, label %coro.init
coro.alloc: ; preds = %entry
%size = call i64 @llvm.coro.size.i64()
- %memory = call i8* @new(i64 %size)
+ %memory = call ptr @new(i64 %size)
br label %coro.init
coro.init: ; preds = %coro.alloc, %entry
- %phi.entry.alloc = phi i8* [ null, %entry ], [ %memory, %coro.alloc ]
- %begin = call i8* @llvm.coro.begin(token %id, i8* %phi.entry.alloc)
+ %phi.entry.alloc = phi ptr [ null, %entry ], [ %memory, %coro.alloc ]
+ %begin = call ptr @llvm.coro.begin(token %id, ptr %phi.entry.alloc)
%ready = call i1 @await_ready()
br i1 %ready, label %init.ready, label %init.suspend
init.suspend: ; preds = %coro.init
- %save = call token @llvm.coro.save(i8* null)
+ %save = call token @llvm.coro.save(ptr null)
call void @await_suspend()
%suspend = call i8 @llvm.coro.suspend(token %save, i1 false)
switch i8 %suspend, label %coro.ret [
@@ -56,16 +56,15 @@ init.ready: ; preds = %init.suspend, %coro
call void @llvm.dbg.value(metadata i32 0, metadata !6, metadata !DIExpression()), !dbg !11
%i.init.ready.inc = add nsw i32 0, 1
call void @llvm.dbg.value(metadata i32 %i.init.ready.inc, metadata !6, metadata !DIExpression()), !dbg !11
- call void @llvm.dbg.value(metadata [10 x i32]* %x, metadata !12, metadata !DIExpression()), !dbg !17
- %memset = bitcast [10 x i32]* %x to i8*, !dbg !17
- call void @llvm.memset.p0i8.i64(i8* align 16 %memset, i8 0, i64 40, i1 false), !dbg !17
+ call void @llvm.dbg.value(metadata ptr %x, metadata !12, metadata !DIExpression()), !dbg !17
+ call void @llvm.memset.p0.i64(ptr align 16 %x, i8 0, i64 40, i1 false), !dbg !17
call void @print(i32 %i.init.ready.inc)
%ready.again = call zeroext i1 @await_ready()
br i1 %ready.again, label %await.ready, label %await.suspend
await.suspend: ; preds = %init.ready
- %save.again = call token @llvm.coro.save(i8* null)
- %from.address = call i8* @from_address(i8* %begin)
+ %save.again = call token @llvm.coro.save(ptr null)
+ %from.address = call ptr @from_address(ptr %begin)
call void @await_suspend()
%suspend.again = call i8 @llvm.coro.suspend(token %save.again, i1 false)
switch i8 %suspend.again, label %coro.ret [
@@ -79,10 +78,9 @@ await.cleanup: ; preds = %await.suspend
await.ready: ; preds = %await.suspend, %init.ready
call void @await_resume()
call void @llvm.dbg.value(metadata i32 0, metadata !18, metadata !DIExpression()), !dbg !11
- %arrayidx0 = getelementptr inbounds [10 x i32], [10 x i32]* %x, i64 0, i64 0, !dbg !19
- store i32 1, i32* %arrayidx0, align 16, !dbg !20
- %arrayidx1 = getelementptr inbounds [10 x i32], [10 x i32]* %x, i64 0, i64 1, !dbg !21
- store i32 2, i32* %arrayidx1, align 4, !dbg !22
+ store i32 1, ptr %x, align 16, !dbg !20
+ %arrayidx1 = getelementptr inbounds [10 x i32], ptr %x, i64 0, i64 1, !dbg !21
+ store i32 2, ptr %arrayidx1, align 4, !dbg !22
%i.await.ready.inc = add nsw i32 %i.init.ready.inc, 1
call void @consume(i32 %produced)
call void @consume(i32 %i)
@@ -100,8 +98,8 @@ coro.final: ; preds = %await.ready
br i1 %coro.final.await_ready, label %final.ready, label %final.suspend
final.suspend: ; preds = %coro.final
- %final.suspend.coro.save = call token @llvm.coro.save(i8* null)
- %final.suspend.from_address = call i8* @from_address(i8* %begin)
+ %final.suspend.coro.save = call token @llvm.coro.save(ptr null)
+ %final.suspend.from_address = call ptr @from_address(ptr %begin)
call void @await_suspend()
%final.suspend.coro.suspend = call i8 @llvm.coro.suspend(token %final.suspend.coro.save, i1 true)
switch i8 %final.suspend.coro.suspend, label %coro.ret [
@@ -118,12 +116,12 @@ final.ready: ; preds = %final.suspend, %cor
cleanup: ; preds = %final.ready, %final.cleanup, %await.cleanup, %init.cleanup
%cleanup.dest.slot.0 = phi i32 [ 0, %final.ready ], [ 2, %final.cleanup ], [ 2, %await.cleanup ], [ 2, %init.cleanup ]
- %free.memory = call i8* @llvm.coro.free(token %id, i8* %begin)
- %free = icmp ne i8* %free.memory, null
+ %free.memory = call ptr @llvm.coro.free(token %id, ptr %begin)
+ %free = icmp ne ptr %free.memory, null
br i1 %free, label %coro.free, label %after.coro.free
coro.free: ; preds = %cleanup
- call void @delete(i8* %free.memory)
+ call void @delete(ptr %free.memory)
br label %after.coro.free
after.coro.free: ; preds = %coro.free, %cleanup
@@ -136,7 +134,7 @@ cleanup.cont: ; preds = %after.coro.free
br label %coro.ret
coro.ret: ; preds = %cleanup.cont, %after.coro.free, %final.suspend, %await.suspend, %init.suspend
- %end = call i1 @llvm.coro.end(i8* null, i1 false)
+ %end = call i1 @llvm.coro.end(ptr null, i1 false)
ret void
unreachable: ; preds = %after.coro.free
@@ -147,7 +145,7 @@ unreachable: ; preds = %after.coro.free
declare void @llvm.dbg.declare(metadata, metadata, metadata) #0
; Function Attrs: argmemonly nounwind readonly
-declare token @llvm.coro.id(i32, i8* readnone, i8* nocapture readonly, i8*) #1
+declare token @llvm.coro.id(i32, ptr readnone, ptr nocapture readonly, ptr) #1
; Function Attrs: nounwind
declare i1 @llvm.coro.alloc(token) #2
@@ -156,23 +154,23 @@ declare i1 @llvm.coro.alloc(token) #2
declare i64 @llvm.coro.size.i64() #3
; Function Attrs: nounwind
-declare token @llvm.coro.save(i8*) #2
+declare token @llvm.coro.save(ptr) #2
; Function Attrs: nounwind
-declare i8* @llvm.coro.begin(token, i8* writeonly) #2
+declare ptr @llvm.coro.begin(token, ptr writeonly) #2
; Function Attrs: nounwind
declare i8 @llvm.coro.suspend(token, i1) #2
; Function Attrs: argmemonly nounwind readonly
-declare i8* @llvm.coro.free(token, i8* nocapture readonly) #1
+declare ptr @llvm.coro.free(token, ptr nocapture readonly) #1
; Function Attrs: nounwind
-declare i1 @llvm.coro.end(i8*, i1) #2
+declare i1 @llvm.coro.end(ptr, i1) #2
-declare i8* @new(i64)
+declare ptr @new(i64)
-declare void @delete(i8*)
+declare void @delete(ptr)
declare i1 @await_ready()
@@ -182,7 +180,7 @@ declare void @await_resume()
declare void @print(i32)
-declare i8* @from_address(i8*)
+declare ptr @from_address(ptr)
declare void @return_void()
@@ -191,7 +189,7 @@ declare void @final_suspend()
declare i32 @value_producer()
; Function Attrs: argmemonly nofree nosync nounwind willreturn writeonly
-declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i1 immarg) #4
+declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i1 immarg) #4
; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
declare void @llvm.dbg.value(metadata, metadata, metadata) #0
diff --git a/llvm/test/Transforms/Coroutines/coro-debug-frame-variable.ll b/llvm/test/Transforms/Coroutines/coro-debug-frame-variable.ll
index eb7fafc810bf4..7d9aa879fc5cb 100644
--- a/llvm/test/Transforms/Coroutines/coro-debug-frame-variable.ll
+++ b/llvm/test/Transforms/Coroutines/coro-debug-frame-variable.ll
@@ -1,4 +1,4 @@
-; RUN: opt -opaque-pointers=0 < %s -passes='default<O0>' -S | FileCheck %s
+; RUN: opt < %s -passes='default<O0>' -S | FileCheck %s
; Define a function 'f' that resembles the Clang frontend's output for the
; following C++ coroutine:
@@ -30,20 +30,20 @@
; CHECK-LABEL: define void @f() {{.*}} {
; CHECK: entry:
; CHECK: %j = alloca i32, align 4
-; CHECK: call void @llvm.dbg.declare(metadata i32* %j, metadata ![[JVAR:[0-9]+]], metadata !DIExpression()), !dbg ![[JDBGLOC:[0-9]+]]
-; CHECK: %[[MEMORY:.*]] = call i8* @new
-; CHECK: call void @llvm.dbg.declare(metadata i8* %[[MEMORY]], metadata ![[XVAR:[0-9]+]], metadata !DIExpression(DW_OP_plus_uconst, 32)), !dbg ![[IDBGLOC:[0-9]+]]
-; CHECK: call void @llvm.dbg.declare(metadata i8* %[[MEMORY]], metadata ![[IVAR:[0-9]+]], metadata !DIExpression(DW_OP_plus_uconst, 20)), !dbg ![[IDBGLOC]]
+; CHECK: call void @llvm.dbg.declare(metadata ptr %j, metadata ![[JVAR:[0-9]+]], metadata !DIExpression()), !dbg ![[JDBGLOC:[0-9]+]]
+; CHECK: %[[MEMORY:.*]] = call ptr @new
+; CHECK: call void @llvm.dbg.declare(metadata ptr %[[MEMORY]], metadata ![[XVAR:[0-9]+]], metadata !DIExpression(DW_OP_plus_uconst, 32)), !dbg ![[IDBGLOC:[0-9]+]]
+; CHECK: call void @llvm.dbg.declare(metadata ptr %[[MEMORY]], metadata ![[IVAR:[0-9]+]], metadata !DIExpression(DW_OP_plus_uconst, 20)), !dbg ![[IDBGLOC]]
; CHECK: await.ready:
;
; CHECK-LABEL: define internal fastcc void @f.resume({{.*}}) {{.*}} {
; CHECK: entry.resume:
-; CHECK-NEXT: %[[DBG_PTR:.*]] = alloca %f.Frame*
-; CHECK-NEXT: call void @llvm.dbg.declare(metadata %f.Frame** %[[DBG_PTR]], metadata ![[XVAR_RESUME:[0-9]+]], metadata !DIExpression(DW_OP_deref, DW_OP_plus_uconst, 32)), !dbg
-; CHECK-NEXT: call void @llvm.dbg.declare(metadata %f.Frame** %[[DBG_PTR]], metadata ![[IVAR_RESUME:[0-9]+]], metadata !DIExpression(DW_OP_deref, DW_OP_plus_uconst, 20)), !dbg ![[IDBGLOC_RESUME:[0-9]+]]
-; CHECK-NEXT: store %f.Frame* {{.*}}, %f.Frame** %[[DBG_PTR]]
+; CHECK-NEXT: %[[DBG_PTR:.*]] = alloca ptr
+; CHECK-NEXT: call void @llvm.dbg.declare(metadata ptr %[[DBG_PTR]], metadata ![[XVAR_RESUME:[0-9]+]], metadata !DIExpression(DW_OP_deref, DW_OP_plus_uconst, 32)), !dbg
+; CHECK-NEXT: call void @llvm.dbg.declare(metadata ptr %[[DBG_PTR]], metadata ![[IVAR_RESUME:[0-9]+]], metadata !DIExpression(DW_OP_deref, DW_OP_plus_uconst, 20)), !dbg ![[IDBGLOC_RESUME:[0-9]+]]
+; CHECK-NEXT: store ptr {{.*}}, ptr %[[DBG_PTR]]
; CHECK: %[[J:.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @llvm.dbg.declare(metadata i32* %[[J]], metadata ![[JVAR_RESUME:[0-9]+]], metadata !DIExpression()), !dbg ![[JDBGLOC_RESUME:[0-9]+]]
+; CHECK-NEXT: call void @llvm.dbg.declare(metadata ptr %[[J]], metadata ![[JVAR_RESUME:[0-9]+]], metadata !DIExpression()), !dbg ![[JDBGLOC_RESUME:[0-9]+]]
; CHECK: init.ready:
; CHECK: await.ready:
;
@@ -56,7 +56,7 @@
; CHECK-DAG: ![[XVAR_RESUME]] = !DILocalVariable(name: "x"
; CHECK-DAG: ![[IDBGLOC_RESUME]] = !DILocation(line: 24, column: 7, scope: ![[RESUME_SCOPE:[0-9]+]])
-; CHECK-DAG: ![[RESUME_SCOPE]] = distinct !DILexicalBlock(scope: !23, file: !1, line: 23, column: 12)
+; CHECK-DAG: ![[RESUME_SCOPE]] = distinct !DILexicalBlock(scope: !22, file: !1, line: 23, column: 12)
; CHECK-DAG: ![[IVAR_RESUME]] = !DILocalVariable(name: "i"
; CHECK-DAG: ![[JVAR_RESUME]] = !DILocalVariable(name: "j"
; CHECK-DAG: ![[JDBGLOC_RESUME]] = !DILocation(line: 32, column: 7, scope: ![[RESUME_SCOPE]])
@@ -66,23 +66,23 @@ entry:
%i = alloca i32, align 4
%j = alloca i32, align 4
%x = alloca [10 x i32], align 16
- %id = call token @llvm.coro.id(i32 16, i8* %__promise, i8* null, i8* null)
+ %id = call token @llvm.coro.id(i32 16, ptr %__promise, ptr null, ptr null)
%alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %alloc, label %coro.alloc, label %coro.init
coro.alloc: ; preds = %entry
%size = call i64 @llvm.coro.size.i64()
- %memory = call i8* @new(i64 %size)
+ %memory = call ptr @new(i64 %size)
br label %coro.init
coro.init: ; preds = %coro.alloc, %entry
- %phi.entry.alloc = phi i8* [ null, %entry ], [ %memory, %coro.alloc ]
- %begin = call i8* @llvm.coro.begin(token %id, i8* %phi.entry.alloc)
+ %phi.entry.alloc = phi ptr [ null, %entry ], [ %memory, %coro.alloc ]
+ %begin = call ptr @llvm.coro.begin(token %id, ptr %phi.entry.alloc)
%ready = call i1 @await_ready()
br i1 %ready, label %init.ready, label %init.suspend
init.suspend: ; preds = %coro.init
- %save = call token @llvm.coro.save(i8* null)
+ %save = call token @llvm.coro.save(ptr null)
call void @await_suspend()
%suspend = call i8 @llvm.coro.suspend(token %save, i1 false)
switch i8 %suspend, label %coro.ret [
@@ -95,22 +95,21 @@ init.cleanup: ; preds = %init.suspend
init.ready: ; preds = %init.suspend, %coro.init
call void @await_resume()
- call void @llvm.dbg.declare(metadata i32* %i, metadata !6, metadata !DIExpression()), !dbg !11
- store i32 0, i32* %i, align 4
- %i.init.ready.load = load i32, i32* %i, align 4
+ call void @llvm.dbg.declare(metadata ptr %i, metadata !6, metadata !DIExpression()), !dbg !11
+ store i32 0, ptr %i, align 4
+ %i.init.ready.load = load i32, ptr %i, align 4
%i.init.ready.inc = add nsw i32 %i.init.ready.load, 1
- store i32 %i.init.ready.inc, i32* %i, align 4
- call void @llvm.dbg.declare(metadata [10 x i32]* %x, metadata !14, metadata !DIExpression()), !dbg !11
- %memset = bitcast [10 x i32]* %x to i8*, !dbg !11
- call void @llvm.memset.p0i8.i64(i8* align 16 %memset, i8 0, i64 40, i1 false), !dbg !11
- %i.init.ready.reload = load i32, i32* %i, align 4
+ store i32 %i.init.ready.inc, ptr %i, align 4
+ call void @llvm.dbg.declare(metadata ptr %x, metadata !14, metadata !DIExpression()), !dbg !11
+ call void @llvm.memset.p0.i64(ptr align 16 %x, i8 0, i64 40, i1 false), !dbg !11
+ %i.init.ready.reload = load i32, ptr %i, align 4
call void @print(i32 %i.init.ready.reload)
%ready.again = call zeroext i1 @await_ready()
br i1 %ready.again, label %await.ready, label %await.suspend
await.suspend: ; preds = %init.ready
- %save.again = call token @llvm.coro.save(i8* null)
- %from.address = call i8* @from_address(i8* %begin)
+ %save.again = call token @llvm.coro.save(ptr null)
+ %from.address = call ptr @from_address(ptr %begin)
call void @await_suspend()
%suspend.again = call i8 @llvm.coro.suspend(token %save.again, i1 false)
switch i8 %suspend.again, label %coro.ret [
@@ -123,21 +122,20 @@ await.cleanup: ; preds = %await.suspend
await.ready: ; preds = %await.suspend, %init.ready
call void @await_resume()
- call void @llvm.dbg.declare(metadata i32* %j, metadata !12, metadata !DIExpression()), !dbg !13
- store i32 0, i32* %j, align 4
- %arrayidx0 = getelementptr inbounds [10 x i32], [10 x i32]* %x, i64 0, i64 0, !dbg !18
- store i32 1, i32* %arrayidx0, align 16, !dbg !19
- %arrayidx1 = getelementptr inbounds [10 x i32], [10 x i32]* %x, i64 0, i64 1, !dbg !20
- store i32 2, i32* %arrayidx1, align 4, !dbg !21
- %i.await.ready.load = load i32, i32* %i, align 4
+ call void @llvm.dbg.declare(metadata ptr %j, metadata !12, metadata !DIExpression()), !dbg !13
+ store i32 0, ptr %j, align 4
+ store i32 1, ptr %x, align 16, !dbg !19
+ %arrayidx1 = getelementptr inbounds [10 x i32], ptr %x, i64 0, i64 1, !dbg !20
+ store i32 2, ptr %arrayidx1, align 4, !dbg !21
+ %i.await.ready.load = load i32, ptr %i, align 4
%i.await.ready.inc = add nsw i32 %i.await.ready.load, 1
- store i32 %i.await.ready.inc, i32* %i, align 4
- %j.await.ready.load = load i32, i32* %j, align 4
+ store i32 %i.await.ready.inc, ptr %i, align 4
+ %j.await.ready.load = load i32, ptr %j, align 4
%j.await.ready.inc = add nsw i32 %j.await.ready.load, 1
- store i32 %j.await.ready.inc, i32* %j, align 4
- %i.await.ready.reload = load i32, i32* %i, align 4
+ store i32 %j.await.ready.inc, ptr %j, align 4
+ %i.await.ready.reload = load i32, ptr %i, align 4
call void @print(i32 %i.await.ready.reload)
- %j.await.ready.reload = load i32, i32* %j, align 4
+ %j.await.ready.reload = load i32, ptr %j, align 4
call void @print(i32 %j.await.ready.reload)
call void @return_void()
br label %coro.final
@@ -148,8 +146,8 @@ coro.final: ; preds = %await.ready
br i1 %coro.final.await_ready, label %final.ready, label %final.suspend
final.suspend: ; preds = %coro.final
- %final.suspend.coro.save = call token @llvm.coro.save(i8* null)
- %final.suspend.from_address = call i8* @from_address(i8* %begin)
+ %final.suspend.coro.save = call token @llvm.coro.save(ptr null)
+ %final.suspend.from_address = call ptr @from_address(ptr %begin)
call void @await_suspend()
%final.suspend.coro.suspend = call i8 @llvm.coro.suspend(token %final.suspend.coro.save, i1 true)
switch i8 %final.suspend.coro.suspend, label %coro.ret [
@@ -166,12 +164,12 @@ final.ready: ; preds = %final.suspend, %cor
cleanup: ; preds = %final.ready, %final.cleanup, %await.cleanup, %init.cleanup
%cleanup.dest.slot.0 = phi i32 [ 0, %final.ready ], [ 2, %final.cleanup ], [ 2, %await.cleanup ], [ 2, %init.cleanup ]
- %free.memory = call i8* @llvm.coro.free(token %id, i8* %begin)
- %free = icmp ne i8* %free.memory, null
+ %free.memory = call ptr @llvm.coro.free(token %id, ptr %begin)
+ %free = icmp ne ptr %free.memory, null
br i1 %free, label %coro.free, label %after.coro.free
coro.free: ; preds = %cleanup
- call void @delete(i8* %free.memory)
+ call void @delete(ptr %free.memory)
br label %after.coro.free
after.coro.free: ; preds = %coro.free, %cleanup
@@ -184,7 +182,7 @@ cleanup.cont: ; preds = %after.coro.free
br label %coro.ret
coro.ret: ; preds = %cleanup.cont, %after.coro.free, %final.suspend, %await.suspend, %init.suspend
- %end = call i1 @llvm.coro.end(i8* null, i1 false)
+ %end = call i1 @llvm.coro.end(ptr null, i1 false)
ret void
unreachable: ; preds = %after.coro.free
@@ -192,26 +190,26 @@ unreachable: ; preds = %after.coro.free
}
declare void @llvm.dbg.declare(metadata, metadata, metadata)
-declare token @llvm.coro.id(i32, i8* readnone, i8* nocapture readonly, i8*)
+declare token @llvm.coro.id(i32, ptr readnone, ptr nocapture readonly, ptr)
declare i1 @llvm.coro.alloc(token)
declare i64 @llvm.coro.size.i64()
-declare token @llvm.coro.save(i8*)
-declare i8* @llvm.coro.begin(token, i8* writeonly)
+declare token @llvm.coro.save(ptr)
+declare ptr @llvm.coro.begin(token, ptr writeonly)
declare i8 @llvm.coro.suspend(token, i1)
-declare i8* @llvm.coro.free(token, i8* nocapture readonly)
-declare i1 @llvm.coro.end(i8*, i1)
+declare ptr @llvm.coro.free(token, ptr nocapture readonly)
+declare i1 @llvm.coro.end(ptr, i1)
-declare i8* @new(i64)
-declare void @delete(i8*)
+declare ptr @new(i64)
+declare void @delete(ptr)
declare i1 @await_ready()
declare void @await_suspend()
declare void @await_resume()
declare void @print(i32)
-declare i8* @from_address(i8*)
+declare ptr @from_address(ptr)
declare void @return_void()
declare void @final_suspend()
-declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i1 immarg)
+declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i1 immarg)
!llvm.dbg.cu = !{!0}
!llvm.linker.options = !{}
diff --git a/llvm/test/Transforms/Coroutines/coro-debug.ll b/llvm/test/Transforms/Coroutines/coro-debug.ll
index 282969484be1a..dec20ab7a0744 100644
--- a/llvm/test/Transforms/Coroutines/coro-debug.ll
+++ b/llvm/test/Transforms/Coroutines/coro-debug.ll
@@ -1,45 +1,44 @@
; Tests that debug information is sane after coro-split
-; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
source_filename = "simple-repro.c"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"
; Function Attrs: noinline nounwind
-define i8* @f(i32 %x) #0 personality i32 0 !dbg !6 {
+define ptr @f(i32 %x) #0 personality i32 0 !dbg !6 {
entry:
%x.addr = alloca i32, align 4
- %coro_hdl = alloca i8*, align 8
- store i32 %x, i32* %x.addr, align 4
- %0 = call token @llvm.coro.id(i32 0, i8* null, i8* bitcast (i8* (i32)* @f to i8*), i8* null), !dbg !16
- %undef = bitcast i8* undef to [16 x i8]*
+ %coro_hdl = alloca ptr, align 8
+ store i32 %x, ptr %x.addr, align 4
+ %0 = call token @llvm.coro.id(i32 0, ptr null, ptr @f, ptr null), !dbg !16
%1 = call i64 @llvm.coro.size.i64(), !dbg !16
- %call = call i8* @malloc(i64 %1), !dbg !16
- %2 = call i8* @llvm.coro.begin(token %0, i8* %call) #7, !dbg !16
- store i8* %2, i8** %coro_hdl, align 8, !dbg !16
+ %call = call ptr @malloc(i64 %1), !dbg !16
+ %2 = call ptr @llvm.coro.begin(token %0, ptr %call) #7, !dbg !16
+ store ptr %2, ptr %coro_hdl, align 8, !dbg !16
%3 = call i8 @llvm.coro.suspend(token none, i1 false), !dbg !17
%conv = sext i8 %3 to i32, !dbg !17
%late_local = alloca i32, align 4
- call void @coro.devirt.trigger(i8* null)
+ call void @coro.devirt.trigger(ptr null)
switch i32 %conv, label %sw.default [
i32 0, label %sw.bb
i32 1, label %sw.bb1
], !dbg !17
sw.bb: ; preds = %entry
- %direct = load i32, i32* %x.addr, align 4, !dbg !14
- %gep = getelementptr inbounds [16 x i8], [16 x i8]* %undef, i32 %direct, !dbg !14
- call void @llvm.dbg.declare(metadata [16 x i8] *%gep, metadata !27, metadata !13), !dbg !14
+ %direct = load i32, ptr %x.addr, align 4, !dbg !14
+ %gep = getelementptr inbounds [16 x i8], ptr undef, i32 %direct, !dbg !14
+ call void @llvm.dbg.declare(metadata ptr %gep, metadata !27, metadata !13), !dbg !14
call void @llvm.dbg.declare(metadata i32 %conv, metadata !26, metadata !13), !dbg !14
call void @llvm.dbg.declare(metadata i32 %direct, metadata !25, metadata !13), !dbg !14
- call void @llvm.dbg.declare(metadata i32* %x.addr, metadata !12, metadata !13), !dbg !14
- call void @llvm.dbg.declare(metadata i8** %coro_hdl, metadata !15, metadata !13), !dbg !16
- call void @llvm.dbg.declare(metadata i32* %late_local, metadata !29, metadata !13), !dbg !16
+ call void @llvm.dbg.declare(metadata ptr %x.addr, metadata !12, metadata !13), !dbg !14
+ call void @llvm.dbg.declare(metadata ptr %coro_hdl, metadata !15, metadata !13), !dbg !16
+ call void @llvm.dbg.declare(metadata ptr %late_local, metadata !29, metadata !13), !dbg !16
call void @llvm.dbg.value(metadata i32 %direct, metadata !30, metadata !13), !dbg !14
; don't crash when encountering nonsensical debug info, verfifier doesn't yet reject these
- call void @llvm.dbg.declare(metadata i8* null, metadata !28, metadata !13), !dbg !16
+ call void @llvm.dbg.declare(metadata ptr null, metadata !28, metadata !13), !dbg !16
call void @llvm.dbg.declare(metadata !{}, metadata !28, metadata !13), !dbg !16
- %new_storgae = invoke i8* @allocate()
+ %new_storgae = invoke ptr @allocate()
to label %next unwind label %ehcleanup, !dbg !18
next:
@@ -52,10 +51,10 @@ sw.default: ; preds = %entry
br label %coro_Suspend, !dbg !18
sw.epilog: ; preds = %sw.bb
- call void @llvm.dbg.declare(metadata i8* %new_storgae, metadata !31, metadata !13), !dbg !16
- %4 = load i32, i32* %x.addr, align 4, !dbg !20
+ call void @llvm.dbg.declare(metadata ptr %new_storgae, metadata !31, metadata !13), !dbg !16
+ %4 = load i32, ptr %x.addr, align 4, !dbg !20
%add = add nsw i32 %4, 1, !dbg !21
- store i32 %add, i32* %x.addr, align 4, !dbg !22
+ store i32 %add, ptr %x.addr, align 4, !dbg !22
%asm_res = callbr i32 asm "", "=r,r,!i"(i32 %x)
to label %coro_Cleanup [label %indirect.dest]
@@ -64,22 +63,22 @@ indirect.dest:
br label %coro_Cleanup
coro_Cleanup: ; preds = %sw.epilog, %sw.bb1
- %5 = load i8*, i8** %coro_hdl, align 8, !dbg !24
- %6 = call i8* @llvm.coro.free(token %0, i8* %5), !dbg !24
- call void @free(i8* %6), !dbg !24
+ %5 = load ptr, ptr %coro_hdl, align 8, !dbg !24
+ %6 = call ptr @llvm.coro.free(token %0, ptr %5), !dbg !24
+ call void @free(ptr %6), !dbg !24
call void @llvm.dbg.declare(metadata i32 %asm_res, metadata !32, metadata !13), !dbg !16
br label %coro_Suspend, !dbg !24
coro_Suspend: ; preds = %coro_Cleanup, %sw.default
- %7 = call i1 @llvm.coro.end(i8* null, i1 false) #7, !dbg !24
- %8 = load i8*, i8** %coro_hdl, align 8, !dbg !24
- store i32 0, i32* %late_local, !dbg !24
- ret i8* %8, !dbg !24
+ %7 = call i1 @llvm.coro.end(ptr null, i1 false) #7, !dbg !24
+ %8 = load ptr, ptr %coro_hdl, align 8, !dbg !24
+ store i32 0, ptr %late_local, !dbg !24
+ ret ptr %8, !dbg !24
ehcleanup:
- %ex = landingpad { i8*, i32 }
- catch i8* null
- call void @print({ i8*, i32 } %ex)
+ %ex = landingpad { ptr, i32 }
+ catch ptr null
+ call void @print({ ptr, i32 } %ex)
unreachable
}
@@ -90,38 +89,38 @@ declare void @llvm.dbg.value(metadata, metadata, metadata) #1
declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
; Function Attrs: argmemonly nounwind readonly
-declare token @llvm.coro.id(i32, i8* readnone, i8* nocapture readonly, i8*) #2
+declare token @llvm.coro.id(i32, ptr readnone, ptr nocapture readonly, ptr) #2
-declare i8* @malloc(i64) #3
-declare i8* @allocate()
-declare void @print({ i8*, i32 })
+declare ptr @malloc(i64) #3
+declare ptr @allocate()
+declare void @print({ ptr, i32 })
declare void @log()
; Function Attrs: nounwind readnone
declare i64 @llvm.coro.size.i64() #4
; Function Attrs: nounwind
-declare i8* @llvm.coro.begin(token, i8* writeonly) #5
+declare ptr @llvm.coro.begin(token, ptr writeonly) #5
; Function Attrs: nounwind
declare i8 @llvm.coro.suspend(token, i1) #5
-declare void @free(i8*) #3
+declare void @free(ptr) #3
; Function Attrs: argmemonly nounwind readonly
-declare i8* @llvm.coro.free(token, i8* nocapture readonly) #2
+declare ptr @llvm.coro.free(token, ptr nocapture readonly) #2
; Function Attrs: nounwind
-declare i1 @llvm.coro.end(i8*, i1) #5
+declare i1 @llvm.coro.end(ptr, i1) #5
; Function Attrs: alwaysinline
-define private void @coro.devirt.trigger(i8*) #6 {
+define private void @coro.devirt.trigger(ptr) #6 {
entry:
ret void
}
; Function Attrs: argmemonly nounwind readonly
-declare i8* @llvm.coro.subfn.addr(i8* nocapture readonly, i8) #2
+declare ptr @llvm.coro.subfn.addr(ptr nocapture readonly, i8) #2
attributes #0 = { noinline nounwind presplitcoroutine "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="none" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-features"="+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { nounwind readnone speculatable }
@@ -171,32 +170,32 @@ attributes #7 = { noduplicate }
!31 = !DILocalVariable(name: "allocated", scope: !6, file: !7, line: 55, type: !11)
!32 = !DILocalVariable(name: "inline_asm", scope: !6, file: !7, line: 55, type: !11)
-; CHECK: define i8* @f(i32 %x) #0 personality i32 0 !dbg ![[ORIG:[0-9]+]]
-; CHECK: define internal fastcc void @f.resume(%f.Frame* noundef nonnull align 8 dereferenceable(40) %FramePtr) #0 personality i32 0 !dbg ![[RESUME:[0-9]+]]
+; CHECK: define ptr @f(i32 %x) #0 personality i32 0 !dbg ![[ORIG:[0-9]+]]
+; CHECK: define internal fastcc void @f.resume(ptr noundef nonnull align 8 dereferenceable(40) %0) #0 personality i32 0 !dbg ![[RESUME:[0-9]+]]
; CHECK: entry.resume:
-; CHECK: %[[DBG_PTR:.*]] = alloca %f.Frame*
-; CHECK: call void @llvm.dbg.declare(metadata %f.Frame** %[[DBG_PTR]], metadata ![[RESUME_COROHDL:[0-9]+]], metadata !DIExpression(DW_OP_deref, DW_OP_plus_uconst,
-; CHECK: call void @llvm.dbg.declare(metadata %f.Frame** %[[DBG_PTR]], metadata ![[RESUME_X:[0-9]+]], metadata !DIExpression(DW_OP_deref, DW_OP_plus_uconst, [[EXPR_TAIL:.*]])
-; CHECK: call void @llvm.dbg.declare(metadata %f.Frame** %[[DBG_PTR]], metadata ![[RESUME_DIRECT:[0-9]+]], metadata !DIExpression(DW_OP_deref, DW_OP_plus_uconst, [[EXPR_TAIL]])
-; CHECK: store %f.Frame* {{.*}}, %f.Frame** %[[DBG_PTR]]
-; CHECK-NOT: alloca %struct.test*
+; CHECK: %[[DBG_PTR:.*]] = alloca ptr
+; CHECK: call void @llvm.dbg.declare(metadata ptr %[[DBG_PTR]], metadata ![[RESUME_COROHDL:[0-9]+]], metadata !DIExpression(DW_OP_deref, DW_OP_plus_uconst,
+; CHECK: call void @llvm.dbg.declare(metadata ptr %[[DBG_PTR]], metadata ![[RESUME_X:[0-9]+]], metadata !DIExpression(DW_OP_deref, DW_OP_plus_uconst, [[EXPR_TAIL:.*]])
+; CHECK: call void @llvm.dbg.declare(metadata ptr %[[DBG_PTR]], metadata ![[RESUME_DIRECT:[0-9]+]], metadata !DIExpression(DW_OP_deref, DW_OP_plus_uconst, [[EXPR_TAIL]])
+; CHECK: store ptr {{.*}}, ptr %[[DBG_PTR]]
+; CHECK-NOT: alloca ptr
; CHECK: call void @llvm.dbg.declare(metadata i8 0, metadata ![[RESUME_CONST:[0-9]+]], metadata !DIExpression(DW_OP_LLVM_convert, 8, DW_ATE_signed, DW_OP_LLVM_convert, 32, DW_ATE_signed))
; Note that keeping the undef value here could be acceptable, too.
-; CHECK-NOT: call void @llvm.dbg.declare(metadata i32* undef, metadata !{{[0-9]+}}, metadata !DIExpression())
-; CHECK: call void @coro.devirt.trigger(i8* null)
-; CHECK: call void @llvm.dbg.value(metadata %f.Frame** {{.*}}, metadata ![[RESUME_DIRECT_VALUE:[0-9]+]], metadata !DIExpression(DW_OP_deref, DW_OP_plus_uconst, {{[0-9]+}}, DW_OP_deref))
+; CHECK-NOT: call void @llvm.dbg.declare(metadata ptr undef, metadata !{{[0-9]+}}, metadata !DIExpression())
+; CHECK: call void @coro.devirt.trigger(ptr null)
+; CHECK: call void @llvm.dbg.value(metadata ptr {{.*}}, metadata ![[RESUME_DIRECT_VALUE:[0-9]+]], metadata !DIExpression(DW_OP_deref, DW_OP_plus_uconst, {{[0-9]+}}, DW_OP_deref))
; Check that the dbg.declare intrinsic of invoke instruction is hanled correctly.
-; CHECK: %[[ALLOCATED_STORAGE:.+]] = invoke i8* @allocate()
+; CHECK: %[[ALLOCATED_STORAGE:.+]] = invoke ptr @allocate()
; CHECK-NEXT: to label %[[NORMAL_DEST:.+]] unwind
; CHECK: [[NORMAL_DEST]]
-; CHECK-NEXT: call void @llvm.dbg.declare(metadata i8* %[[ALLOCATED_STORAGE]]
+; CHECK-NEXT: call void @llvm.dbg.declare(metadata ptr %[[ALLOCATED_STORAGE]]
; CHECK: %[[CALLBR_RES:.+]] = callbr i32 asm
; CHECK-NEXT: to label %[[DEFAULT_DEST:.+]] [label
; CHECK: [[DEFAULT_DEST]]:
; CHECK-NOT: {{.*}}:
; CHECK: call void @llvm.dbg.declare(metadata i32 %[[CALLBR_RES]]
-; CHECK: define internal fastcc void @f.destroy(%f.Frame* noundef nonnull align 8 dereferenceable(40) %FramePtr) #0 personality i32 0 !dbg ![[DESTROY:[0-9]+]]
-; CHECK: define internal fastcc void @f.cleanup(%f.Frame* noundef nonnull align 8 dereferenceable(40) %FramePtr) #0 personality i32 0 !dbg ![[CLEANUP:[0-9]+]]
+; CHECK: define internal fastcc void @f.destroy(ptr noundef nonnull align 8 dereferenceable(40) %0) #0 personality i32 0 !dbg ![[DESTROY:[0-9]+]]
+; CHECK: define internal fastcc void @f.cleanup(ptr noundef nonnull align 8 dereferenceable(40) %0) #0 personality i32 0 !dbg ![[CLEANUP:[0-9]+]]
; CHECK: ![[ORIG]] = distinct !DISubprogram(name: "f", linkageName: "flink"
diff --git a/llvm/test/Transforms/Coroutines/coro-eh-aware-edge-split-00.ll b/llvm/test/Transforms/Coroutines/coro-eh-aware-edge-split-00.ll
index 889c2712f7b08..e30b3fa55536c 100644
--- a/llvm/test/Transforms/Coroutines/coro-eh-aware-edge-split-00.ll
+++ b/llvm/test/Transforms/Coroutines/coro-eh-aware-edge-split-00.ll
@@ -1,5 +1,5 @@
; Check that we can handle edge splits leading into a landingpad
-; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"
@@ -7,10 +7,10 @@ target triple = "x86_64-unknown-linux-gnu"
; CHECK-LABEL: define internal fastcc void @f.resume(
define void @f(i1 %cond) presplitcoroutine personality i32 0 {
entry:
- %id = call token @llvm.coro.id(i32 16, i8* null, i8* null, i8* null)
+ %id = call token @llvm.coro.id(i32 16, ptr null, ptr null, ptr null)
%size = tail call i64 @llvm.coro.size.i64()
- %alloc = call i8* @malloc(i64 %size)
- %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
+ %alloc = call ptr @malloc(i64 %size)
+ %hdl = call ptr @llvm.coro.begin(token %id, ptr %alloc)
%sp = call i8 @llvm.coro.suspend(token none, i1 false)
switch i8 %sp, label %coro.ret [
i8 0, label %resume
@@ -30,42 +30,42 @@ invoke2:
; Verify that we cloned landing pad on every edge and inserted a reload of the spilled value
; CHECK: pad.with.phi.from.invoke2:
-; CHECK: %0 = landingpad { i8*, i32 }
-; CHECK: catch i8* null
+; CHECK: %0 = landingpad { ptr, i32 }
+; CHECK: catch ptr null
; CHECK: br label %pad.with.phi
; CHECK: pad.with.phi.from.invoke1:
-; CHECK: %1 = landingpad { i8*, i32 }
-; CHECK: catch i8* null
+; CHECK: %1 = landingpad { ptr, i32 }
+; CHECK: catch ptr null
; CHECK: br label %pad.with.phi
; CHECK: pad.with.phi:
; CHECK: %val = phi i32 [ 0, %pad.with.phi.from.invoke1 ], [ 1, %pad.with.phi.from.invoke2 ]
-; CHECK: %lp = phi { i8*, i32 } [ %0, %pad.with.phi.from.invoke2 ], [ %1, %pad.with.phi.from.invoke1 ]
-; CHECK: %exn = extractvalue { i8*, i32 } %lp, 0
-; CHECK: call i8* @__cxa_begin_catch(i8* %exn)
+; CHECK: %lp = phi { ptr, i32 } [ %0, %pad.with.phi.from.invoke2 ], [ %1, %pad.with.phi.from.invoke1 ]
+; CHECK: %exn = extractvalue { ptr, i32 } %lp, 0
+; CHECK: call ptr @__cxa_begin_catch(ptr %exn)
; CHECK: call void @use_val(i32 %val)
; CHECK: call void @__cxa_end_catch()
-; CHECK: call void @free(i8* %vFrame)
+; CHECK: call void @free(ptr %hdl)
; CHECK: ret void
pad.with.phi:
%val = phi i32 [ 0, %invoke1 ], [ 1, %invoke2 ]
- %lp = landingpad { i8*, i32 }
- catch i8* null
- %exn = extractvalue { i8*, i32 } %lp, 0
- call i8* @__cxa_begin_catch(i8* %exn)
+ %lp = landingpad { ptr, i32 }
+ catch ptr null
+ %exn = extractvalue { ptr, i32 } %lp, 0
+ call ptr @__cxa_begin_catch(ptr %exn)
call void @use_val(i32 %val)
call void @__cxa_end_catch()
br label %cleanup
cleanup: ; preds = %invoke.cont15, %if.else, %if.then, %ehcleanup21, %init.suspend
- %mem = call i8* @llvm.coro.free(token %id, i8* %hdl)
- call void @free(i8* %mem)
+ %mem = call ptr @llvm.coro.free(token %id, ptr %hdl)
+ call void @free(ptr %mem)
br label %coro.ret
coro.ret:
- call i1 @llvm.coro.end(i8* null, i1 false)
+ call i1 @llvm.coro.end(ptr null, i1 false)
ret void
unreach:
@@ -73,25 +73,25 @@ unreach:
}
; Function Attrs: argmemonly nounwind readonly
-declare token @llvm.coro.id(i32, i8* readnone, i8* nocapture readonly, i8*)
-declare noalias i8* @malloc(i64)
+declare token @llvm.coro.id(i32, ptr readnone, ptr nocapture readonly, ptr)
+declare noalias ptr @malloc(i64)
declare i64 @llvm.coro.size.i64()
-declare i8* @llvm.coro.begin(token, i8* writeonly)
+declare ptr @llvm.coro.begin(token, ptr writeonly)
; Function Attrs: nounwind
-declare token @llvm.coro.save(i8*)
+declare token @llvm.coro.save(ptr)
declare i8 @llvm.coro.suspend(token, i1)
; Function Attrs: argmemonly nounwind
declare void @may_throw1()
declare void @may_throw2()
-declare i8* @__cxa_begin_catch(i8*)
+declare ptr @__cxa_begin_catch(ptr)
declare void @use_val(i32)
declare void @__cxa_end_catch()
; Function Attrs: nounwind
-declare i1 @llvm.coro.end(i8*, i1)
-declare void @free(i8*)
-declare i8* @llvm.coro.free(token, i8* nocapture readonly)
+declare i1 @llvm.coro.end(ptr, i1)
+declare void @free(ptr)
+declare ptr @llvm.coro.free(token, ptr nocapture readonly)
diff --git a/llvm/test/Transforms/Coroutines/coro-eh-aware-edge-split-01.ll b/llvm/test/Transforms/Coroutines/coro-eh-aware-edge-split-01.ll
index a7d9c075ba910..3959229959f43 100644
--- a/llvm/test/Transforms/Coroutines/coro-eh-aware-edge-split-01.ll
+++ b/llvm/test/Transforms/Coroutines/coro-eh-aware-edge-split-01.ll
@@ -1,5 +1,5 @@
; Check that we can handle edge splits leading into a landingpad
-; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"
@@ -7,10 +7,10 @@ target triple = "x86_64-unknown-linux-gnu"
; CHECK-LABEL: define internal fastcc void @g.resume(
define void @g(i1 %cond, i32 %x, i32 %y) presplitcoroutine personality i32 0 {
entry:
- %id = call token @llvm.coro.id(i32 16, i8* null, i8* null, i8* null)
+ %id = call token @llvm.coro.id(i32 16, ptr null, ptr null, ptr null)
%size = tail call i64 @llvm.coro.size.i64()
- %alloc = call i8* @malloc(i64 %size)
- %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
+ %alloc = call ptr @malloc(i64 %size)
+ %hdl = call ptr @llvm.coro.begin(token %id, ptr %alloc)
%sp = call i8 @llvm.coro.suspend(token none, i1 false)
switch i8 %sp, label %coro.ret [
i8 0, label %resume
@@ -31,14 +31,14 @@ invoke2:
; CHECK: pad.with.phi.from.invoke2:
; CHECK: %0 = cleanuppad within none []
-; CHECK: %y.reload.addr = getelementptr inbounds %g.Frame, %g.Frame* %FramePtr, i32 0, i32 3
-; CHECK: %y.reload = load i32, i32* %y.reload.addr
+; CHECK: %y.reload.addr = getelementptr inbounds %g.Frame, ptr %hdl, i32 0, i32 3
+; CHECK: %y.reload = load i32, ptr %y.reload.addr
; CHECK: cleanupret from %0 unwind label %pad.with.phi
; CHECK: pad.with.phi.from.invoke1:
; CHECK: %1 = cleanuppad within none []
-; CHECK: %x.reload.addr = getelementptr inbounds %g.Frame, %g.Frame* %FramePtr, i32 0, i32 2
-; CHECK: %x.reload = load i32, i32* %x.reload.addr
+; CHECK: %x.reload.addr = getelementptr inbounds %g.Frame, ptr %hdl, i32 0, i32 2
+; CHECK: %x.reload = load i32, ptr %x.reload.addr
; CHECK: cleanupret from %1 unwind label %pad.with.phi
; CHECK: pad.with.phi:
@@ -54,12 +54,12 @@ pad.with.phi:
cleanupret from %tok unwind to caller
cleanup: ; preds = %invoke.cont15, %if.else, %if.then, %ehcleanup21, %init.suspend
- %mem = call i8* @llvm.coro.free(token %id, i8* %hdl)
- call void @free(i8* %mem)
+ %mem = call ptr @llvm.coro.free(token %id, ptr %hdl)
+ call void @free(ptr %mem)
br label %coro.ret
coro.ret:
- call i1 @llvm.coro.end(i8* null, i1 false)
+ call i1 @llvm.coro.end(ptr null, i1 false)
ret void
unreach:
@@ -67,25 +67,25 @@ unreach:
}
; Function Attrs: argmemonly nounwind readonly
-declare token @llvm.coro.id(i32, i8* readnone, i8* nocapture readonly, i8*)
-declare noalias i8* @malloc(i64)
+declare token @llvm.coro.id(i32, ptr readnone, ptr nocapture readonly, ptr)
+declare noalias ptr @malloc(i64)
declare i64 @llvm.coro.size.i64()
-declare i8* @llvm.coro.begin(token, i8* writeonly)
+declare ptr @llvm.coro.begin(token, ptr writeonly)
; Function Attrs: nounwind
-declare token @llvm.coro.save(i8*)
+declare token @llvm.coro.save(ptr)
declare i8 @llvm.coro.suspend(token, i1)
; Function Attrs: argmemonly nounwind
declare void @may_throw1()
declare void @may_throw2()
-declare i8* @__cxa_begin_catch(i8*)
+declare ptr @__cxa_begin_catch(ptr)
declare void @use_val(i32)
declare void @__cxa_end_catch()
; Function Attrs: nounwind
-declare i1 @llvm.coro.end(i8*, i1)
-declare void @free(i8*)
-declare i8* @llvm.coro.free(token, i8* nocapture readonly)
+declare i1 @llvm.coro.end(ptr, i1)
+declare void @free(ptr)
+declare ptr @llvm.coro.free(token, ptr nocapture readonly)
diff --git a/llvm/test/Transforms/Coroutines/coro-eh-aware-edge-split-02.ll b/llvm/test/Transforms/Coroutines/coro-eh-aware-edge-split-02.ll
index cae241e064080..95a73bec09dec 100644
--- a/llvm/test/Transforms/Coroutines/coro-eh-aware-edge-split-02.ll
+++ b/llvm/test/Transforms/Coroutines/coro-eh-aware-edge-split-02.ll
@@ -1,5 +1,5 @@
; Check that we can handle edge splits leading into a landingpad
-; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"
@@ -7,10 +7,10 @@ target triple = "x86_64-unknown-linux-gnu"
; CHECK-LABEL: define internal fastcc void @h.resume(
define void @h(i1 %cond, i32 %x, i32 %y) presplitcoroutine personality i32 0 {
entry:
- %id = call token @llvm.coro.id(i32 16, i8* null, i8* null, i8* null)
+ %id = call token @llvm.coro.id(i32 16, ptr null, ptr null, ptr null)
%size = tail call i64 @llvm.coro.size.i64()
- %alloc = call i8* @malloc(i64 %size)
- %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
+ %alloc = call ptr @malloc(i64 %size)
+ %hdl = call ptr @llvm.coro.begin(token %id, ptr %alloc)
%sp = call i8 @llvm.coro.suspend(token none, i1 false)
switch i8 %sp, label %coro.ret [
i8 0, label %resume
@@ -31,14 +31,14 @@ invoke2:
; CHECK: pad.with.phi.from.invoke2:
; CHECK: %0 = cleanuppad within none []
-; CHECK: %y.reload.addr = getelementptr inbounds %h.Frame, %h.Frame* %FramePtr, i32 0, i32 3
-; CHECK: %y.reload = load i32, i32* %y.reload.addr
+; CHECK: %y.reload.addr = getelementptr inbounds %h.Frame, ptr %hdl, i32 0, i32 3
+; CHECK: %y.reload = load i32, ptr %y.reload.addr
; CHECK: cleanupret from %0 unwind label %pad.with.phi
; CHECK: pad.with.phi.from.invoke1:
; CHECK: %1 = cleanuppad within none []
-; CHECK: %x.reload.addr = getelementptr inbounds %h.Frame, %h.Frame* %FramePtr, i32 0, i32 2
-; CHECK: %x.reload = load i32, i32* %x.reload.addr
+; CHECK: %x.reload.addr = getelementptr inbounds %h.Frame, ptr %hdl, i32 0, i32 2
+; CHECK: %x.reload = load i32, ptr %x.reload.addr
; CHECK: cleanupret from %1 unwind label %pad.with.phi
; CHECK: pad.with.phi:
@@ -49,40 +49,40 @@ pad.with.phi:
%switch = catchswitch within none [label %catch] unwind to caller
catch: ; preds = %catch.dispatch
- %pad = catchpad within %switch [i8* null, i32 64, i8* null]
+ %pad = catchpad within %switch [ptr null, i32 64, ptr null]
call void @use_val(i32 %val)
catchret from %pad to label %coro.ret
cleanup: ; preds = %invoke.cont15, %if.else, %if.then, %ehcleanup21, %init.suspend
- %mem = call i8* @llvm.coro.free(token %id, i8* %hdl)
- call void @free(i8* %mem)
+ %mem = call ptr @llvm.coro.free(token %id, ptr %hdl)
+ call void @free(ptr %mem)
br label %coro.ret
coro.ret:
- call i1 @llvm.coro.end(i8* null, i1 false)
+ call i1 @llvm.coro.end(ptr null, i1 false)
ret void
}
; Function Attrs: argmemonly nounwind readonly
-declare token @llvm.coro.id(i32, i8* readnone, i8* nocapture readonly, i8*)
-declare noalias i8* @malloc(i64)
+declare token @llvm.coro.id(i32, ptr readnone, ptr nocapture readonly, ptr)
+declare noalias ptr @malloc(i64)
declare i64 @llvm.coro.size.i64()
-declare i8* @llvm.coro.begin(token, i8* writeonly)
+declare ptr @llvm.coro.begin(token, ptr writeonly)
; Function Attrs: nounwind
-declare token @llvm.coro.save(i8*)
+declare token @llvm.coro.save(ptr)
declare i8 @llvm.coro.suspend(token, i1)
; Function Attrs: argmemonly nounwind
declare void @may_throw1()
declare void @may_throw2()
-declare i8* @__cxa_begin_catch(i8*)
+declare ptr @__cxa_begin_catch(ptr)
declare void @use_val(i32)
declare void @__cxa_end_catch()
; Function Attrs: nounwind
-declare i1 @llvm.coro.end(i8*, i1)
-declare void @free(i8*)
-declare i8* @llvm.coro.free(token, i8* nocapture readonly)
+declare i1 @llvm.coro.end(ptr, i1)
+declare void @free(ptr)
+declare ptr @llvm.coro.free(token, ptr nocapture readonly)
diff --git a/llvm/test/Transforms/Coroutines/coro-frame-arrayalloca.ll b/llvm/test/Transforms/Coroutines/coro-frame-arrayalloca.ll
index 075f97dbd9947..7d1a3f2e6ef80 100644
--- a/llvm/test/Transforms/Coroutines/coro-frame-arrayalloca.ll
+++ b/llvm/test/Transforms/Coroutines/coro-frame-arrayalloca.ll
@@ -1,72 +1,72 @@
; Check that we can handle spills of array allocas
-; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
-declare void @consume.double.ptr(double*)
-declare void @consume.i32.ptr(i32*)
+declare void @consume.double.ptr(ptr)
+declare void @consume.i32.ptr(ptr)
-define i8* @f() presplitcoroutine {
+define ptr @f() presplitcoroutine {
entry:
%prefix = alloca double
%data = alloca i32, i32 4
%suffix = alloca double
- %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
+ %id = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
%size = call i32 @llvm.coro.size.i32()
- %alloc = call i8* @malloc(i32 %size)
- %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
- call void @consume.double.ptr(double* %prefix)
- call void @consume.i32.ptr(i32* %data)
- call void @consume.double.ptr(double* %suffix)
+ %alloc = call ptr @malloc(i32 %size)
+ %hdl = call ptr @llvm.coro.begin(token %id, ptr %alloc)
+ call void @consume.double.ptr(ptr %prefix)
+ call void @consume.i32.ptr(ptr %data)
+ call void @consume.double.ptr(ptr %suffix)
%0 = call i8 @llvm.coro.suspend(token none, i1 false)
switch i8 %0, label %suspend [i8 0, label %resume
i8 1, label %cleanup]
resume:
- call void @consume.double.ptr(double* %prefix)
- call void @consume.i32.ptr(i32* %data)
- call void @consume.double.ptr(double* %suffix)
+ call void @consume.double.ptr(ptr %prefix)
+ call void @consume.i32.ptr(ptr %data)
+ call void @consume.double.ptr(ptr %suffix)
br label %cleanup
cleanup:
- %mem = call i8* @llvm.coro.free(token %id, i8* %hdl)
- call void @free(i8* %mem)
+ %mem = call ptr @llvm.coro.free(token %id, ptr %hdl)
+ call void @free(ptr %mem)
br label %suspend
suspend:
- call i1 @llvm.coro.end(i8* %hdl, i1 0)
- ret i8* %hdl
+ call i1 @llvm.coro.end(ptr %hdl, i1 0)
+ ret ptr %hdl
}
; See if the array alloca was stored as an array field.
-; CHECK-LABEL: %f.Frame = type { void (%f.Frame*)*, void (%f.Frame*)*, double, double, [4 x i32], i1 }
+; CHECK-LABEL: %f.Frame = type { ptr, ptr, double, double, [4 x i32], i1 }
; See if we used correct index to access prefix, data, suffix (@f)
; CHECK-LABEL: @f(
-; CHECK: %[[PREFIX:.+]] = getelementptr inbounds %f.Frame, %f.Frame* %FramePtr, i32 0, i32 2
-; CHECK-NEXT: %[[DATA:.+]] = getelementptr inbounds %f.Frame, %f.Frame* %FramePtr, i32 0, i32 4
-; CHECK-NEXT: %[[SUFFIX:.+]] = getelementptr inbounds %f.Frame, %f.Frame* %FramePtr, i32 0, i32 3
-; CHECK-NEXT: call void @consume.double.ptr(double* %[[PREFIX:.+]])
-; CHECK-NEXT: call void @consume.i32.ptr(i32* %[[DATA:.+]])
-; CHECK-NEXT: call void @consume.double.ptr(double* %[[SUFFIX:.+]])
-; CHECK: ret i8*
+; CHECK: %[[PREFIX:.+]] = getelementptr inbounds %f.Frame, ptr %hdl, i32 0, i32 2
+; CHECK-NEXT: %[[DATA:.+]] = getelementptr inbounds %f.Frame, ptr %hdl, i32 0, i32 4
+; CHECK-NEXT: %[[SUFFIX:.+]] = getelementptr inbounds %f.Frame, ptr %hdl, i32 0, i32 3
+; CHECK-NEXT: call void @consume.double.ptr(ptr %[[PREFIX:.+]])
+; CHECK-NEXT: call void @consume.i32.ptr(ptr %[[DATA:.+]])
+; CHECK-NEXT: call void @consume.double.ptr(ptr %[[SUFFIX:.+]])
+; CHECK: ret ptr
; See if we used correct index to access prefix, data, suffix (@f.resume)
; CHECK-LABEL: @f.resume(
-; CHECK: %[[PREFIX:.+]] = getelementptr inbounds %f.Frame, %f.Frame* %FramePtr, i32 0, i32 2
-; CHECK: %[[DATA:.+]] = getelementptr inbounds %f.Frame, %f.Frame* %FramePtr, i32 0, i32 4
-; CHECK: %[[SUFFIX:.+]] = getelementptr inbounds %f.Frame, %f.Frame* %FramePtr, i32 0, i32 3
-; CHECK: call void @consume.double.ptr(double* %[[PREFIX]])
-; CHECK-NEXT: call void @consume.i32.ptr(i32* %[[DATA]])
-; CHECK-NEXT: call void @consume.double.ptr(double* %[[SUFFIX]])
+; CHECK: %[[PREFIX:.+]] = getelementptr inbounds %f.Frame, ptr %hdl, i32 0, i32 2
+; CHECK: %[[DATA:.+]] = getelementptr inbounds %f.Frame, ptr %hdl, i32 0, i32 4
+; CHECK: %[[SUFFIX:.+]] = getelementptr inbounds %f.Frame, ptr %hdl, i32 0, i32 3
+; CHECK: call void @consume.double.ptr(ptr %[[PREFIX]])
+; CHECK-NEXT: call void @consume.i32.ptr(ptr %[[DATA]])
+; CHECK-NEXT: call void @consume.double.ptr(ptr %[[SUFFIX]])
-declare i8* @llvm.coro.free(token, i8*)
+declare ptr @llvm.coro.free(token, ptr)
declare i32 @llvm.coro.size.i32()
declare i8 @llvm.coro.suspend(token, i1)
-declare void @llvm.coro.resume(i8*)
-declare void @llvm.coro.destroy(i8*)
+declare void @llvm.coro.resume(ptr)
+declare void @llvm.coro.destroy(ptr)
-declare token @llvm.coro.id(i32, i8*, i8*, i8*)
+declare token @llvm.coro.id(i32, ptr, ptr, ptr)
declare i1 @llvm.coro.alloc(token)
-declare i8* @llvm.coro.begin(token, i8*)
-declare i1 @llvm.coro.end(i8*, i1)
+declare ptr @llvm.coro.begin(token, ptr)
+declare i1 @llvm.coro.end(ptr, i1)
-declare noalias i8* @malloc(i32)
+declare noalias ptr @malloc(i32)
declare double @print(double)
-declare void @free(i8*)
+declare void @free(ptr)
diff --git a/llvm/test/Transforms/Coroutines/coro-frame-reuse-alloca-02.ll b/llvm/test/Transforms/Coroutines/coro-frame-reuse-alloca-02.ll
index 828d22dfdd0b7..923a93ca1694b 100644
--- a/llvm/test/Transforms/Coroutines/coro-frame-reuse-alloca-02.ll
+++ b/llvm/test/Transforms/Coroutines/coro-frame-reuse-alloca-02.ll
@@ -1,13 +1,13 @@
; Tests that variables of
diff erent type in a Corotuine whose lifetime range is not overlapping each other
; re-use the same slot in Coroutine frame.
-; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split<reuse-storage>),simplifycfg,early-cse' -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(coro-split<reuse-storage>),simplifycfg,early-cse' -S | FileCheck %s
%"struct.task::promise_type" = type { i8 }
%struct.awaitable = type { i8 }
%struct.big_structure = type { [500 x i8] }
%struct.big_structure.2 = type { [300 x i8] }
-declare i8* @malloc(i64)
-declare void @consume(%struct.big_structure*)
-declare void @consume.2(%struct.big_structure.2*)
+declare ptr @malloc(i64)
+declare void @consume(ptr)
+declare void @consume.2(ptr)
define void @a(i1 zeroext %cond) presplitcoroutine {
entry:
%__promise = alloca %"struct.task::promise_type", align 1
@@ -15,65 +15,60 @@ entry:
%ref.tmp7 = alloca %struct.awaitable, align 1
%b = alloca %struct.big_structure.2, align 1
%ref.tmp18 = alloca %struct.awaitable, align 1
- %0 = getelementptr inbounds %"struct.task::promise_type", %"struct.task::promise_type"* %__promise, i64 0, i32 0
- %1 = call token @llvm.coro.id(i32 16, i8* nonnull %0, i8* bitcast (void (i1)* @a to i8*), i8* null)
+ %0 = call token @llvm.coro.id(i32 16, ptr nonnull %__promise, ptr @a, ptr null)
br label %init.ready
init.ready:
- %2 = call noalias nonnull i8* @llvm.coro.begin(token %1, i8* null)
- call void @llvm.lifetime.start.p0i8(i64 1, i8* nonnull %0)
+ %1 = call noalias nonnull ptr @llvm.coro.begin(token %0, ptr null)
+ call void @llvm.lifetime.start.p0(i64 1, ptr nonnull %__promise)
br i1 %cond, label %if.then, label %if.else
if.then:
- %3 = getelementptr inbounds %struct.big_structure, %struct.big_structure* %a, i64 0, i32 0, i64 0
- call void @llvm.lifetime.start.p0i8(i64 500, i8* nonnull %3)
- call void @consume(%struct.big_structure* nonnull %a)
- %save = call token @llvm.coro.save(i8* null)
+ call void @llvm.lifetime.start.p0(i64 500, ptr nonnull %a)
+ call void @consume(ptr nonnull %a)
+ %save = call token @llvm.coro.save(ptr null)
%suspend = call i8 @llvm.coro.suspend(token %save, i1 false)
switch i8 %suspend, label %coro.ret [
i8 0, label %await.ready
i8 1, label %cleanup1
]
await.ready:
- call void @llvm.lifetime.end.p0i8(i64 500, i8* nonnull %3)
+ call void @llvm.lifetime.end.p0(i64 500, ptr nonnull %a)
br label %cleanup1
if.else:
- %4 = getelementptr inbounds %struct.big_structure.2, %struct.big_structure.2* %b, i64 0, i32 0, i64 0
- call void @llvm.lifetime.start.p0i8(i64 300, i8* nonnull %4)
- call void @consume.2(%struct.big_structure.2* nonnull %b)
- %save2 = call token @llvm.coro.save(i8* null)
+ call void @llvm.lifetime.start.p0(i64 300, ptr nonnull %b)
+ call void @consume.2(ptr nonnull %b)
+ %save2 = call token @llvm.coro.save(ptr null)
%suspend2 = call i8 @llvm.coro.suspend(token %save2, i1 false)
switch i8 %suspend2, label %coro.ret [
i8 0, label %await2.ready
i8 1, label %cleanup2
]
await2.ready:
- call void @llvm.lifetime.end.p0i8(i64 300, i8* nonnull %4)
+ call void @llvm.lifetime.end.p0(i64 300, ptr nonnull %b)
br label %cleanup2
cleanup1:
- call void @llvm.lifetime.end.p0i8(i64 500, i8* nonnull %3)
+ call void @llvm.lifetime.end.p0(i64 500, ptr nonnull %a)
br label %cleanup
cleanup2:
- call void @llvm.lifetime.end.p0i8(i64 300, i8* nonnull %4)
+ call void @llvm.lifetime.end.p0(i64 300, ptr nonnull %b)
br label %cleanup
cleanup:
- call i8* @llvm.coro.free(token %1, i8* %2)
+ call ptr @llvm.coro.free(token %0, ptr %1)
br label %coro.ret
coro.ret:
- call i1 @llvm.coro.end(i8* null, i1 false)
+ call i1 @llvm.coro.end(ptr null, i1 false)
ret void
}
-; CHECK: %a.Frame = type { void (%a.Frame*)*, void (%a.Frame*)*, %"struct.task::promise_type", %struct.big_structure, i1 }
+; CHECK: %a.Frame = type { ptr, ptr, %"struct.task::promise_type", %struct.big_structure, i1 }
; CHECK-LABEL: @a.resume(
-; CHECK: %[[A:.*]] = getelementptr inbounds %a.Frame, %a.Frame* %FramePtr, i32 0, i32 3
-; CHECK: %{{.*}} = bitcast %struct.big_structure* %[[A]] to %struct.big_structure.2*
-declare token @llvm.coro.id(i32, i8* readnone, i8* nocapture readonly, i8*)
+declare token @llvm.coro.id(i32, ptr readnone, ptr nocapture readonly, ptr)
declare i1 @llvm.coro.alloc(token) #3
declare i64 @llvm.coro.size.i64() #5
-declare i8* @llvm.coro.begin(token, i8* writeonly) #3
-declare token @llvm.coro.save(i8*) #3
-declare i8* @llvm.coro.frame() #5
+declare ptr @llvm.coro.begin(token, ptr writeonly) #3
+declare token @llvm.coro.save(ptr) #3
+declare ptr @llvm.coro.frame() #5
declare i8 @llvm.coro.suspend(token, i1) #3
-declare i8* @llvm.coro.free(token, i8* nocapture readonly) #2
-declare i1 @llvm.coro.end(i8*, i1) #3
-declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #4
-declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #4
+declare ptr @llvm.coro.free(token, ptr nocapture readonly) #2
+declare i1 @llvm.coro.end(ptr, i1) #3
+declare void @llvm.lifetime.start.p0(i64, ptr nocapture) #4
+declare void @llvm.lifetime.end.p0(i64, ptr nocapture) #4
diff --git a/llvm/test/Transforms/Coroutines/coro-frame-reuse-alloca-04.ll b/llvm/test/Transforms/Coroutines/coro-frame-reuse-alloca-04.ll
index d23501d24bb3e..65a38e6da0a4c 100644
--- a/llvm/test/Transforms/Coroutines/coro-frame-reuse-alloca-04.ll
+++ b/llvm/test/Transforms/Coroutines/coro-frame-reuse-alloca-04.ll
@@ -1,13 +1,13 @@
; Tests that variables of
diff erent type with incompatible alignment in a Corotuine whose lifetime
; range is not overlapping each other should not re-use the same slot in Coroutine frame.
-; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split<reuse-storage>),simplifycfg,early-cse' -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(coro-split<reuse-storage>),simplifycfg,early-cse' -S | FileCheck %s
%"struct.task::promise_type" = type { i8 }
%struct.awaitable = type { i8 }
%struct.big_structure = type { [500 x i8] }
%struct.big_structure.2 = type { [300 x i8] }
-declare i8* @malloc(i64)
-declare void @consume(%struct.big_structure*)
-declare void @consume.2(%struct.big_structure.2*)
+declare ptr @malloc(i64)
+declare void @consume(ptr)
+declare void @consume.2(ptr)
define void @a(i1 zeroext %cond) presplitcoroutine {
entry:
%__promise = alloca %"struct.task::promise_type", align 1
@@ -15,65 +15,60 @@ entry:
%ref.tmp7 = alloca %struct.awaitable, align 1
%b = alloca %struct.big_structure.2, align 32
%ref.tmp18 = alloca %struct.awaitable, align 1
- %0 = getelementptr inbounds %"struct.task::promise_type", %"struct.task::promise_type"* %__promise, i64 0, i32 0
- %1 = call token @llvm.coro.id(i32 16, i8* nonnull %0, i8* bitcast (void (i1)* @a to i8*), i8* null)
+ %0 = call token @llvm.coro.id(i32 16, ptr nonnull %__promise, ptr @a, ptr null)
br label %init.ready
init.ready:
- %2 = call noalias nonnull i8* @llvm.coro.begin(token %1, i8* null)
- call void @llvm.lifetime.start.p0i8(i64 1, i8* nonnull %0)
+ %1 = call noalias nonnull ptr @llvm.coro.begin(token %0, ptr null)
+ call void @llvm.lifetime.start.p0(i64 1, ptr nonnull %__promise)
br i1 %cond, label %if.then, label %if.else
if.then:
- %3 = getelementptr inbounds %struct.big_structure, %struct.big_structure* %a, i64 0, i32 0, i64 0
- call void @llvm.lifetime.start.p0i8(i64 500, i8* nonnull %3)
- call void @consume(%struct.big_structure* nonnull %a)
- %save = call token @llvm.coro.save(i8* null)
+ call void @llvm.lifetime.start.p0(i64 500, ptr nonnull %a)
+ call void @consume(ptr nonnull %a)
+ %save = call token @llvm.coro.save(ptr null)
%suspend = call i8 @llvm.coro.suspend(token %save, i1 false)
switch i8 %suspend, label %coro.ret [
i8 0, label %await.ready
i8 1, label %cleanup1
]
await.ready:
- call void @llvm.lifetime.end.p0i8(i64 500, i8* nonnull %3)
+ call void @llvm.lifetime.end.p0(i64 500, ptr nonnull %a)
br label %cleanup1
if.else:
- %4 = getelementptr inbounds %struct.big_structure.2, %struct.big_structure.2* %b, i64 0, i32 0, i64 0
- call void @llvm.lifetime.start.p0i8(i64 300, i8* nonnull %4)
- call void @consume.2(%struct.big_structure.2* nonnull %b)
- %save2 = call token @llvm.coro.save(i8* null)
+ call void @llvm.lifetime.start.p0(i64 300, ptr nonnull %b)
+ call void @consume.2(ptr nonnull %b)
+ %save2 = call token @llvm.coro.save(ptr null)
%suspend2 = call i8 @llvm.coro.suspend(token %save2, i1 false)
switch i8 %suspend2, label %coro.ret [
i8 0, label %await2.ready
i8 1, label %cleanup2
]
await2.ready:
- call void @llvm.lifetime.end.p0i8(i64 300, i8* nonnull %4)
+ call void @llvm.lifetime.end.p0(i64 300, ptr nonnull %b)
br label %cleanup2
cleanup1:
- call void @llvm.lifetime.end.p0i8(i64 500, i8* nonnull %3)
+ call void @llvm.lifetime.end.p0(i64 500, ptr nonnull %a)
br label %cleanup
cleanup2:
- call void @llvm.lifetime.end.p0i8(i64 300, i8* nonnull %4)
+ call void @llvm.lifetime.end.p0(i64 300, ptr nonnull %b)
br label %cleanup
cleanup:
- call i8* @llvm.coro.free(token %1, i8* %2)
+ call ptr @llvm.coro.free(token %0, ptr %1)
br label %coro.ret
coro.ret:
- call i1 @llvm.coro.end(i8* null, i1 false)
+ call i1 @llvm.coro.end(ptr null, i1 false)
ret void
}
-; CHECK: %a.Frame = type { void (%a.Frame*)*, void (%a.Frame*)*, %"struct.task::promise_type", %struct.big_structure, i1, [26 x i8], %struct.big_structure.2 }
+; CHECK: %a.Frame = type { ptr, ptr, %"struct.task::promise_type", %struct.big_structure, i1, [26 x i8], %struct.big_structure.2 }
; CHECK-LABEL: @a.resume(
-; CHECK: %[[A:.*]] = getelementptr inbounds %a.Frame, %a.Frame* %FramePtr, i32 0, i32 3
-; CHECK: %[[A:.*]] = getelementptr inbounds %a.Frame, %a.Frame* %FramePtr, i32 0, i32 6
-declare token @llvm.coro.id(i32, i8* readnone, i8* nocapture readonly, i8*)
+declare token @llvm.coro.id(i32, ptr readnone, ptr nocapture readonly, ptr)
declare i1 @llvm.coro.alloc(token) #3
declare i64 @llvm.coro.size.i64() #5
-declare i8* @llvm.coro.begin(token, i8* writeonly) #3
-declare token @llvm.coro.save(i8*) #3
-declare i8* @llvm.coro.frame() #5
+declare ptr @llvm.coro.begin(token, ptr writeonly) #3
+declare token @llvm.coro.save(ptr) #3
+declare ptr @llvm.coro.frame() #5
declare i8 @llvm.coro.suspend(token, i1) #3
-declare i8* @llvm.coro.free(token, i8* nocapture readonly) #2
-declare i1 @llvm.coro.end(i8*, i1) #3
-declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #4
-declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #4
+declare ptr @llvm.coro.free(token, ptr nocapture readonly) #2
+declare i1 @llvm.coro.end(ptr, i1) #3
+declare void @llvm.lifetime.start.p0(i64, ptr nocapture) #4
+declare void @llvm.lifetime.end.p0(i64, ptr nocapture) #4
diff --git a/llvm/test/Transforms/Coroutines/coro-frame-reuse-alloca-05.ll b/llvm/test/Transforms/Coroutines/coro-frame-reuse-alloca-05.ll
index 644bb01c73eaf..2722c9ec45616 100644
--- a/llvm/test/Transforms/Coroutines/coro-frame-reuse-alloca-05.ll
+++ b/llvm/test/Transforms/Coroutines/coro-frame-reuse-alloca-05.ll
@@ -1,13 +1,13 @@
; Tests that variables of
diff erent type with incompatible alignment in a Corotuine whose
; lifetime range is not overlapping each other re-use the same slot in CorotuineFrame.
-; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split<reuse-storage>),simplifycfg,early-cse' -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(coro-split<reuse-storage>),simplifycfg,early-cse' -S | FileCheck %s
%"struct.task::promise_type" = type { i8 }
%struct.awaitable = type { i8 }
%struct.big_structure = type { [500 x i8] }
%struct.big_structure.2 = type { [400 x i8] }
-declare i8* @malloc(i64)
-declare void @consume(%struct.big_structure*)
-declare void @consume.2(%struct.big_structure.2*)
+declare ptr @malloc(i64)
+declare void @consume(ptr)
+declare void @consume.2(ptr)
define void @a(i1 zeroext %cond) presplitcoroutine {
entry:
%__promise = alloca %"struct.task::promise_type", align 1
@@ -15,65 +15,60 @@ entry:
%ref.tmp7 = alloca %struct.awaitable, align 1
%b = alloca %struct.big_structure.2, align 16
%ref.tmp18 = alloca %struct.awaitable, align 1
- %0 = getelementptr inbounds %"struct.task::promise_type", %"struct.task::promise_type"* %__promise, i64 0, i32 0
- %1 = call token @llvm.coro.id(i32 16, i8* nonnull %0, i8* bitcast (void (i1)* @a to i8*), i8* null)
+ %0 = call token @llvm.coro.id(i32 16, ptr nonnull %__promise, ptr @a, ptr null)
br label %init.ready
init.ready:
- %2 = call noalias nonnull i8* @llvm.coro.begin(token %1, i8* null)
- call void @llvm.lifetime.start.p0i8(i64 1, i8* nonnull %0)
+ %1 = call noalias nonnull ptr @llvm.coro.begin(token %0, ptr null)
+ call void @llvm.lifetime.start.p0(i64 1, ptr nonnull %__promise)
br i1 %cond, label %if.then, label %if.else
if.then:
- %3 = getelementptr inbounds %struct.big_structure, %struct.big_structure* %a, i64 0, i32 0, i64 0
- call void @llvm.lifetime.start.p0i8(i64 500, i8* nonnull %3)
- call void @consume(%struct.big_structure* nonnull %a)
- %save = call token @llvm.coro.save(i8* null)
+ call void @llvm.lifetime.start.p0(i64 500, ptr nonnull %a)
+ call void @consume(ptr nonnull %a)
+ %save = call token @llvm.coro.save(ptr null)
%suspend = call i8 @llvm.coro.suspend(token %save, i1 false)
switch i8 %suspend, label %coro.ret [
i8 0, label %await.ready
i8 1, label %cleanup1
]
await.ready:
- call void @llvm.lifetime.end.p0i8(i64 500, i8* nonnull %3)
+ call void @llvm.lifetime.end.p0(i64 500, ptr nonnull %a)
br label %cleanup1
if.else:
- %4 = getelementptr inbounds %struct.big_structure.2, %struct.big_structure.2* %b, i64 0, i32 0, i64 0
- call void @llvm.lifetime.start.p0i8(i64 400, i8* nonnull %4)
- call void @consume.2(%struct.big_structure.2* nonnull %b)
- %save2 = call token @llvm.coro.save(i8* null)
+ call void @llvm.lifetime.start.p0(i64 400, ptr nonnull %b)
+ call void @consume.2(ptr nonnull %b)
+ %save2 = call token @llvm.coro.save(ptr null)
%suspend2 = call i8 @llvm.coro.suspend(token %save2, i1 false)
switch i8 %suspend2, label %coro.ret [
i8 0, label %await2.ready
i8 1, label %cleanup2
]
await2.ready:
- call void @llvm.lifetime.end.p0i8(i64 400, i8* nonnull %4)
+ call void @llvm.lifetime.end.p0(i64 400, ptr nonnull %b)
br label %cleanup2
cleanup1:
- call void @llvm.lifetime.end.p0i8(i64 500, i8* nonnull %3)
+ call void @llvm.lifetime.end.p0(i64 500, ptr nonnull %a)
br label %cleanup
cleanup2:
- call void @llvm.lifetime.end.p0i8(i64 400, i8* nonnull %4)
+ call void @llvm.lifetime.end.p0(i64 400, ptr nonnull %b)
br label %cleanup
cleanup:
- call i8* @llvm.coro.free(token %1, i8* %2)
+ call ptr @llvm.coro.free(token %0, ptr %1)
br label %coro.ret
coro.ret:
- call i1 @llvm.coro.end(i8* null, i1 false)
+ call i1 @llvm.coro.end(ptr null, i1 false)
ret void
}
-; CHECK: %a.Frame = type { void (%a.Frame*)*, void (%a.Frame*)*, %"struct.task::promise_type", i1, [14 x i8], %struct.big_structure }
+; CHECK: %a.Frame = type { ptr, ptr, %"struct.task::promise_type", i1, [14 x i8], %struct.big_structure }
; CHECK-LABEL: @a.resume(
-; CHECK: %[[A:.*]] = getelementptr inbounds %a.Frame, %a.Frame* %FramePtr, i32 0, i32 3
-; CHECK: %[[A:.*]] = getelementptr inbounds %a.Frame, %a.Frame* %FramePtr, i32 0, i32 5
-declare token @llvm.coro.id(i32, i8* readnone, i8* nocapture readonly, i8*)
+declare token @llvm.coro.id(i32, ptr readnone, ptr nocapture readonly, ptr)
declare i1 @llvm.coro.alloc(token) #3
declare i64 @llvm.coro.size.i64() #5
-declare i8* @llvm.coro.begin(token, i8* writeonly) #3
-declare token @llvm.coro.save(i8*) #3
-declare i8* @llvm.coro.frame() #5
+declare ptr @llvm.coro.begin(token, ptr writeonly) #3
+declare token @llvm.coro.save(ptr) #3
+declare ptr @llvm.coro.frame() #5
declare i8 @llvm.coro.suspend(token, i1) #3
-declare i8* @llvm.coro.free(token, i8* nocapture readonly) #2
-declare i1 @llvm.coro.end(i8*, i1) #3
-declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #4
-declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #4
+declare ptr @llvm.coro.free(token, ptr nocapture readonly) #2
+declare i1 @llvm.coro.end(ptr, i1) #3
+declare void @llvm.lifetime.start.p0(i64, ptr nocapture) #4
+declare void @llvm.lifetime.end.p0(i64, ptr nocapture) #4
diff --git a/llvm/test/Transforms/Coroutines/coro-frame.ll b/llvm/test/Transforms/Coroutines/coro-frame.ll
index 0c558aab96ca0..e7fa887a05fa2 100644
--- a/llvm/test/Transforms/Coroutines/coro-frame.ll
+++ b/llvm/test/Transforms/Coroutines/coro-frame.ll
@@ -1,15 +1,15 @@
; Check that we can handle spills of the result of the invoke instruction
-; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
-define i8* @f(i64 %this) presplitcoroutine personality i32 0 {
+define ptr @f(i64 %this) presplitcoroutine personality i32 0 {
entry:
%this.addr = alloca i64
- store i64 %this, i64* %this.addr
- %this1 = load i64, i64* %this.addr
- %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
+ store i64 %this, ptr %this.addr
+ %this1 = load i64, ptr %this.addr
+ %id = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
%size = call i32 @llvm.coro.size.i32()
- %alloc = call i8* @malloc(i32 %size)
- %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
+ %alloc = call ptr @malloc(i32 %size)
+ %hdl = call ptr @llvm.coro.begin(token %id, ptr %alloc)
%r = invoke double @print(double 0.0) to label %cont unwind label %pad
cont:
@@ -22,45 +22,45 @@ resume:
br label %cleanup
cleanup:
- %mem = call i8* @llvm.coro.free(token %id, i8* %hdl)
- call void @free(i8* %mem)
+ %mem = call ptr @llvm.coro.free(token %id, ptr %hdl)
+ call void @free(ptr %mem)
br label %suspend
suspend:
- call i1 @llvm.coro.end(i8* %hdl, i1 0)
- ret i8* %hdl
+ call i1 @llvm.coro.end(ptr %hdl, i1 0)
+ ret ptr %hdl
pad:
%tok = cleanuppad within none []
cleanupret from %tok unwind to caller
}
; See if the float was added to the frame
-; CHECK-LABEL: %f.Frame = type { void (%f.Frame*)*, void (%f.Frame*)*, double, i64, i1 }
+; CHECK-LABEL: %f.Frame = type { ptr, ptr, double, i64, i1 }
; See if the float was spilled into the frame
; CHECK-LABEL: @f(
; CHECK: %r = call double @print(
-; CHECK: %r.spill.addr = getelementptr inbounds %f.Frame, %f.Frame* %FramePtr, i32 0, i32 2
-; CHECK: store double %r, double* %r.spill.addr
-; CHECK: ret i8* %hdl
+; CHECK: %r.spill.addr = getelementptr inbounds %f.Frame, ptr %hdl, i32 0, i32 2
+; CHECK: store double %r, ptr %r.spill.addr
+; CHECK: ret ptr %hdl
; See if the float was loaded from the frame
-; CHECK-LABEL: @f.resume(%f.Frame* noundef nonnull align 8
-; CHECK: %r.reload = load double, double* %r.reload.addr
+; CHECK-LABEL: @f.resume(ptr noundef nonnull align 8
+; CHECK: %r.reload = load double, ptr %r.reload.addr
; CHECK: call double @print(double %r.reload)
; CHECK: ret void
-declare i8* @llvm.coro.free(token, i8*)
+declare ptr @llvm.coro.free(token, ptr)
declare i32 @llvm.coro.size.i32()
declare i8 @llvm.coro.suspend(token, i1)
-declare void @llvm.coro.resume(i8*)
-declare void @llvm.coro.destroy(i8*)
+declare void @llvm.coro.resume(ptr)
+declare void @llvm.coro.destroy(ptr)
-declare token @llvm.coro.id(i32, i8*, i8*, i8*)
+declare token @llvm.coro.id(i32, ptr, ptr, ptr)
declare i1 @llvm.coro.alloc(token)
-declare i8* @llvm.coro.begin(token, i8*)
-declare i1 @llvm.coro.end(i8*, i1)
+declare ptr @llvm.coro.begin(token, ptr)
+declare i1 @llvm.coro.end(ptr, i1)
-declare noalias i8* @malloc(i32)
+declare noalias ptr @malloc(i32)
declare double @print(double)
declare void @print2(i64)
-declare void @free(i8*)
+declare void @free(ptr)
diff --git a/llvm/test/Transforms/Coroutines/coro-heap-elide.ll b/llvm/test/Transforms/Coroutines/coro-heap-elide.ll
index 8de554803ace7..633045d4c9b83 100644
--- a/llvm/test/Transforms/Coroutines/coro-heap-elide.ll
+++ b/llvm/test/Transforms/Coroutines/coro-heap-elide.ll
@@ -1,7 +1,7 @@
; Tests that the dynamic allocation and deallocation of the coroutine frame is
; elided and any tail calls referencing the coroutine frame has the tail
; call attribute removed.
-; RUN: opt -opaque-pointers=0 < %s -S \
+; RUN: opt < %s -S \
; RUN: -passes='cgscc(inline,function(coro-elide,instsimplify,simplifycfg))' \
; RUN: -aa-pipeline='basic-aa' | FileCheck %s
@@ -9,45 +9,45 @@ declare void @print(i32) nounwind
%f.frame = type {i32}
-declare void @bar(i8*)
+declare void @bar(ptr)
-declare fastcc void @f.resume(%f.frame* align 4 dereferenceable(4))
-declare fastcc void @f.destroy(%f.frame*)
-declare fastcc void @f.cleanup(%f.frame*)
+declare fastcc void @f.resume(ptr align 4 dereferenceable(4))
+declare fastcc void @f.destroy(ptr)
+declare fastcc void @f.cleanup(ptr)
declare void @may_throw()
-declare i8* @CustomAlloc(i32)
-declare void @CustomFree(i8*)
+declare ptr @CustomAlloc(i32)
+declare void @CustomFree(ptr)
- at f.resumers = internal constant [3 x void (%f.frame*)*]
- [void (%f.frame*)* @f.resume, void (%f.frame*)* @f.destroy, void (%f.frame*)* @f.cleanup]
+ at f.resumers = internal constant [3 x ptr]
+ [ptr @f.resume, ptr @f.destroy, ptr @f.cleanup]
; a coroutine start function
-define i8* @f() personality i8* null {
+define ptr @f() personality ptr null {
entry:
- %id = call token @llvm.coro.id(i32 0, i8* null,
- i8* bitcast (i8*()* @f to i8*),
- i8* bitcast ([3 x void (%f.frame*)*]* @f.resumers to i8*))
+ %id = call token @llvm.coro.id(i32 0, ptr null,
+ ptr @f,
+ ptr @f.resumers)
%need.dyn.alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin
dyn.alloc:
- %alloc = call i8* @CustomAlloc(i32 4)
+ %alloc = call ptr @CustomAlloc(i32 4)
br label %coro.begin
coro.begin:
- %phi = phi i8* [ null, %entry ], [ %alloc, %dyn.alloc ]
- %hdl = call i8* @llvm.coro.begin(token %id, i8* %phi)
+ %phi = phi ptr [ null, %entry ], [ %alloc, %dyn.alloc ]
+ %hdl = call ptr @llvm.coro.begin(token %id, ptr %phi)
invoke void @may_throw()
to label %ret unwind label %ehcleanup
ret:
- ret i8* %hdl
+ ret ptr %hdl
ehcleanup:
%tok = cleanuppad within none []
- %mem = call i8* @llvm.coro.free(token %id, i8* %hdl)
- %need.dyn.free = icmp ne i8* %mem, null
+ %mem = call ptr @llvm.coro.free(token %id, ptr %hdl)
+ %need.dyn.free = icmp ne ptr %mem, null
br i1 %need.dyn.free, label %dyn.free, label %if.end
dyn.free:
- call void @CustomFree(i8* %mem)
+ call void @CustomFree(ptr %mem)
br label %if.end
if.end:
cleanupret from %tok unwind to caller
@@ -60,24 +60,22 @@ entry:
; CHECK-NOT: coro.begin
; CHECK-NOT: CustomAlloc
; CHECK: call void @may_throw()
- %hdl = call i8* @f()
+ %hdl = call ptr @f()
; Need to remove 'tail' from the first call to @bar
; CHECK-NOT: tail call void @bar(
; CHECK: call void @bar(
- tail call void @bar(i8* %hdl)
+ tail call void @bar(ptr %hdl)
; CHECK: tail call void @bar(
- tail call void @bar(i8* null)
+ tail call void @bar(ptr null)
-; CHECK-NEXT: call fastcc void bitcast (void (%f.frame*)* @f.resume to void (i8*)*)(i8* %vFrame)
- %0 = call i8* @llvm.coro.subfn.addr(i8* %hdl, i8 0)
- %1 = bitcast i8* %0 to void (i8*)*
- call fastcc void %1(i8* %hdl)
+; CHECK-NEXT: call fastcc void @f.resume(ptr %0)
+ %0 = call ptr @llvm.coro.subfn.addr(ptr %hdl, i8 0)
+ call fastcc void %0(ptr %hdl)
-; CHECK-NEXT: call fastcc void bitcast (void (%f.frame*)* @f.cleanup to void (i8*)*)(i8* %vFrame)
- %2 = call i8* @llvm.coro.subfn.addr(i8* %hdl, i8 1)
- %3 = bitcast i8* %2 to void (i8*)*
- call fastcc void %3(i8* %hdl)
+; CHECK-NEXT: call fastcc void @f.cleanup(ptr %0)
+ %1 = call ptr @llvm.coro.subfn.addr(ptr %hdl, i8 1)
+ call fastcc void %1(ptr %hdl)
; CHECK-NEXT: ret void
ret void
@@ -90,38 +88,35 @@ entry:
; CHECK-NOT: coro.begin
; CHECK-NOT: CustomAlloc
; CHECK: call void @may_throw()
- %hdl = call i8* @f()
-
-; CHECK-NEXT: call fastcc void bitcast (void (%f.frame*)* @f.resume to void (i8*)*)(i8* %vFrame)
- %0 = call i8* @llvm.coro.subfn.addr(i8* %hdl, i8 0)
- %1 = bitcast i8* %0 to void (i8*)*
- call fastcc void %1(i8* %hdl)
- %2 = call token @llvm.coro.save(i8* %hdl)
- %3 = call i8 @llvm.coro.suspend(token %2, i1 false)
- switch i8 %3, label %coro.ret [
+ %hdl = call ptr @f()
+
+; CHECK-NEXT: call fastcc void @f.resume(ptr %0)
+ %0 = call ptr @llvm.coro.subfn.addr(ptr %hdl, i8 0)
+ call fastcc void %0(ptr %hdl)
+ %1 = call token @llvm.coro.save(ptr %hdl)
+ %2 = call i8 @llvm.coro.suspend(token %1, i1 false)
+ switch i8 %2, label %coro.ret [
i8 0, label %final.suspend
i8 1, label %cleanups
]
; CHECK-LABEL: final.suspend:
final.suspend:
-; CHECK-NEXT: call fastcc void bitcast (void (%f.frame*)* @f.cleanup to void (i8*)*)(i8* %vFrame)
- %4 = call i8* @llvm.coro.subfn.addr(i8* %hdl, i8 1)
- %5 = bitcast i8* %4 to void (i8*)*
- call fastcc void %5(i8* %hdl)
- %6 = call token @llvm.coro.save(i8* %hdl)
- %7 = call i8 @llvm.coro.suspend(token %6, i1 true)
- switch i8 %7, label %coro.ret [
+; CHECK-NEXT: call fastcc void @f.cleanup(ptr %0)
+ %3 = call ptr @llvm.coro.subfn.addr(ptr %hdl, i8 1)
+ call fastcc void %3(ptr %hdl)
+ %4 = call token @llvm.coro.save(ptr %hdl)
+ %5 = call i8 @llvm.coro.suspend(token %4, i1 true)
+ switch i8 %5, label %coro.ret [
i8 0, label %coro.ret
i8 1, label %cleanups
]
; CHECK-LABEL: cleanups:
cleanups:
-; CHECK-NEXT: call fastcc void bitcast (void (%f.frame*)* @f.cleanup to void (i8*)*)(i8* %vFrame)
- %8 = call i8* @llvm.coro.subfn.addr(i8* %hdl, i8 1)
- %9 = bitcast i8* %8 to void (i8*)*
- call fastcc void %9(i8* %hdl)
+; CHECK-NEXT: call fastcc void @f.cleanup(ptr %0)
+ %6 = call ptr @llvm.coro.subfn.addr(ptr %hdl, i8 1)
+ call fastcc void %6(ptr %hdl)
br label %coro.ret
; CHECK-LABEL: coro.ret:
@@ -131,62 +126,58 @@ coro.ret:
}
; CHECK-LABEL: @callResume_with_coro_suspend_2(
-define void @callResume_with_coro_suspend_2() personality i8* null {
+define void @callResume_with_coro_suspend_2() personality ptr null {
entry:
; CHECK: alloca [4 x i8], align 4
; CHECK-NOT: coro.begin
; CHECK-NOT: CustomAlloc
; CHECK: call void @may_throw()
- %hdl = call i8* @f()
+ %hdl = call ptr @f()
- %0 = call token @llvm.coro.save(i8* %hdl)
-; CHECK: invoke fastcc void bitcast (void (%f.frame*)* @f.resume to void (i8*)*)(i8* %vFrame)
- %1 = call i8* @llvm.coro.subfn.addr(i8* %hdl, i8 0)
- %2 = bitcast i8* %1 to void (i8*)*
- invoke fastcc void %2(i8* %hdl)
+ %0 = call token @llvm.coro.save(ptr %hdl)
+; CHECK: invoke fastcc void @f.resume(ptr %0)
+ %1 = call ptr @llvm.coro.subfn.addr(ptr %hdl, i8 0)
+ invoke fastcc void %1(ptr %hdl)
to label %invoke.cont1 unwind label %lpad
; CHECK-LABEL: invoke.cont1:
invoke.cont1:
- %3 = call i8 @llvm.coro.suspend(token %0, i1 false)
- switch i8 %3, label %coro.ret [
+ %2 = call i8 @llvm.coro.suspend(token %0, i1 false)
+ switch i8 %2, label %coro.ret [
i8 0, label %final.ready
i8 1, label %cleanups
]
; CHECK-LABEL: lpad:
lpad:
- %4 = landingpad { i8*, i32 }
- catch i8* null
-; CHECK: call fastcc void bitcast (void (%f.frame*)* @f.cleanup to void (i8*)*)(i8* %vFrame)
- %5 = call i8* @llvm.coro.subfn.addr(i8* %hdl, i8 1)
- %6 = bitcast i8* %5 to void (i8*)*
- call fastcc void %6(i8* %hdl)
+ %3 = landingpad { ptr, i32 }
+ catch ptr null
+; CHECK: call fastcc void @f.cleanup(ptr %0)
+ %4 = call ptr @llvm.coro.subfn.addr(ptr %hdl, i8 1)
+ call fastcc void %4(ptr %hdl)
br label %final.suspend
; CHECK-LABEL: final.ready:
final.ready:
-; CHECK-NEXT: call fastcc void bitcast (void (%f.frame*)* @f.cleanup to void (i8*)*)(i8* %vFrame)
- %7 = call i8* @llvm.coro.subfn.addr(i8* %hdl, i8 1)
- %8 = bitcast i8* %7 to void (i8*)*
- call fastcc void %8(i8* %hdl)
+; CHECK-NEXT: call fastcc void @f.cleanup(ptr %0)
+ %5 = call ptr @llvm.coro.subfn.addr(ptr %hdl, i8 1)
+ call fastcc void %5(ptr %hdl)
br label %final.suspend
; CHECK-LABEL: final.suspend:
final.suspend:
- %9 = call token @llvm.coro.save(i8* %hdl)
- %10 = call i8 @llvm.coro.suspend(token %9, i1 true)
- switch i8 %10, label %coro.ret [
+ %6 = call token @llvm.coro.save(ptr %hdl)
+ %7 = call i8 @llvm.coro.suspend(token %6, i1 true)
+ switch i8 %7, label %coro.ret [
i8 0, label %coro.ret
i8 1, label %cleanups
]
; CHECK-LABEL: cleanups:
cleanups:
-; CHECK-NEXT: call fastcc void bitcast (void (%f.frame*)* @f.cleanup to void (i8*)*)(i8* %vFrame)
- %11 = call i8* @llvm.coro.subfn.addr(i8* %hdl, i8 1)
- %12 = bitcast i8* %11 to void (i8*)*
- call fastcc void %12(i8* %hdl)
+; CHECK-NEXT: call fastcc void @f.cleanup(ptr %0)
+ %8 = call ptr @llvm.coro.subfn.addr(ptr %hdl, i8 1)
+ call fastcc void %8(ptr %hdl)
br label %coro.ret
; CHECK-LABEL: coro.ret:
@@ -208,37 +199,34 @@ init.suspend:
; CHECK-NOT: llvm.coro.begin
; CHECK-NOT: CustomAlloc
; CHECK: call void @may_throw()
- %hdl = call i8* @f()
-; CHECK-NEXT: call fastcc void bitcast (void (%f.frame*)* @f.resume to void (i8*)*)(i8* %vFrame)
- %0 = call i8* @llvm.coro.subfn.addr(i8* %hdl, i8 0)
- %1 = bitcast i8* %0 to void (i8*)*
- call fastcc void %1(i8* %hdl)
- %2 = call token @llvm.coro.save(i8* %hdl)
- %3 = call i8 @llvm.coro.suspend(token %2, i1 false)
- switch i8 %3, label %coro.ret [
+ %hdl = call ptr @f()
+; CHECK-NEXT: call fastcc void @f.resume(ptr %0)
+ %0 = call ptr @llvm.coro.subfn.addr(ptr %hdl, i8 0)
+ call fastcc void %0(ptr %hdl)
+ %1 = call token @llvm.coro.save(ptr %hdl)
+ %2 = call i8 @llvm.coro.suspend(token %1, i1 false)
+ switch i8 %2, label %coro.ret [
i8 0, label %final.suspend
i8 1, label %cleanups
]
; CHECK-LABEL: final.suspend:
final.suspend:
-; CHECK-NEXT: call fastcc void bitcast (void (%f.frame*)* @f.cleanup to void (i8*)*)(i8* %vFrame)
- %4 = call i8* @llvm.coro.subfn.addr(i8* %hdl, i8 1)
- %5 = bitcast i8* %4 to void (i8*)*
- call fastcc void %5(i8* %hdl)
- %6 = call token @llvm.coro.save(i8* %hdl)
- %7 = call i8 @llvm.coro.suspend(token %6, i1 true)
- switch i8 %7, label %coro.ret [
+; CHECK-NEXT: call fastcc void @f.cleanup(ptr %0)
+ %3 = call ptr @llvm.coro.subfn.addr(ptr %hdl, i8 1)
+ call fastcc void %3(ptr %hdl)
+ %4 = call token @llvm.coro.save(ptr %hdl)
+ %5 = call i8 @llvm.coro.suspend(token %4, i1 true)
+ switch i8 %5, label %coro.ret [
i8 0, label %coro.ret
i8 1, label %cleanups
]
; CHECK-LABEL: cleanups:
cleanups:
-; CHECK-NEXT: call fastcc void bitcast (void (%f.frame*)* @f.cleanup to void (i8*)*)(i8* %vFrame)
- %8 = call i8* @llvm.coro.subfn.addr(i8* %hdl, i8 1)
- %9 = bitcast i8* %8 to void (i8*)*
- call fastcc void %9(i8* %hdl)
+; CHECK-NEXT: call fastcc void @f.cleanup(ptr %0)
+ %6 = call ptr @llvm.coro.subfn.addr(ptr %hdl, i8 1)
+ call fastcc void %6(ptr %hdl)
br label %coro.ret
; CHECK-LABEL: coro.ret:
@@ -253,24 +241,22 @@ coro.ret:
define void @callResume_PR34897_no_elision(i1 %cond) {
; CHECK-LABEL: entry:
entry:
-; CHECK: call i8* @CustomAlloc(
- %hdl = call i8* @f()
+; CHECK: call ptr @CustomAlloc(
+ %hdl = call ptr @f()
; CHECK: tail call void @bar(
- tail call void @bar(i8* %hdl)
+ tail call void @bar(ptr %hdl)
; CHECK: tail call void @bar(
- tail call void @bar(i8* null)
+ tail call void @bar(ptr null)
br i1 %cond, label %if.then, label %if.else
; CHECK-LABEL: if.then:
if.then:
-; CHECK: call fastcc void bitcast (void (%f.frame*)* @f.resume to void (i8*)*)(i8*
- %0 = call i8* @llvm.coro.subfn.addr(i8* %hdl, i8 0)
- %1 = bitcast i8* %0 to void (i8*)*
- call fastcc void %1(i8* %hdl)
-; CHECK-NEXT: call fastcc void bitcast (void (%f.frame*)* @f.destroy to void (i8*)*)(i8*
- %2 = call i8* @llvm.coro.subfn.addr(i8* %hdl, i8 1)
- %3 = bitcast i8* %2 to void (i8*)*
- call fastcc void %3(i8* %hdl)
+; CHECK: call fastcc void @f.resume(ptr
+ %0 = call ptr @llvm.coro.subfn.addr(ptr %hdl, i8 0)
+ call fastcc void %0(ptr %hdl)
+; CHECK-NEXT: call fastcc void @f.destroy(ptr
+ %1 = call ptr @llvm.coro.subfn.addr(ptr %hdl, i8 1)
+ call fastcc void %1(ptr %hdl)
br label %return
if.else:
@@ -288,23 +274,21 @@ define void @callResume_PR34897_elision(i1 %cond) {
entry:
; CHECK: alloca [4 x i8], align 4
; CHECK: tail call void @bar(
- tail call void @bar(i8* null)
+ tail call void @bar(ptr null)
br i1 %cond, label %if.then, label %if.else
if.then:
; CHECK-NOT: CustomAlloc
; CHECK: call void @may_throw()
- %hdl = call i8* @f()
+ %hdl = call ptr @f()
; CHECK: call void @bar(
- tail call void @bar(i8* %hdl)
-; CHECK: call fastcc void bitcast (void (%f.frame*)* @f.resume to void (i8*)*)(i8*
- %0 = call i8* @llvm.coro.subfn.addr(i8* %hdl, i8 0)
- %1 = bitcast i8* %0 to void (i8*)*
- call fastcc void %1(i8* %hdl)
-; CHECK-NEXT: call fastcc void bitcast (void (%f.frame*)* @f.cleanup to void (i8*)*)(i8*
- %2 = call i8* @llvm.coro.subfn.addr(i8* %hdl, i8 1)
- %3 = bitcast i8* %2 to void (i8*)*
- call fastcc void %3(i8* %hdl)
+ tail call void @bar(ptr %hdl)
+; CHECK: call fastcc void @f.resume(ptr
+ %0 = call ptr @llvm.coro.subfn.addr(ptr %hdl, i8 0)
+ call fastcc void %0(ptr %hdl)
+; CHECK-NEXT: call fastcc void @f.cleanup(ptr
+ %1 = call ptr @llvm.coro.subfn.addr(ptr %hdl, i8 1)
+ call fastcc void %1(ptr %hdl)
br label %return
if.else:
@@ -319,47 +303,45 @@ return:
; a coroutine start function (cannot elide heap alloc, due to second argument to
; coro.begin not pointint to coro.alloc)
-define i8* @f_no_elision() personality i8* null {
+define ptr @f_no_elision() personality ptr null {
entry:
- %id = call token @llvm.coro.id(i32 0, i8* null,
- i8* bitcast (i8*()* @f_no_elision to i8*),
- i8* bitcast ([3 x void (%f.frame*)*]* @f.resumers to i8*))
- %alloc = call i8* @CustomAlloc(i32 4)
- %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
- ret i8* %hdl
+ %id = call token @llvm.coro.id(i32 0, ptr null,
+ ptr @f_no_elision,
+ ptr @f.resumers)
+ %alloc = call ptr @CustomAlloc(i32 4)
+ %hdl = call ptr @llvm.coro.begin(token %id, ptr %alloc)
+ ret ptr %hdl
}
; CHECK-LABEL: @callResume_no_elision(
define void @callResume_no_elision() {
entry:
-; CHECK: call i8* @CustomAlloc(
- %hdl = call i8* @f_no_elision()
+; CHECK: call ptr @CustomAlloc(
+ %hdl = call ptr @f_no_elision()
; Tail call should remain tail calls
; CHECK: tail call void @bar(
- tail call void @bar(i8* %hdl)
+ tail call void @bar(ptr %hdl)
; CHECK: tail call void @bar(
- tail call void @bar(i8* null)
+ tail call void @bar(ptr null)
-; CHECK-NEXT: call fastcc void bitcast (void (%f.frame*)* @f.resume to void (i8*)*)(i8*
- %0 = call i8* @llvm.coro.subfn.addr(i8* %hdl, i8 0)
- %1 = bitcast i8* %0 to void (i8*)*
- call fastcc void %1(i8* %hdl)
+; CHECK-NEXT: call fastcc void @f.resume(ptr
+ %0 = call ptr @llvm.coro.subfn.addr(ptr %hdl, i8 0)
+ call fastcc void %0(ptr %hdl)
-; CHECK-NEXT: call fastcc void bitcast (void (%f.frame*)* @f.destroy to void (i8*)*)(i8*
- %2 = call i8* @llvm.coro.subfn.addr(i8* %hdl, i8 1)
- %3 = bitcast i8* %2 to void (i8*)*
- call fastcc void %3(i8* %hdl)
+; CHECK-NEXT: call fastcc void @f.destroy(ptr
+ %1 = call ptr @llvm.coro.subfn.addr(ptr %hdl, i8 1)
+ call fastcc void %1(ptr %hdl)
; CHECK-NEXT: ret void
ret void
}
-declare token @llvm.coro.id(i32, i8*, i8*, i8*)
+declare token @llvm.coro.id(i32, ptr, ptr, ptr)
declare i1 @llvm.coro.alloc(token)
-declare i8* @llvm.coro.free(token, i8*)
-declare i8* @llvm.coro.begin(token, i8*)
-declare i8* @llvm.coro.frame(token)
-declare i8* @llvm.coro.subfn.addr(i8*, i8)
+declare ptr @llvm.coro.free(token, ptr)
+declare ptr @llvm.coro.begin(token, ptr)
+declare ptr @llvm.coro.frame(token)
+declare ptr @llvm.coro.subfn.addr(ptr, i8)
declare i8 @llvm.coro.suspend(token, i1)
-declare token @llvm.coro.save(i8*)
+declare token @llvm.coro.save(ptr)
diff --git a/llvm/test/Transforms/Coroutines/coro-padding.ll b/llvm/test/Transforms/Coroutines/coro-padding.ll
index 28f72f4f04f24..faed9b4b3b549 100644
--- a/llvm/test/Transforms/Coroutines/coro-padding.ll
+++ b/llvm/test/Transforms/Coroutines/coro-padding.ll
@@ -1,61 +1,61 @@
; Check that we will insert the correct padding if natural alignment of the
; spilled data does not match the alignment specified in alloca instruction.
-; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
%PackedStruct = type <{ i64 }>
-declare void @consume(%PackedStruct*)
+declare void @consume(ptr)
-define i8* @f() presplitcoroutine {
+define ptr @f() presplitcoroutine {
entry:
%data = alloca %PackedStruct, align 32
- %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
+ %id = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
%size = call i32 @llvm.coro.size.i32()
- %alloc = call i8* @malloc(i32 %size)
- %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
- call void @consume(%PackedStruct* %data)
+ %alloc = call ptr @malloc(i32 %size)
+ %hdl = call ptr @llvm.coro.begin(token %id, ptr %alloc)
+ call void @consume(ptr %data)
%0 = call i8 @llvm.coro.suspend(token none, i1 false)
switch i8 %0, label %suspend [i8 0, label %resume
i8 1, label %cleanup]
resume:
- call void @consume(%PackedStruct* %data)
+ call void @consume(ptr %data)
br label %cleanup
cleanup:
- %mem = call i8* @llvm.coro.free(token %id, i8* %hdl)
- call void @free(i8* %mem)
+ %mem = call ptr @llvm.coro.free(token %id, ptr %hdl)
+ call void @free(ptr %mem)
br label %suspend
suspend:
- call i1 @llvm.coro.end(i8* %hdl, i1 0)
- ret i8* %hdl
+ call i1 @llvm.coro.end(ptr %hdl, i1 0)
+ ret ptr %hdl
}
; See if the padding was inserted before PackedStruct
-; CHECK-LABEL: %f.Frame = type { void (%f.Frame*)*, void (%f.Frame*)*, i1, [15 x i8], %PackedStruct }
+; CHECK-LABEL: %f.Frame = type { ptr, ptr, i1, [15 x i8], %PackedStruct }
; See if we used correct index to access packed struct (padding is field 3)
; CHECK-LABEL: @f(
-; CHECK: %[[DATA:.+]] = getelementptr inbounds %f.Frame, %f.Frame* %FramePtr, i32 0, i32 4
-; CHECK-NEXT: call void @consume(%PackedStruct* %[[DATA]])
-; CHECK: ret i8*
+; CHECK: %[[DATA:.+]] = getelementptr inbounds %f.Frame, ptr %hdl, i32 0, i32 4
+; CHECK-NEXT: call void @consume(ptr %[[DATA]])
+; CHECK: ret ptr
; See if we used correct index to access packed struct (padding is field 3)
; CHECK-LABEL: @f.resume(
-; CHECK: %[[DATA:.+]] = getelementptr inbounds %f.Frame, %f.Frame* %FramePtr, i32 0, i32 4
-; CHECK-NEXT: call void @consume(%PackedStruct* %[[DATA]])
+; CHECK: %[[DATA:.+]] = getelementptr inbounds %f.Frame, ptr %hdl, i32 0, i32 4
+; CHECK-NEXT: call void @consume(ptr %[[DATA]])
; CHECK: ret void
-declare i8* @llvm.coro.free(token, i8*)
+declare ptr @llvm.coro.free(token, ptr)
declare i32 @llvm.coro.size.i32()
declare i8 @llvm.coro.suspend(token, i1)
-declare void @llvm.coro.resume(i8*)
-declare void @llvm.coro.destroy(i8*)
+declare void @llvm.coro.resume(ptr)
+declare void @llvm.coro.destroy(ptr)
-declare token @llvm.coro.id(i32, i8*, i8*, i8*)
+declare token @llvm.coro.id(i32, ptr, ptr, ptr)
declare i1 @llvm.coro.alloc(token)
-declare i8* @llvm.coro.begin(token, i8*)
-declare i1 @llvm.coro.end(i8*, i1)
+declare ptr @llvm.coro.begin(token, ptr)
+declare i1 @llvm.coro.end(ptr, i1)
-declare noalias i8* @malloc(i32)
+declare noalias ptr @malloc(i32)
declare double @print(double)
-declare void @free(i8*)
+declare void @free(ptr)
diff --git a/llvm/test/Transforms/Coroutines/coro-param-copy.ll b/llvm/test/Transforms/Coroutines/coro-param-copy.ll
index 792a894627ff2..6e80577b56b39 100644
--- a/llvm/test/Transforms/Coroutines/coro-param-copy.ll
+++ b/llvm/test/Transforms/Coroutines/coro-param-copy.ll
@@ -1,96 +1,93 @@
; Check that we create copy the data from the alloca into the coroutine
; frame slot if it was written to.
-; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
-define i8* @f() presplitcoroutine {
+define ptr @f() presplitcoroutine {
entry:
%a.addr = alloca i64 ; read-only before coro.begin
- %a = load i64, i64* %a.addr ; cannot modify the value, don't need to copy
+ %a = load i64, ptr %a.addr ; cannot modify the value, don't need to copy
%x.addr = alloca i64
- call void @use(i64* %x.addr) ; uses %x.addr before coro.begin
+ call void @use(ptr %x.addr) ; uses %x.addr before coro.begin
%y.addr = alloca i64
- %y.cast = bitcast i64* %y.addr to i8* ; alias created and used after coro.begin
%z.addr = alloca i64
%flag = call i1 @check()
br i1 %flag, label %flag_true, label %flag_merge
flag_true:
- call void @use(i64* %z.addr) ; conditionally used %z.addr
+ call void @use(ptr %z.addr) ; conditionally used %z.addr
br label %flag_merge
flag_merge:
- %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
+ %id = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
%size = call i32 @llvm.coro.size.i32()
- %alloc = call i8* @myAlloc(i32 %size)
- %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
- call void @llvm.memset.p0i8.i32(i8* %y.cast, i8 1, i32 4, i1 false)
+ %alloc = call ptr @myAlloc(i32 %size)
+ %hdl = call ptr @llvm.coro.begin(token %id, ptr %alloc)
+ call void @llvm.memset.p0.i32(ptr %y.addr, i8 1, i32 4, i1 false)
%0 = call i8 @llvm.coro.suspend(token none, i1 false)
switch i8 %0, label %suspend [i8 0, label %resume
i8 1, label %cleanup]
resume:
- call void @use(i64* %a.addr)
- call void @use(i64* %x.addr)
- call void @use(i64* %y.addr)
- call void @use(i64* %z.addr)
+ call void @use(ptr %a.addr)
+ call void @use(ptr %x.addr)
+ call void @use(ptr %y.addr)
+ call void @use(ptr %z.addr)
br label %cleanup
cleanup:
- %mem = call i8* @llvm.coro.free(token %id, i8* %hdl)
- call void @free(i8* %mem)
+ %mem = call ptr @llvm.coro.free(token %id, ptr %hdl)
+ call void @free(ptr %mem)
br label %suspend
suspend:
- call i1 @llvm.coro.end(i8* %hdl, i1 0)
- ret i8* %hdl
+ call i1 @llvm.coro.end(ptr %hdl, i1 0)
+ ret ptr %hdl
}
; See that we added both x and y to the frame.
-; CHECK: %f.Frame = type { void (%f.Frame*)*, void (%f.Frame*)*, i64, i64, i64, i64, i1 }
+; CHECK: %f.Frame = type { ptr, ptr, i64, i64, i64, i64, i1 }
; See that all of the uses prior to coro-begin stays put.
-; CHECK-LABEL: define i8* @f() {
+; CHECK-LABEL: define ptr @f() {
; CHECK-NEXT: entry:
; CHECK-NEXT: %a.addr = alloca i64
; CHECK-NEXT: %x.addr = alloca i64
-; CHECK-NEXT: call void @use(i64* %x.addr)
-; CHECK-NEXT: %y.addr = alloca i64
+; CHECK-NEXT: call void @use(ptr %x.addr)
; CHECK-NEXT: %z.addr = alloca i64
; See that we only copy the x as y was not modified prior to coro.begin.
-; CHECK: store void (%f.Frame*)* @f.destroy, void (%f.Frame*)** %destroy.addr
+; CHECK: store ptr @f.destroy, ptr %destroy.addr
; The next 3 instructions are to copy data in %x.addr from stack to frame.
-; CHECK-NEXT: %0 = getelementptr inbounds %f.Frame, %f.Frame* %FramePtr, i32 0, i32 3
-; CHECK-NEXT: %1 = load i64, i64* %x.addr, align 4
-; CHECK-NEXT: store i64 %1, i64* %0, align 4
-; The next 2 instructions are to recreate %y.cast in the original IR.
-; CHECK-NEXT: %2 = getelementptr inbounds %f.Frame, %f.Frame* %FramePtr, i32 0, i32 4
-; CHECK-NEXT: %3 = bitcast i64* %2 to i8*
+; CHECK-NEXT: %0 = getelementptr inbounds %f.Frame, ptr %hdl, i32 0, i32 3
+; CHECK-NEXT: %1 = load i64, ptr %x.addr, align 4
+; CHECK-NEXT: store i64 %1, ptr %0, align 4
; The next 3 instructions are to copy data in %z.addr from stack to frame.
-; CHECK-NEXT: %4 = getelementptr inbounds %f.Frame, %f.Frame* %FramePtr, i32 0, i32 5
-; CHECK-NEXT: %5 = load i64, i64* %z.addr, align 4
-; CHECK-NEXT: store i64 %5, i64* %4, align 4
-; CHECK-NEXT: call void @llvm.memset.p0i8.i32(i8* %3, i8 1, i32 4, i1 false)
-; CHECK-NEXT: %index.addr1 = getelementptr inbounds %f.Frame, %f.Frame* %FramePtr, i32 0, i32 6
-; CHECK-NEXT: store i1 false, i1* %index.addr1, align 1
-; CHECK-NEXT: ret i8* %hdl
+; CHECK-NEXT: [[T2:%.+]] = getelementptr inbounds %f.Frame, ptr %hdl, i32 0, i32 5
+; CHECK-NEXT: [[T3:%.+]] = load i64, ptr %z.addr, align 4
+; CHECK-NEXT: store i64 [[T3]], ptr [[T2]], align 4
+; The next instruction is to recreate %y.cast in the original IR.
+; CHECK-NEXT: %y.addr.reload.addr = getelementptr inbounds %f.Frame, ptr %hdl, i32 0, i32 4
+; CHECK-NEXT: call void @llvm.memset.p0.i32(ptr %y.addr.reload.addr, i8 1, i32 4, i1 false)
+; CHECK-NEXT: %index.addr1 = getelementptr inbounds %f.Frame, ptr %hdl, i32 0, i32 6
+; CHECK-NEXT: store i1 false, ptr %index.addr1, align 1
+; CHECK-NEXT: ret ptr %hdl
-declare i8* @llvm.coro.free(token, i8*)
+declare ptr @llvm.coro.free(token, ptr)
declare i32 @llvm.coro.size.i32()
declare i8 @llvm.coro.suspend(token, i1)
-declare void @llvm.coro.resume(i8*)
-declare void @llvm.coro.destroy(i8*)
+declare void @llvm.coro.resume(ptr)
+declare void @llvm.coro.destroy(ptr)
-declare token @llvm.coro.id(i32, i8*, i8*, i8*)
+declare token @llvm.coro.id(i32, ptr, ptr, ptr)
declare i1 @llvm.coro.alloc(token)
-declare i8* @llvm.coro.begin(token, i8*)
-declare i1 @llvm.coro.end(i8*, i1)
+declare ptr @llvm.coro.begin(token, ptr)
+declare i1 @llvm.coro.end(ptr, i1)
-declare void @llvm.memset.p0i8.i32(i8*, i8, i32, i1)
+declare void @llvm.memset.p0.i32(ptr, i8, i32, i1)
-declare noalias i8* @myAlloc(i32)
-declare void @use(i64*)
-declare void @free(i8*)
+declare noalias ptr @myAlloc(i32)
+declare void @use(ptr)
+declare void @free(ptr)
declare i1 @check()
diff --git a/llvm/test/Transforms/Coroutines/coro-resume-destroy.ll b/llvm/test/Transforms/Coroutines/coro-resume-destroy.ll
index 4b6cc7a9cf1bd..e5e828dd6abff 100644
--- a/llvm/test/Transforms/Coroutines/coro-resume-destroy.ll
+++ b/llvm/test/Transforms/Coroutines/coro-resume-destroy.ll
@@ -1,32 +1,32 @@
; Tests that CoroEarly pass correctly lowers coro.resume, coro.destroy
-; RUN: opt -opaque-pointers=0 < %s -S -passes=coro-early | FileCheck %s
+; RUN: opt < %s -S -passes=coro-early | FileCheck %s
; CHECK-LABEL: @callResume(
-define void @callResume(i8* %hdl) {
+define void @callResume(ptr %hdl) {
; CHECK-NEXT: entry
entry:
-; CHECK-NEXT: %0 = call i8* @llvm.coro.subfn.addr(i8* %hdl, i8 0)
-; CHECK-NEXT: %1 = bitcast i8* %0 to void (i8*)*
-; CHECK-NEXT: call fastcc void %1(i8* %hdl)
- call void @llvm.coro.resume(i8* %hdl)
+; CHECK-NEXT: %0 = call ptr @llvm.coro.subfn.addr(ptr %hdl, i8 0)
+; CHECK-NEXT: %1 = bitcast ptr %0 to ptr
+; CHECK-NEXT: call fastcc void %1(ptr %hdl)
+ call void @llvm.coro.resume(ptr %hdl)
-; CHECK-NEXT: %2 = call i8* @llvm.coro.subfn.addr(i8* %hdl, i8 1)
-; CHECK-NEXT: %3 = bitcast i8* %2 to void (i8*)*
-; CHECK-NEXT: call fastcc void %3(i8* %hdl)
- call void @llvm.coro.destroy(i8* %hdl)
+; CHECK-NEXT: %2 = call ptr @llvm.coro.subfn.addr(ptr %hdl, i8 1)
+; CHECK-NEXT: %3 = bitcast ptr %2 to ptr
+; CHECK-NEXT: call fastcc void %3(ptr %hdl)
+ call void @llvm.coro.destroy(ptr %hdl)
ret void
; CHECK-NEXT: ret void
}
; CHECK-LABEL: @eh(
-define void @eh(i8* %hdl) personality i8* null {
+define void @eh(ptr %hdl) personality ptr null {
; CHECK-NEXT: entry
entry:
-; CHECK-NEXT: %0 = call i8* @llvm.coro.subfn.addr(i8* %hdl, i8 0)
-; CHECK-NEXT: %1 = bitcast i8* %0 to void (i8*)*
-; CHECK-NEXT: invoke fastcc void %1(i8* %hdl)
- invoke void @llvm.coro.resume(i8* %hdl)
+; CHECK-NEXT: %0 = call ptr @llvm.coro.subfn.addr(ptr %hdl, i8 0)
+; CHECK-NEXT: %1 = bitcast ptr %0 to ptr
+; CHECK-NEXT: invoke fastcc void %1(ptr %hdl)
+ invoke void @llvm.coro.resume(ptr %hdl)
to label %cont unwind label %ehcleanup
cont:
ret void
@@ -37,5 +37,5 @@ ehcleanup:
}
-declare void @llvm.coro.resume(i8*)
-declare void @llvm.coro.destroy(i8*)
+declare void @llvm.coro.resume(ptr)
+declare void @llvm.coro.destroy(ptr)
diff --git a/llvm/test/Transforms/Coroutines/coro-retcon-frame.ll b/llvm/test/Transforms/Coroutines/coro-retcon-frame.ll
index 5868f6d743e7b..3418e07a9b0aa 100644
--- a/llvm/test/Transforms/Coroutines/coro-retcon-frame.ll
+++ b/llvm/test/Transforms/Coroutines/coro-retcon-frame.ll
@@ -1,63 +1,56 @@
-; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
target datalayout = "p:64:64:64"
-declare void @prototype_f(i8*, i1)
+declare void @prototype_f(ptr, i1)
-declare noalias i8* @allocate(i32 %size)
-declare void @deallocate(i8* %ptr)
-declare void @init(i64 *%ptr)
-declare void @use(i8* %ptr)
-declare void @use_addr_val(i64 %val, {i64, i64}*%addr)
+declare noalias ptr @allocate(i32 %size)
+declare void @deallocate(ptr %ptr)
+declare void @init(ptr %ptr)
+declare void @use(ptr %ptr)
+declare void @use_addr_val(i64 %val, ptr %addr)
-define { i8*, {i64, i64}* } @f(i8* %buffer) presplitcoroutine {
+define { ptr, ptr } @f(ptr %buffer) presplitcoroutine {
entry:
%tmp = alloca { i64, i64 }, align 8
- %proj.1 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %tmp, i64 0, i32 0
- %proj.2 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %tmp, i64 0, i32 1
- store i64 0, i64* %proj.1, align 8
- store i64 0, i64* %proj.2, align 8
- %cast = bitcast { i64, i64 }* %tmp to i8*
- %escape_addr = ptrtoint {i64, i64}* %tmp to i64
- %id = call token @llvm.coro.id.retcon.once(i32 32, i32 8, i8* %buffer, i8* bitcast (void (i8*, i1)* @prototype_f to i8*), i8* bitcast (i8* (i32)* @allocate to i8*), i8* bitcast (void (i8*)* @deallocate to i8*))
- %hdl = call i8* @llvm.coro.begin(token %id, i8* null)
- %proj.2.2 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %tmp, i64 0, i32 1
- call void @init(i64 * %proj.1)
- call void @init(i64 * %proj.2.2)
- call void @use_addr_val(i64 %escape_addr, {i64, i64}* %tmp)
- %abort = call i1 (...) @llvm.coro.suspend.retcon.i1({i64, i64}* %tmp)
+ %proj.1 = getelementptr inbounds { i64, i64 }, ptr %tmp, i64 0, i32 0
+ %proj.2 = getelementptr inbounds { i64, i64 }, ptr %tmp, i64 0, i32 1
+ store i64 0, ptr %proj.1, align 8
+ store i64 0, ptr %proj.2, align 8
+ %escape_addr = ptrtoint ptr %tmp to i64
+ %id = call token @llvm.coro.id.retcon.once(i32 32, i32 8, ptr %buffer, ptr @prototype_f, ptr @allocate, ptr @deallocate)
+ %hdl = call ptr @llvm.coro.begin(token %id, ptr null)
+ %proj.2.2 = getelementptr inbounds { i64, i64 }, ptr %tmp, i64 0, i32 1
+ call void @init(ptr %proj.1)
+ call void @init(ptr %proj.2.2)
+ call void @use_addr_val(i64 %escape_addr, ptr %tmp)
+ %abort = call i1 (...) @llvm.coro.suspend.retcon.i1(ptr %tmp)
br i1 %abort, label %end, label %resume
resume:
- call void @use(i8* %cast)
+ call void @use(ptr %tmp)
br label %end
end:
- call i1 @llvm.coro.end(i8* %hdl, i1 0)
+ call i1 @llvm.coro.end(ptr %hdl, i1 0)
unreachable
}
; Make sure we don't lose writes to the frame.
-; CHECK-LABEL: define { i8*, { i64, i64 }* } @f(i8* %buffer) {
-; CHECK: [[FRAMEPTR:%.*]] = bitcast i8* %buffer to %f.Frame*
-; CHECK: [[TMP:%.*]] = getelementptr inbounds %f.Frame, %f.Frame* [[FRAMEPTR]], i32 0, i32 0
-; CHECK: [[PROJ1:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[TMP]], i64 0, i32 0
-; CHECK: [[PROJ2:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[TMP]], i64 0, i32 1
-; CHECK: store i64 0, i64* [[PROJ1]]
-; CHECK: store i64 0, i64* [[PROJ2]]
-; CHECK: [[ESCAPED_ADDR:%.*]] = ptrtoint { i64, i64 }* [[TMP]] to i64
-; CHECK: call void @init(i64* [[PROJ1]])
-; CHECK: call void @init(i64* [[PROJ2]])
-; CHECK: call void @use_addr_val(i64 [[ESCAPED_ADDR]], { i64, i64 }* [[TMP]])
-
-; CHECK-LABEL: define internal void @f.resume.0(i8* {{.*}} %0, i1 %1) {
-; CHECK: [[FRAMEPTR:%.*]] = bitcast i8* %0 to %f.Frame*
-; CHECK: [[TMP:%.*]] = getelementptr inbounds %f.Frame, %f.Frame* [[FRAMEPTR]], i32 0, i32 0
+; CHECK-LABEL: define { ptr, ptr } @f(ptr %buffer) {
+; CHECK: [[PROJ2:%.*]] = getelementptr inbounds { i64, i64 }, ptr %buffer, i64 0, i32 1
+; CHECK: store i64 0, ptr %buffer
+; CHECK: store i64 0, ptr [[PROJ2]]
+; CHECK: [[ESCAPED_ADDR:%.*]] = ptrtoint ptr %buffer to i64
+; CHECK: call void @init(ptr %buffer)
+; CHECK: call void @init(ptr [[PROJ2]])
+; CHECK: call void @use_addr_val(i64 [[ESCAPED_ADDR]], ptr %buffer)
+
+; CHECK-LABEL: define internal void @f.resume.0(ptr {{.*}} %0, i1 %1) {
; CHECK: resume:
-; CHECK: [[CAST:%.*]] = bitcast { i64, i64 }* [[TMP]] to i8*
-; CHECK: call void @use(i8* [[CAST]])
+; CHECK: call void @use(ptr %0)
-declare token @llvm.coro.id.retcon.once(i32, i32, i8*, i8*, i8*, i8*)
-declare i8* @llvm.coro.begin(token, i8*)
+declare token @llvm.coro.id.retcon.once(i32, i32, ptr, ptr, ptr, ptr)
+declare ptr @llvm.coro.begin(token, ptr)
declare i1 @llvm.coro.suspend.retcon.i1(...)
-declare i1 @llvm.coro.end(i8*, i1)
+declare i1 @llvm.coro.end(ptr, i1)
diff --git a/llvm/test/Transforms/Coroutines/coro-spill-corobegin.ll b/llvm/test/Transforms/Coroutines/coro-spill-corobegin.ll
index 8edfb5112ccd0..7e19fd6b76d10 100644
--- a/llvm/test/Transforms/Coroutines/coro-spill-corobegin.ll
+++ b/llvm/test/Transforms/Coroutines/coro-spill-corobegin.ll
@@ -1,71 +1,69 @@
; Check that we can spills coro.begin from an inlined inner coroutine.
-; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
-%g.Frame = type { void (%g.Frame*)*, void (%g.Frame*)*, i32, i1, i32 }
+%g.Frame = type { ptr, ptr, i32, i1, i32 }
- at g.resumers = private constant [3 x void (%g.Frame*)*] [void (%g.Frame*)* @g.dummy, void (%g.Frame*)* @g.dummy, void (%g.Frame*)* @g.dummy]
+ at g.resumers = private constant [3 x ptr] [ptr @g.dummy, ptr @g.dummy, ptr @g.dummy]
-declare void @g.dummy(%g.Frame*)
+declare void @g.dummy(ptr)
-declare i8* @g()
+declare ptr @g()
-define i8* @f() presplitcoroutine {
+define ptr @f() presplitcoroutine {
entry:
- %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
+ %id = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
%size = call i32 @llvm.coro.size.i32()
- %alloc = call i8* @malloc(i32 %size)
- %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
+ %alloc = call ptr @malloc(i32 %size)
+ %hdl = call ptr @llvm.coro.begin(token %id, ptr %alloc)
- %innerid = call token @llvm.coro.id(i32 0, i8* null, i8* bitcast (i8* ()* @g to i8*), i8* bitcast ([3 x void (%g.Frame*)*]* @g.resumers to i8*))
- %innerhdl = call noalias nonnull i8* @llvm.coro.begin(token %innerid, i8* null)
- %gframe = bitcast i8* %innerhdl to %g.Frame*
+ %innerid = call token @llvm.coro.id(i32 0, ptr null, ptr @g, ptr @g.resumers)
+ %innerhdl = call noalias nonnull ptr @llvm.coro.begin(token %innerid, ptr null)
%tok = call i8 @llvm.coro.suspend(token none, i1 false)
switch i8 %tok, label %suspend [i8 0, label %resume
i8 1, label %cleanup]
resume:
- %gvar.addr = getelementptr inbounds %g.Frame, %g.Frame* %gframe, i32 0, i32 4
- %gvar = load i32, i32* %gvar.addr
+ %gvar.addr = getelementptr inbounds %g.Frame, ptr %innerhdl, i32 0, i32 4
+ %gvar = load i32, ptr %gvar.addr
call void @print.i32(i32 %gvar)
br label %cleanup
cleanup:
- %mem = call i8* @llvm.coro.free(token %id, i8* %hdl)
- call void @free(i8* %mem)
+ %mem = call ptr @llvm.coro.free(token %id, ptr %hdl)
+ call void @free(ptr %mem)
br label %suspend
suspend:
- call i1 @llvm.coro.end(i8* %hdl, i1 0)
- ret i8* %hdl
+ call i1 @llvm.coro.end(ptr %hdl, i1 0)
+ ret ptr %hdl
}
; See if the i8* for coro.begin was added to f.Frame
-; CHECK-LABEL: %f.Frame = type { void (%f.Frame*)*, void (%f.Frame*)*, i8*, i1 }
+; CHECK-LABEL: %f.Frame = type { ptr, ptr, ptr, i1 }
; See if the g's coro.begin was spilled into the frame
; CHECK-LABEL: @f(
-; CHECK: %innerid = call token @llvm.coro.id(i32 0, i8* null, i8* bitcast (i8* ()* @g to i8*), i8* bitcast ([3 x void (%g.Frame*)*]* @g.resumers to i8*))
-; CHECK: %innerhdl = call noalias nonnull i8* @llvm.coro.begin(token %innerid, i8* null)
-; CHECK: %[[spilladdr:.+]] = getelementptr inbounds %f.Frame, %f.Frame* %FramePtr, i32 0, i32 2
-; CHECK: store i8* %innerhdl, i8** %[[spilladdr]]
+; CHECK: %innerid = call token @llvm.coro.id(i32 0, ptr null, ptr @g, ptr @g.resumers)
+; CHECK: %innerhdl = call noalias nonnull ptr @llvm.coro.begin(token %innerid, ptr null)
+; CHECK: %[[spilladdr:.+]] = getelementptr inbounds %f.Frame, ptr %hdl, i32 0, i32 2
+; CHECK: store ptr %innerhdl, ptr %[[spilladdr]]
; See if the coro.begin was loaded from the frame
; CHECK-LABEL: @f.resume(
-; CHECK: %[[innerhdlAddr:.+]] = getelementptr inbounds %f.Frame, %f.Frame* %{{.+}}, i32 0, i32 2
-; CHECK: %[[innerhdl:.+]] = load i8*, i8** %[[innerhdlAddr]]
-; CHECK: %[[gframe:.+]] = bitcast i8* %[[innerhdl]] to %g.Frame*
-; CHECK: %[[gvarAddr:.+]] = getelementptr inbounds %g.Frame, %g.Frame* %[[gframe]], i32 0, i32 4
-; CHECK: %[[gvar:.+]] = load i32, i32* %[[gvarAddr]]
+; CHECK: %[[innerhdlAddr:.+]] = getelementptr inbounds %f.Frame, ptr %{{.+}}, i32 0, i32 2
+; CHECK: %[[innerhdl:.+]] = load ptr, ptr %[[innerhdlAddr]]
+; CHECK: %[[gvarAddr:.+]] = getelementptr inbounds %g.Frame, ptr %[[innerhdl]], i32 0, i32 4
+; CHECK: %[[gvar:.+]] = load i32, ptr %[[gvarAddr]]
; CHECK: call void @print.i32(i32 %[[gvar]])
-declare i8* @llvm.coro.free(token, i8*)
+declare ptr @llvm.coro.free(token, ptr)
declare i32 @llvm.coro.size.i32()
declare i8 @llvm.coro.suspend(token, i1)
-declare token @llvm.coro.id(i32, i8*, i8*, i8*)
+declare token @llvm.coro.id(i32, ptr, ptr, ptr)
declare i1 @llvm.coro.alloc(token)
-declare i8* @llvm.coro.begin(token, i8*)
-declare i1 @llvm.coro.end(i8*, i1)
+declare ptr @llvm.coro.begin(token, ptr)
+declare i1 @llvm.coro.end(ptr, i1)
-declare noalias i8* @malloc(i32)
+declare noalias ptr @malloc(i32)
declare void @print.i32(i32)
-declare void @free(i8*)
+declare void @free(ptr)
diff --git a/llvm/test/Transforms/Coroutines/coro-spill-defs-before-corobegin.ll b/llvm/test/Transforms/Coroutines/coro-spill-defs-before-corobegin.ll
index 640d1ee9cf648..12b24df00c1de 100644
--- a/llvm/test/Transforms/Coroutines/coro-spill-defs-before-corobegin.ll
+++ b/llvm/test/Transforms/Coroutines/coro-spill-defs-before-corobegin.ll
@@ -1,12 +1,12 @@
; Verifies that phi and invoke definitions before CoroBegin are spilled properly.
-; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s
-define i8* @f(i1 %n) presplitcoroutine personality i32 0 {
+define ptr @f(i1 %n) presplitcoroutine personality i32 0 {
entry:
- %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
+ %id = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
%size = call i32 @llvm.coro.size.i32()
- %alloc = call i8* @malloc(i32 %size)
- %flag = call i1 @check(i8* %alloc)
+ %alloc = call ptr @malloc(i32 %size)
+ %flag = call i1 @check(ptr %alloc)
br i1 %flag, label %flag_true, label %flag_false
flag_true:
@@ -20,7 +20,7 @@ merge:
%value_invoke = invoke i32 @calc() to label %normal unwind label %lpad
normal:
- %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
+ %hdl = call ptr @llvm.coro.begin(token %id, ptr %alloc)
call i32 @print(i32 %value_phi)
call i32 @print(i32 %value_invoke)
%sp1 = call i8 @llvm.coro.suspend(token none, i1 false)
@@ -32,48 +32,48 @@ resume:
br label %cleanup
cleanup:
- %mem = call i8* @llvm.coro.free(token %id, i8* %hdl)
- call void @free(i8* %mem)
+ %mem = call ptr @llvm.coro.free(token %id, ptr %hdl)
+ call void @free(ptr %mem)
br label %suspend
suspend:
- call i1 @llvm.coro.end(i8* %hdl, i1 0)
- ret i8* %hdl
+ call i1 @llvm.coro.end(ptr %hdl, i1 0)
+ ret ptr %hdl
lpad:
- %lpval = landingpad { i8*, i32 }
+ %lpval = landingpad { ptr, i32 }
cleanup
- resume { i8*, i32 } %lpval
+ resume { ptr, i32 } %lpval
}
; Verifies that the both value_phi and value_invoke are stored correctly in the coroutine frame
-; CHECK: %f.Frame = type { void (%f.Frame*)*, void (%f.Frame*)*, i32, i32, i1 }
+; CHECK: %f.Frame = type { ptr, ptr, i32, i32, i1 }
; CHECK-LABEL: @f(
-; CHECK: %alloc = call i8* @malloc(i32 32)
-; CHECK-NEXT: %flag = call i1 @check(i8* %alloc)
+; CHECK: %alloc = call ptr @malloc(i32 32)
+; CHECK-NEXT: %flag = call i1 @check(ptr %alloc)
; CHECK-NEXT: %spec.select = select i1 %flag, i32 0, i32 1
; CHECK-NEXT: %value_invoke = call i32 @calc()
-; CHECK-NEXT: %hdl = call noalias nonnull i8* @llvm.coro.begin(token %id, i8* %alloc)
+; CHECK-NEXT: %hdl = call noalias nonnull ptr @llvm.coro.begin(token %id, ptr %alloc)
-; CHECK: store void (%f.Frame*)* @f.destroy, void (%f.Frame*)** %destroy.addr
-; CHECK-NEXT: %value_invoke.spill.addr = getelementptr inbounds %f.Frame, %f.Frame* %FramePtr, i32 0, i32 3
-; CHECK-NEXT: store i32 %value_invoke, i32* %value_invoke.spill.addr
-; CHECK-NEXT: %value_phi.spill.addr = getelementptr inbounds %f.Frame, %f.Frame* %FramePtr, i32 0, i32 2
-; CHECK-NEXT: store i32 %spec.select, i32* %value_phi.spill.addr
+; CHECK: store ptr @f.destroy, ptr %destroy.addr
+; CHECK-NEXT: %value_invoke.spill.addr = getelementptr inbounds %f.Frame, ptr %hdl, i32 0, i32 3
+; CHECK-NEXT: store i32 %value_invoke, ptr %value_invoke.spill.addr
+; CHECK-NEXT: %value_phi.spill.addr = getelementptr inbounds %f.Frame, ptr %hdl, i32 0, i32 2
+; CHECK-NEXT: store i32 %spec.select, ptr %value_phi.spill.addr
-declare i8* @llvm.coro.free(token, i8*)
+declare ptr @llvm.coro.free(token, ptr)
declare i32 @llvm.coro.size.i32()
declare i8 @llvm.coro.suspend(token, i1)
-declare void @llvm.coro.resume(i8*)
-declare void @llvm.coro.destroy(i8*)
+declare void @llvm.coro.resume(ptr)
+declare void @llvm.coro.destroy(ptr)
-declare token @llvm.coro.id(i32, i8*, i8*, i8*)
+declare token @llvm.coro.id(i32, ptr, ptr, ptr)
declare i1 @llvm.coro.alloc(token)
-declare i8* @llvm.coro.begin(token, i8*)
-declare i1 @llvm.coro.end(i8*, i1)
+declare ptr @llvm.coro.begin(token, ptr)
+declare i1 @llvm.coro.end(ptr, i1)
-declare noalias i8* @malloc(i32)
+declare noalias ptr @malloc(i32)
declare i32 @print(i32)
-declare i1 @check(i8*)
+declare i1 @check(ptr)
declare i32 @calc()
-declare void @free(i8*)
+declare void @free(ptr)
diff --git a/llvm/test/Transforms/Coroutines/coro-spill-promise.ll b/llvm/test/Transforms/Coroutines/coro-spill-promise.ll
index c8949ae48a1f4..8e15d41a1c35b 100644
--- a/llvm/test/Transforms/Coroutines/coro-spill-promise.ll
+++ b/llvm/test/Transforms/Coroutines/coro-spill-promise.ll
@@ -1,56 +1,55 @@
; Check that promise object is reloaded from the correct index of the coro frame.
-; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
%"class.task::promise_type" = type { [64 x i8] }
-declare void @consume(i32*)
-declare void @consume2(%"class.task::promise_type"*)
+declare void @consume(ptr)
+declare void @consume2(ptr)
-define i8* @f() presplitcoroutine {
+define ptr @f() presplitcoroutine {
entry:
%data = alloca i32, align 4
%__promise = alloca %"class.task::promise_type", align 64
- %pv = bitcast %"class.task::promise_type"* %__promise to i8*
- %id = call token @llvm.coro.id(i32 0, i8* %pv, i8* null, i8* null)
+ %id = call token @llvm.coro.id(i32 0, ptr %__promise, ptr null, ptr null)
%size = call i32 @llvm.coro.size.i32()
- %alloc = call i8* @malloc(i32 %size)
- %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
- call void @consume(i32* %data)
+ %alloc = call ptr @malloc(i32 %size)
+ %hdl = call ptr @llvm.coro.begin(token %id, ptr %alloc)
+ call void @consume(ptr %data)
%0 = call i8 @llvm.coro.suspend(token none, i1 false)
switch i8 %0, label %suspend [i8 0, label %resume
i8 1, label %cleanup]
resume:
- call void @consume(i32* %data)
- call void @consume2(%"class.task::promise_type"* %__promise)
+ call void @consume(ptr %data)
+ call void @consume2(ptr %__promise)
br label %cleanup
cleanup:
- %mem = call i8* @llvm.coro.free(token %id, i8* %hdl)
- call void @free(i8* %mem)
+ %mem = call ptr @llvm.coro.free(token %id, ptr %hdl)
+ call void @free(ptr %mem)
br label %suspend
suspend:
- call i1 @llvm.coro.end(i8* %hdl, i1 0)
- ret i8* %hdl
+ call i1 @llvm.coro.end(ptr %hdl, i1 0)
+ ret ptr %hdl
}
-; CHECK-LABEL: %f.Frame = type { void (%f.Frame*)*, void (%f.Frame*)*, i32, i1, [43 x i8], %"class.task::promise_type" }
+; CHECK-LABEL: %f.Frame = type { ptr, ptr, i32, i1, [43 x i8], %"class.task::promise_type" }
; CHECK-LABEL: @f.resume(
-; CHECK: %[[DATA:.+]] = getelementptr inbounds %f.Frame, %f.Frame* %FramePtr, i32 0, i32 5
-; CHECK: call void @consume2(%"class.task::promise_type"* %[[DATA]])
+; CHECK: %[[DATA:.+]] = getelementptr inbounds %f.Frame, ptr %hdl, i32 0, i32 5
+; CHECK: call void @consume2(ptr %[[DATA]])
; CHECK: ret void
-declare i8* @llvm.coro.free(token, i8*)
+declare ptr @llvm.coro.free(token, ptr)
declare i32 @llvm.coro.size.i32()
declare i8 @llvm.coro.suspend(token, i1)
-declare void @llvm.coro.resume(i8*)
-declare void @llvm.coro.destroy(i8*)
+declare void @llvm.coro.resume(ptr)
+declare void @llvm.coro.destroy(ptr)
-declare token @llvm.coro.id(i32, i8*, i8*, i8*)
+declare token @llvm.coro.id(i32, ptr, ptr, ptr)
declare i1 @llvm.coro.alloc(token)
-declare i8* @llvm.coro.begin(token, i8*)
-declare i1 @llvm.coro.end(i8*, i1)
+declare ptr @llvm.coro.begin(token, ptr)
+declare i1 @llvm.coro.end(ptr, i1)
-declare noalias i8* @malloc(i32)
+declare noalias ptr @malloc(i32)
declare double @print(double)
-declare void @free(i8*)
+declare void @free(ptr)
diff --git a/llvm/test/Transforms/Coroutines/coro-split-00.ll b/llvm/test/Transforms/Coroutines/coro-split-00.ll
index e2bd466d6c120..c75aff50dab6c 100644
--- a/llvm/test/Transforms/Coroutines/coro-split-00.ll
+++ b/llvm/test/Transforms/Coroutines/coro-split-00.ll
@@ -1,20 +1,20 @@
; Tests that coro-split pass splits the coroutine into f, f.resume and f.destroy
-; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
-define i8* @f() presplitcoroutine !func_sanitize !0 {
+define ptr @f() presplitcoroutine !func_sanitize !0 {
entry:
- %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
+ %id = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
%need.alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %need.alloc, label %dyn.alloc, label %begin
dyn.alloc:
%size = call i32 @llvm.coro.size.i32()
- %alloc = call i8* @malloc(i32 %size)
+ %alloc = call ptr @malloc(i32 %size)
br label %begin
begin:
- %phi = phi i8* [ null, %entry ], [ %alloc, %dyn.alloc ]
- %hdl = call i8* @llvm.coro.begin(token %id, i8* %phi)
+ %phi = phi ptr [ null, %entry ], [ %alloc, %dyn.alloc ]
+ %hdl = call ptr @llvm.coro.begin(token %id, ptr %phi)
call void @print(i32 0)
%0 = call i8 @llvm.coro.suspend(token none, i1 false)
switch i8 %0, label %suspend [i8 0, label %resume
@@ -24,27 +24,27 @@ resume:
br label %cleanup
cleanup:
- %mem = call i8* @llvm.coro.free(token %id, i8* %hdl)
- call void @free(i8* %mem)
+ %mem = call ptr @llvm.coro.free(token %id, ptr %hdl)
+ call void @free(ptr %mem)
br label %suspend
suspend:
- call i1 @llvm.coro.end(i8* %hdl, i1 0)
- ret i8* %hdl
+ call i1 @llvm.coro.end(ptr %hdl, i1 0)
+ ret ptr %hdl
}
; CHECK-LABEL: @f() !func_sanitize !0 {
-; CHECK: call i8* @malloc
-; CHECK: @llvm.coro.begin(token %id, i8* %phi)
-; CHECK: store void (%f.Frame*)* @f.resume, void (%f.Frame*)** %resume.addr
-; CHECK: %[[SEL:.+]] = select i1 %need.alloc, void (%f.Frame*)* @f.destroy, void (%f.Frame*)* @f.cleanup
-; CHECK: store void (%f.Frame*)* %[[SEL]], void (%f.Frame*)** %destroy.addr
+; CHECK: call ptr @malloc
+; CHECK: @llvm.coro.begin(token %id, ptr %phi)
+; CHECK: store ptr @f.resume, ptr %hdl
+; CHECK: %[[SEL:.+]] = select i1 %need.alloc, ptr @f.destroy, ptr @f.cleanup
+; CHECK: store ptr %[[SEL]], ptr %destroy.addr
; CHECK: call void @print(i32 0)
; CHECK-NOT: call void @print(i32 1)
; CHECK-NOT: call void @free(
-; CHECK: ret i8* %hdl
+; CHECK: ret ptr %hdl
; CHECK-LABEL: @f.resume({{.*}}) {
-; CHECK-NOT: call i8* @malloc
+; CHECK-NOT: call ptr @malloc
; CHECK-NOT: call void @print(i32 0)
; CHECK: call void @print(i32 1)
; CHECK-NOT: call void @print(i32 0)
@@ -52,30 +52,30 @@ suspend:
; CHECK: ret void
; CHECK-LABEL: @f.destroy({{.*}}) {
-; CHECK-NOT: call i8* @malloc
+; CHECK-NOT: call ptr @malloc
; CHECK-NOT: call void @print(
; CHECK: call void @free(
; CHECK: ret void
; CHECK-LABEL: @f.cleanup({{.*}}) {
-; CHECK-NOT: call i8* @malloc
+; CHECK-NOT: call ptr @malloc
; CHECK-NOT: call void @print(
; CHECK-NOT: call void @free(
; CHECK: ret void
-declare i8* @llvm.coro.free(token, i8*)
+declare ptr @llvm.coro.free(token, ptr)
declare i32 @llvm.coro.size.i32()
declare i8 @llvm.coro.suspend(token, i1)
-declare void @llvm.coro.resume(i8*)
-declare void @llvm.coro.destroy(i8*)
+declare void @llvm.coro.resume(ptr)
+declare void @llvm.coro.destroy(ptr)
-declare token @llvm.coro.id(i32, i8*, i8*, i8*)
+declare token @llvm.coro.id(i32, ptr, ptr, ptr)
declare i1 @llvm.coro.alloc(token)
-declare i8* @llvm.coro.begin(token, i8*)
-declare i1 @llvm.coro.end(i8*, i1)
+declare ptr @llvm.coro.begin(token, ptr)
+declare i1 @llvm.coro.end(ptr, i1)
-declare noalias i8* @malloc(i32) allockind("alloc,uninitialized") "alloc-family"="malloc"
+declare noalias ptr @malloc(i32) allockind("alloc,uninitialized") "alloc-family"="malloc"
declare void @print(i32)
-declare void @free(i8*) willreturn allockind("free") "alloc-family"="malloc"
+declare void @free(ptr) willreturn allockind("free") "alloc-family"="malloc"
-!0 = !{i32 846595819, i8** null}
+!0 = !{i32 846595819, ptr null}
diff --git a/llvm/test/Transforms/Coroutines/coro-split-02.ll b/llvm/test/Transforms/Coroutines/coro-split-02.ll
index 187b2567ae164..ed09f009f9b83 100644
--- a/llvm/test/Transforms/Coroutines/coro-split-02.ll
+++ b/llvm/test/Transforms/Coroutines/coro-split-02.ll
@@ -1,70 +1,65 @@
; Tests that coro-split can handle the case when a code after coro.suspend uses
; a value produces between coro.save and coro.suspend (%Result.i19)
; and checks whether stray coro.saves are properly removed
-; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s
-%"struct.std::coroutine_handle" = type { i8* }
+%"struct.std::coroutine_handle" = type { ptr }
%"struct.std::coroutine_handle.0" = type { %"struct.std::coroutine_handle" }
%"struct.lean_future<int>::Awaiter" = type { i32, %"struct.std::coroutine_handle.0" }
-declare i8* @malloc(i64)
+declare ptr @malloc(i64)
declare void @print(i32)
define void @a() presplitcoroutine {
entry:
%ref.tmp7 = alloca %"struct.lean_future<int>::Awaiter", align 8
%testval = alloca i32
- %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
- %alloc = call i8* @malloc(i64 16) #3
- %vFrame = call noalias nonnull i8* @llvm.coro.begin(token %id, i8* %alloc)
+ %id = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
+ %alloc = call ptr @malloc(i64 16) #3
+ %vFrame = call noalias nonnull ptr @llvm.coro.begin(token %id, ptr %alloc)
- %save = call token @llvm.coro.save(i8* null)
- %Result.i19 = getelementptr inbounds %"struct.lean_future<int>::Awaiter", %"struct.lean_future<int>::Awaiter"* %ref.tmp7, i64 0, i32 0
+ %save = call token @llvm.coro.save(ptr null)
%suspend = call i8 @llvm.coro.suspend(token %save, i1 false)
switch i8 %suspend, label %exit [
i8 0, label %await.ready
i8 1, label %exit
]
await.ready:
- %StrayCoroSave = call token @llvm.coro.save(i8* null)
- %val = load i32, i32* %Result.i19
- %cast = bitcast i32* %testval to i8*
- call void @llvm.lifetime.start.p0i8(i64 4, i8* %cast)
- %test = load i32, i32* %testval
+ %StrayCoroSave = call token @llvm.coro.save(ptr null)
+ %val = load i32, ptr %ref.tmp7
+ call void @llvm.lifetime.start.p0(i64 4, ptr %testval)
+ %test = load i32, ptr %testval
call void @print(i32 %test)
- call void @llvm.lifetime.end.p0i8(i64 4, i8* %cast)
+ call void @llvm.lifetime.end.p0(i64 4, ptr %testval)
call void @print(i32 %val)
br label %exit
exit:
- call i1 @llvm.coro.end(i8* null, i1 false)
+ call i1 @llvm.coro.end(ptr null, i1 false)
ret void
}
; CHECK-LABEL: @a.resume(
; CHECK: %testval = alloca i32
-; CHECK: getelementptr inbounds %a.Frame
-; CHECK-NEXT: getelementptr inbounds %"struct.lean_future<int>::Awaiter"
-; CHECK-NOT: call token @llvm.coro.save(i8* null)
-; CHECK-NEXT: %val = load i32, i32* %Result
-; CHECK-NEXT: %cast = bitcast i32* %testval to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 4, i8* %cast)
-; CHECK-NEXT: %test = load i32, i32* %testval
+; CHECK-NOT: call token @llvm.coro.save(ptr null)
+; CHECK: %val = load i32, ptr %ref.tmp7
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 4, ptr %testval)
+; CHECK-NEXT: %test = load i32, ptr %testval
; CHECK-NEXT: call void @print(i32 %test)
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 4, i8* %cast)
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 4, ptr %testval)
; CHECK-NEXT: call void @print(i32 %val)
; CHECK-NEXT: ret void
-declare token @llvm.coro.id(i32, i8* readnone, i8* nocapture readonly, i8*)
+declare token @llvm.coro.id(i32, ptr readnone, ptr nocapture readonly, ptr)
declare i1 @llvm.coro.alloc(token) #3
-declare noalias nonnull i8* @"\01??2 at YAPEAX_K@Z"(i64) local_unnamed_addr
+declare noalias nonnull ptr @"\01??2 at YAPEAX_K@Z"(i64) local_unnamed_addr
declare i64 @llvm.coro.size.i64() #5
-declare i8* @llvm.coro.begin(token, i8* writeonly) #3
+declare ptr @llvm.coro.begin(token, ptr writeonly) #3
declare void @"\01?puts@@YAXZZ"(...)
-declare token @llvm.coro.save(i8*) #3
-declare i8* @llvm.coro.frame() #5
+declare token @llvm.coro.save(ptr) #3
+declare ptr @llvm.coro.frame() #5
declare i8 @llvm.coro.suspend(token, i1) #3
-declare void @"\01??3 at YAXPEAX@Z"(i8*) local_unnamed_addr #10
-declare i8* @llvm.coro.free(token, i8* nocapture readonly) #2
-declare i1 @llvm.coro.end(i8*, i1) #3
-declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #4
-declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #4
+declare void @"\01??3 at YAXPEAX@Z"(ptr) local_unnamed_addr #10
+declare ptr @llvm.coro.free(token, ptr nocapture readonly) #2
+declare i1 @llvm.coro.end(ptr, i1) #3
+declare void @llvm.lifetime.start.p0(i64, ptr nocapture) #4
+declare void @llvm.lifetime.end.p0(i64, ptr nocapture) #4
diff --git a/llvm/test/Transforms/Coroutines/coro-split-eh-00.ll b/llvm/test/Transforms/Coroutines/coro-split-eh-00.ll
index 520797bb1fa36..d2bb1bbb98891 100644
--- a/llvm/test/Transforms/Coroutines/coro-split-eh-00.ll
+++ b/llvm/test/Transforms/Coroutines/coro-split-eh-00.ll
@@ -1,11 +1,11 @@
; Tests that coro-split removes cleanup code after coro.end in resume functions
; and retains it in the start function.
-; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
-define i8* @f(i1 %val) presplitcoroutine personality i32 3 {
+define ptr @f(i1 %val) presplitcoroutine personality i32 3 {
entry:
- %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
- %hdl = call i8* @llvm.coro.begin(token %id, i8* null)
+ %id = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
+ %hdl = call ptr @llvm.coro.begin(token %id, ptr null)
call void @print(i32 0)
br i1 %val, label %resume, label %susp
@@ -17,16 +17,16 @@ resume:
invoke void @print(i32 1) to label %suspend unwind label %lpad
suspend:
- call i1 @llvm.coro.end(i8* %hdl, i1 0)
+ call i1 @llvm.coro.end(ptr %hdl, i1 0)
call void @print(i32 0) ; should not be present in f.resume
- ret i8* %hdl
+ ret ptr %hdl
lpad:
- %lpval = landingpad { i8*, i32 }
+ %lpval = landingpad { ptr, i32 }
cleanup
call void @print(i32 2)
- %need.resume = call i1 @llvm.coro.end(i8* null, i1 true)
+ %need.resume = call i1 @llvm.coro.end(ptr null, i1 true)
br i1 %need.resume, label %eh.resume, label %cleanup.cont
cleanup.cont:
@@ -34,24 +34,24 @@ cleanup.cont:
br label %eh.resume
eh.resume:
- resume { i8*, i32 } %lpval
+ resume { ptr, i32 } %lpval
}
; Verify that start function contains both print calls the one before and after coro.end
-; CHECK-LABEL: define i8* @f(
+; CHECK-LABEL: define ptr @f(
; CHECK: invoke void @print(i32 1)
; CHECK: to label %AfterCoroEnd unwind label %lpad
; CHECK: AfterCoroEnd:
; CHECK: call void @print(i32 0)
-; CHECK: ret i8* %hdl
+; CHECK: ret ptr %hdl
; CHECK: lpad:
-; CHECK-NEXT: %lpval = landingpad { i8*, i32 }
+; CHECK-NEXT: %lpval = landingpad { ptr, i32 }
; CHECK-NEXT: cleanup
; CHECK-NEXT: call void @print(i32 2)
; CHECK-NEXT: call void @print(i32 3)
-; CHECK-NEXT: resume { i8*, i32 } %lpval
+; CHECK-NEXT: resume { ptr, i32 } %lpval
; VERIFY Resume Parts
@@ -64,25 +64,24 @@ eh.resume:
; CHECK-NEXT: ret void
; CHECK: lpad:
-; CHECK-NEXT: %lpval = landingpad { i8*, i32 }
+; CHECK-NEXT: %lpval = landingpad { ptr, i32 }
; CHECK-NEXT: cleanup
; CHECK-NEXT: call void @print(i32 2)
; Checks that the coroutine would be marked as done if it exits in unwinding path.
-; CHECK-NEXT: %[[RESUME_ADDR:.+]] = getelementptr inbounds %[[FRAME_TY:.+]], %[[FRAME_TY]]* %FramePtr, i32 0, i32 0
-; CHECK-NEXT: store void (%[[FRAME_TY]]*)* null, void (%[[FRAME_TY]]*)** %[[RESUME_ADDR]], align 8
-; CHECK-NEXT: resume { i8*, i32 } %lpval
+; CHECK-NEXT: store ptr null, ptr %hdl, align 8
+; CHECK-NEXT: resume { ptr, i32 } %lpval
-declare i8* @llvm.coro.free(token, i8*)
+declare ptr @llvm.coro.free(token, ptr)
declare i32 @llvm.coro.size.i32()
declare i8 @llvm.coro.suspend(token, i1)
-declare void @llvm.coro.resume(i8*)
-declare void @llvm.coro.destroy(i8*)
+declare void @llvm.coro.resume(ptr)
+declare void @llvm.coro.destroy(ptr)
-declare token @llvm.coro.id(i32, i8*, i8*, i8*)
-declare i8* @llvm.coro.alloc(token)
-declare i8* @llvm.coro.begin(token, i8*)
-declare i1 @llvm.coro.end(i8*, i1)
+declare token @llvm.coro.id(i32, ptr, ptr, ptr)
+declare ptr @llvm.coro.alloc(token)
+declare ptr @llvm.coro.begin(token, ptr)
+declare i1 @llvm.coro.end(ptr, i1)
-declare noalias i8* @malloc(i32)
+declare noalias ptr @malloc(i32)
declare void @print(i32)
-declare void @free(i8*)
+declare void @free(ptr)
diff --git a/llvm/test/Transforms/Coroutines/coro-split-eh-01.ll b/llvm/test/Transforms/Coroutines/coro-split-eh-01.ll
index 63fe96cd9efa6..835d399d55b54 100644
--- a/llvm/test/Transforms/Coroutines/coro-split-eh-01.ll
+++ b/llvm/test/Transforms/Coroutines/coro-split-eh-01.ll
@@ -1,11 +1,11 @@
; Tests that coro-split removes cleanup code after coro.end in resume functions
; and retains it in the start function.
-; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
-define i8* @f2(i1 %val) presplitcoroutine personality i32 4 {
+define ptr @f2(i1 %val) presplitcoroutine personality i32 4 {
entry:
- %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
- %hdl = call i8* @llvm.coro.begin(token %id, i8* null)
+ %id = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
+ %hdl = call ptr @llvm.coro.begin(token %id, ptr null)
call void @print(i32 0)
br i1 %val, label %resume, label %susp
@@ -17,14 +17,14 @@ resume:
invoke void @print(i32 1) to label %suspend unwind label %lpad
suspend:
- call i1 @llvm.coro.end(i8* %hdl, i1 0)
+ call i1 @llvm.coro.end(ptr %hdl, i1 0)
call void @print(i32 0) ; should not be present in f.resume
- ret i8* %hdl
+ ret ptr %hdl
lpad:
%tok = cleanuppad within none []
call void @print(i32 2)
- %unused = call i1 @llvm.coro.end(i8* null, i1 true) [ "funclet"(token %tok) ]
+ %unused = call i1 @llvm.coro.end(ptr null, i1 true) [ "funclet"(token %tok) ]
cleanupret from %tok unwind label %cleanup.cont
cleanup.cont:
@@ -34,13 +34,13 @@ cleanup.cont:
}
; Verify that start function contains both print calls the one before and after coro.end
-; CHECK-LABEL: define i8* @f2(
+; CHECK-LABEL: define ptr @f2(
; CHECK: invoke void @print(i32 1)
; CHECK: to label %AfterCoroEnd unwind label %lpad
; CHECK: AfterCoroEnd:
; CHECK: call void @print(i32 0)
-; CHECK: ret i8* %hdl
+; CHECK: ret ptr %hdl
; CHECK: lpad:
; CHECK-NEXT: %tok = cleanuppad within none []
@@ -62,21 +62,20 @@ cleanup.cont:
; CHECK-NEXT: %tok = cleanuppad within none []
; CHECK-NEXT: call void @print(i32 2)
; Checks that the coroutine would be marked as done if it exits in unwinding path.
-; CHECK-NEXT: %[[RESUME_ADDR:.+]] = getelementptr inbounds %[[FRAME_TY:.+]], %[[FRAME_TY]]* %FramePtr, i32 0, i32 0
-; CHECK-NEXT: store void (%[[FRAME_TY]]*)* null, void (%[[FRAME_TY]]*)** %[[RESUME_ADDR]], align 8
+; CHECK-NEXT: store ptr null, ptr %hdl, align 8
; CHECK-NEXT: cleanupret from %tok unwind to caller
-declare i8* @llvm.coro.free(token, i8*)
+declare ptr @llvm.coro.free(token, ptr)
declare i32 @llvm.coro.size.i32()
declare i8 @llvm.coro.suspend(token, i1)
-declare void @llvm.coro.resume(i8*)
-declare void @llvm.coro.destroy(i8*)
+declare void @llvm.coro.resume(ptr)
+declare void @llvm.coro.destroy(ptr)
-declare token @llvm.coro.id(i32, i8*, i8*, i8*)
-declare i8* @llvm.coro.alloc(token)
-declare i8* @llvm.coro.begin(token, i8*)
-declare i1 @llvm.coro.end(i8*, i1)
+declare token @llvm.coro.id(i32, ptr, ptr, ptr)
+declare ptr @llvm.coro.alloc(token)
+declare ptr @llvm.coro.begin(token, ptr)
+declare i1 @llvm.coro.end(ptr, i1)
-declare noalias i8* @malloc(i32)
+declare noalias ptr @malloc(i32)
declare void @print(i32)
-declare void @free(i8*)
+declare void @free(ptr)
diff --git a/llvm/test/Transforms/Coroutines/coro-split-hidden.ll b/llvm/test/Transforms/Coroutines/coro-split-hidden.ll
index fedf16176df89..aebc0bb8d93ba 100644
--- a/llvm/test/Transforms/Coroutines/coro-split-hidden.ll
+++ b/llvm/test/Transforms/Coroutines/coro-split-hidden.ll
@@ -1,22 +1,22 @@
; Tests that coro-split can convert functions with hidden visibility.
; These may be generated by a frontend such as Clang, when inlining with
; '-fvisibility-inlines-hidden'.
-; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
-define hidden i8* @f() presplitcoroutine {
+define hidden ptr @f() presplitcoroutine {
entry:
- %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
+ %id = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
%need.alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %need.alloc, label %dyn.alloc, label %begin
dyn.alloc:
%size = call i32 @llvm.coro.size.i32()
- %alloc = call i8* @malloc(i32 %size)
+ %alloc = call ptr @malloc(i32 %size)
br label %begin
begin:
- %phi = phi i8* [ null, %entry ], [ %alloc, %dyn.alloc ]
- %hdl = call i8* @llvm.coro.begin(token %id, i8* %phi)
+ %phi = phi ptr [ null, %entry ], [ %alloc, %dyn.alloc ]
+ %hdl = call ptr @llvm.coro.begin(token %id, ptr %phi)
call void @print(i32 0)
%0 = call i8 @llvm.coro.suspend(token none, i1 false)
switch i8 %0, label %suspend [i8 0, label %resume
@@ -26,27 +26,27 @@ resume:
br label %cleanup
cleanup:
- %mem = call i8* @llvm.coro.free(token %id, i8* %hdl)
- call void @free(i8* %mem)
+ %mem = call ptr @llvm.coro.free(token %id, ptr %hdl)
+ call void @free(ptr %mem)
br label %suspend
suspend:
- call i1 @llvm.coro.end(i8* %hdl, i1 0)
- ret i8* %hdl
+ call i1 @llvm.coro.end(ptr %hdl, i1 0)
+ ret ptr %hdl
}
; CHECK-LABEL: hidden{{.*}}@f(
-; CHECK: call i8* @malloc
-; CHECK: @llvm.coro.begin(token %id, i8* %phi)
-; CHECK: store void (%f.Frame*)* @f.resume, void (%f.Frame*)** %resume.addr
-; CHECK: %[[SEL:.+]] = select i1 %need.alloc, void (%f.Frame*)* @f.destroy, void (%f.Frame*)* @f.cleanup
-; CHECK: store void (%f.Frame*)* %[[SEL]], void (%f.Frame*)** %destroy.addr
+; CHECK: call ptr @malloc
+; CHECK: @llvm.coro.begin(token %id, ptr %phi)
+; CHECK: store ptr @f.resume, ptr %hdl
+; CHECK: %[[SEL:.+]] = select i1 %need.alloc, ptr @f.destroy, ptr @f.cleanup
+; CHECK: store ptr %[[SEL]], ptr %destroy.addr
; CHECK: call void @print(i32 0)
; CHECK-NOT: call void @print(i32 1)
; CHECK-NOT: call void @free(
-; CHECK: ret i8* %hdl
+; CHECK: ret ptr %hdl
; CHECK-LABEL: internal{{.*}}@f.resume(
-; CHECK-NOT: call i8* @malloc
+; CHECK-NOT: call ptr @malloc
; CHECK-NOT: call void @print(i32 0)
; CHECK: call void @print(i32 1)
; CHECK-NOT: call void @print(i32 0)
@@ -54,28 +54,28 @@ suspend:
; CHECK: ret void
; CHECK-LABEL: internal{{.*}}@f.destroy(
-; CHECK-NOT: call i8* @malloc
+; CHECK-NOT: call ptr @malloc
; CHECK-NOT: call void @print(
; CHECK: call void @free(
; CHECK: ret void
; CHECK-LABEL: internal{{.*}}@f.cleanup(
-; CHECK-NOT: call i8* @malloc
+; CHECK-NOT: call ptr @malloc
; CHECK-NOT: call void @print(
; CHECK-NOT: call void @free(
; CHECK: ret void
-declare i8* @llvm.coro.free(token, i8*)
+declare ptr @llvm.coro.free(token, ptr)
declare i32 @llvm.coro.size.i32()
declare i8 @llvm.coro.suspend(token, i1)
-declare void @llvm.coro.resume(i8*)
-declare void @llvm.coro.destroy(i8*)
+declare void @llvm.coro.resume(ptr)
+declare void @llvm.coro.destroy(ptr)
-declare token @llvm.coro.id(i32, i8*, i8*, i8*)
+declare token @llvm.coro.id(i32, ptr, ptr, ptr)
declare i1 @llvm.coro.alloc(token)
-declare i8* @llvm.coro.begin(token, i8*)
-declare i1 @llvm.coro.end(i8*, i1)
+declare ptr @llvm.coro.begin(token, ptr)
+declare i1 @llvm.coro.end(ptr, i1)
-declare noalias i8* @malloc(i32) allockind("alloc,uninitialized")
+declare noalias ptr @malloc(i32) allockind("alloc,uninitialized")
declare void @print(i32)
-declare void @free(i8*) willreturn allockind("free")
+declare void @free(ptr) willreturn allockind("free")
diff --git a/llvm/test/Transforms/Coroutines/coro-split-sink-lifetime-01.ll b/llvm/test/Transforms/Coroutines/coro-split-sink-lifetime-01.ll
index d7978c98153e6..442e1d24e85de 100644
--- a/llvm/test/Transforms/Coroutines/coro-split-sink-lifetime-01.ll
+++ b/llvm/test/Transforms/Coroutines/coro-split-sink-lifetime-01.ll
@@ -1,58 +1,53 @@
; Tests that coro-split will optimize the lifetime.start maker of each local variable,
; sink them to the places after the suspend block.
-; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s
-; CHECK: %a.Frame = type { void (%a.Frame*)*, void (%a.Frame*)*, %"struct.lean_future<int>::Awaiter", i1 }
-; CHECK: %a_optnone.Frame = type { void (%a_optnone.Frame*)*, void (%a_optnone.Frame*)*, %"struct.lean_future<int>::Awaiter", i8*, i32*, i32, i1 }
+; CHECK: %a.Frame = type { ptr, ptr, i1 }
+; CHECK: %a_optnone.Frame = type { ptr, ptr, i32, i1 }
-%"struct.std::coroutine_handle" = type { i8* }
+%"struct.std::coroutine_handle" = type { ptr }
%"struct.std::coroutine_handle.0" = type { %"struct.std::coroutine_handle" }
%"struct.lean_future<int>::Awaiter" = type { i32, %"struct.std::coroutine_handle.0" }
-declare i8* @malloc(i64)
+declare ptr @malloc(i64)
declare void @print(i32)
define void @a() presplitcoroutine {
entry:
%ref.tmp7 = alloca %"struct.lean_future<int>::Awaiter", align 8
%testval = alloca i32
- %cast = bitcast i32* %testval to i8*
; lifetime of %testval starts here, but not used until await.ready.
- call void @llvm.lifetime.start.p0i8(i64 4, i8* %cast)
- %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
- %alloc = call i8* @malloc(i64 16) #3
- %vFrame = call noalias nonnull i8* @llvm.coro.begin(token %id, i8* %alloc)
+ call void @llvm.lifetime.start.p0(i64 4, ptr %testval)
+ %id = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
+ %alloc = call ptr @malloc(i64 16) #3
+ %vFrame = call noalias nonnull ptr @llvm.coro.begin(token %id, ptr %alloc)
- %save = call token @llvm.coro.save(i8* null)
- %Result.i19 = getelementptr inbounds %"struct.lean_future<int>::Awaiter", %"struct.lean_future<int>::Awaiter"* %ref.tmp7, i64 0, i32 0
+ %save = call token @llvm.coro.save(ptr null)
%suspend = call i8 @llvm.coro.suspend(token %save, i1 false)
switch i8 %suspend, label %exit [
i8 0, label %await.ready
i8 1, label %exit
]
await.ready:
- %StrayCoroSave = call token @llvm.coro.save(i8* null)
- %val = load i32, i32* %Result.i19
- %test = load i32, i32* %testval
+ %StrayCoroSave = call token @llvm.coro.save(ptr null)
+ %val = load i32, ptr %ref.tmp7
+ %test = load i32, ptr %testval
call void @print(i32 %test)
- call void @llvm.lifetime.end.p0i8(i64 4, i8* %cast)
+ call void @llvm.lifetime.end.p0(i64 4, ptr %testval)
call void @print(i32 %val)
br label %exit
exit:
- call i1 @llvm.coro.end(i8* null, i1 false)
+ call i1 @llvm.coro.end(ptr null, i1 false)
ret void
}
; CHECK-LABEL: @a.resume(
; CHECK: %testval = alloca i32, align 4
-; CHECK-NEXT: getelementptr inbounds %a.Frame
-; CHECK-NEXT: %0 = bitcast i32* %testval to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 4, i8* %0)
-; CHECK-NEXT: getelementptr inbounds %"struct.lean_future<int>::Awaiter"
-; CHECK-NEXT: %val = load i32, i32* %Result
-; CHECK-NEXT: %test = load i32, i32* %testval
+; CHECK: call void @llvm.lifetime.start.p0(i64 4, ptr %testval)
+; CHECK-NEXT: %val = load i32, ptr %ref.tmp7
+; CHECK-NEXT: %test = load i32, ptr %testval
; CHECK-NEXT: call void @print(i32 %test)
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 4, i8* %0)
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 4, ptr %testval)
; CHECK-NEXT: call void @print(i32 %val)
; CHECK-NEXT: ret void
@@ -60,44 +55,42 @@ define void @a_optnone() presplitcoroutine optnone noinline {
entry:
%ref.tmp7 = alloca %"struct.lean_future<int>::Awaiter", align 8
%testval = alloca i32
- %cast = bitcast i32* %testval to i8*
; lifetime of %testval starts here, but not used until await.ready.
- call void @llvm.lifetime.start.p0i8(i64 4, i8* %cast)
- %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
- %alloc = call i8* @malloc(i64 16) #3
- %vFrame = call noalias nonnull i8* @llvm.coro.begin(token %id, i8* %alloc)
+ call void @llvm.lifetime.start.p0(i64 4, ptr %testval)
+ %id = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
+ %alloc = call ptr @malloc(i64 16) #3
+ %vFrame = call noalias nonnull ptr @llvm.coro.begin(token %id, ptr %alloc)
- %save = call token @llvm.coro.save(i8* null)
- %Result.i19 = getelementptr inbounds %"struct.lean_future<int>::Awaiter", %"struct.lean_future<int>::Awaiter"* %ref.tmp7, i64 0, i32 0
+ %save = call token @llvm.coro.save(ptr null)
%suspend = call i8 @llvm.coro.suspend(token %save, i1 false)
switch i8 %suspend, label %exit [
i8 0, label %await.ready
i8 1, label %exit
]
await.ready:
- %StrayCoroSave = call token @llvm.coro.save(i8* null)
- %val = load i32, i32* %Result.i19
- %test = load i32, i32* %testval
+ %StrayCoroSave = call token @llvm.coro.save(ptr null)
+ %val = load i32, ptr %ref.tmp7
+ %test = load i32, ptr %testval
call void @print(i32 %test)
- call void @llvm.lifetime.end.p0i8(i64 4, i8* %cast)
+ call void @llvm.lifetime.end.p0(i64 4, ptr %testval)
call void @print(i32 %val)
br label %exit
exit:
- call i1 @llvm.coro.end(i8* null, i1 false)
+ call i1 @llvm.coro.end(ptr null, i1 false)
ret void
}
-declare token @llvm.coro.id(i32, i8* readnone, i8* nocapture readonly, i8*)
+declare token @llvm.coro.id(i32, ptr readnone, ptr nocapture readonly, ptr)
declare i1 @llvm.coro.alloc(token) #3
-declare noalias nonnull i8* @"\01??2 at YAPEAX_K@Z"(i64) local_unnamed_addr
+declare noalias nonnull ptr @"\01??2 at YAPEAX_K@Z"(i64) local_unnamed_addr
declare i64 @llvm.coro.size.i64() #5
-declare i8* @llvm.coro.begin(token, i8* writeonly) #3
+declare ptr @llvm.coro.begin(token, ptr writeonly) #3
declare void @"\01?puts@@YAXZZ"(...)
-declare token @llvm.coro.save(i8*) #3
-declare i8* @llvm.coro.frame() #5
+declare token @llvm.coro.save(ptr) #3
+declare ptr @llvm.coro.frame() #5
declare i8 @llvm.coro.suspend(token, i1) #3
-declare void @"\01??3 at YAXPEAX@Z"(i8*) local_unnamed_addr #10
-declare i8* @llvm.coro.free(token, i8* nocapture readonly) #2
-declare i1 @llvm.coro.end(i8*, i1) #3
-declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #4
-declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #4
+declare void @"\01??3 at YAXPEAX@Z"(ptr) local_unnamed_addr #10
+declare ptr @llvm.coro.free(token, ptr nocapture readonly) #2
+declare i1 @llvm.coro.end(ptr, i1) #3
+declare void @llvm.lifetime.start.p0(i64, ptr nocapture) #4
+declare void @llvm.lifetime.end.p0(i64, ptr nocapture) #4
diff --git a/llvm/test/Transforms/Coroutines/coro-split-sink-lifetime-03.ll b/llvm/test/Transforms/Coroutines/coro-split-sink-lifetime-03.ll
index f88273e9aca77..6b845f97368eb 100644
--- a/llvm/test/Transforms/Coroutines/coro-split-sink-lifetime-03.ll
+++ b/llvm/test/Transforms/Coroutines/coro-split-sink-lifetime-03.ll
@@ -1,70 +1,64 @@
; Corresponding to coro-split-sink-lifetime-01.ll. This file tests that whether the CoroFrame
; pass knows the operand of lifetime.start intrinsic may be GEP as well.
-; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s
-%"struct.std::coroutine_handle" = type { i8* }
+%"struct.std::coroutine_handle" = type { ptr }
%"struct.std::coroutine_handle.0" = type { %"struct.std::coroutine_handle" }
%"struct.lean_future<int>::Awaiter" = type { i32, %"struct.std::coroutine_handle.0" }
-declare i8* @malloc(i64)
+declare ptr @malloc(i64)
declare void @print(i32)
%i8.array = type { [100 x i8] }
-declare void @consume.i8.array(%i8.array*)
+declare void @consume.i8.array(ptr)
define void @a.gep() presplitcoroutine {
entry:
%ref.tmp7 = alloca %"struct.lean_future<int>::Awaiter", align 8
%testval = alloca %i8.array
- %cast = getelementptr inbounds %i8.array, %i8.array* %testval, i64 0, i32 0, i64 0
; lifetime of %testval starts here, but not used until await.ready.
- call void @llvm.lifetime.start.p0i8(i64 100, i8* %cast)
- %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
- %alloc = call i8* @malloc(i64 16) #3
- %vFrame = call noalias nonnull i8* @llvm.coro.begin(token %id, i8* %alloc)
+ call void @llvm.lifetime.start.p0(i64 100, ptr %testval)
+ %id = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
+ %alloc = call ptr @malloc(i64 16) #3
+ %vFrame = call noalias nonnull ptr @llvm.coro.begin(token %id, ptr %alloc)
- %save = call token @llvm.coro.save(i8* null)
- %Result.i19 = getelementptr inbounds %"struct.lean_future<int>::Awaiter", %"struct.lean_future<int>::Awaiter"* %ref.tmp7, i64 0, i32 0
+ %save = call token @llvm.coro.save(ptr null)
%suspend = call i8 @llvm.coro.suspend(token %save, i1 false)
switch i8 %suspend, label %exit [
i8 0, label %await.ready
i8 1, label %exit
]
await.ready:
- %StrayCoroSave = call token @llvm.coro.save(i8* null)
- %val = load i32, i32* %Result.i19
- call void @consume.i8.array(%i8.array* %testval)
- call void @llvm.lifetime.end.p0i8(i64 100, i8* %cast)
+ %StrayCoroSave = call token @llvm.coro.save(ptr null)
+ %val = load i32, ptr %ref.tmp7
+ call void @consume.i8.array(ptr %testval)
+ call void @llvm.lifetime.end.p0(i64 100, ptr %testval)
call void @print(i32 %val)
br label %exit
exit:
- call i1 @llvm.coro.end(i8* null, i1 false)
+ call i1 @llvm.coro.end(ptr null, i1 false)
ret void
}
; CHECK-LABEL: @a.gep.resume(
; CHECK: %testval = alloca %i8.array
-; CHECK-NEXT: getelementptr inbounds %a.gep.Frame
-; CHECK-NEXT: %0 = bitcast %i8.array* %testval to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 100, i8* %0)
-; CHECK-NEXT: getelementptr inbounds %"struct.lean_future<int>::Awaiter"
-; CHECK-NEXT: getelementptr inbounds %i8.array, %i8.array* %testval
-; CHECK-NEXT: %val = load i32, i32* %Result
-; CHECK-NEXT: call void @consume.i8.array(%i8.array* %testval)
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 100, i8* %cast1)
+; CHECK: call void @llvm.lifetime.start.p0(i64 100, ptr %testval)
+; CHECK-NEXT: %val = load i32, ptr %ref.tmp7
+; CHECK-NEXT: call void @consume.i8.array(ptr %testval)
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 100, ptr %testval)
; CHECK-NEXT: call void @print(i32 %val)
; CHECK-NEXT: ret void
-declare token @llvm.coro.id(i32, i8* readnone, i8* nocapture readonly, i8*)
+declare token @llvm.coro.id(i32, ptr readnone, ptr nocapture readonly, ptr)
declare i1 @llvm.coro.alloc(token) #3
-declare noalias nonnull i8* @"\01??2 at YAPEAX_K@Z"(i64) local_unnamed_addr
+declare noalias nonnull ptr @"\01??2 at YAPEAX_K@Z"(i64) local_unnamed_addr
declare i64 @llvm.coro.size.i64() #5
-declare i8* @llvm.coro.begin(token, i8* writeonly) #3
+declare ptr @llvm.coro.begin(token, ptr writeonly) #3
declare void @"\01?puts@@YAXZZ"(...)
-declare token @llvm.coro.save(i8*) #3
-declare i8* @llvm.coro.frame() #5
+declare token @llvm.coro.save(ptr) #3
+declare ptr @llvm.coro.frame() #5
declare i8 @llvm.coro.suspend(token, i1) #3
-declare void @"\01??3 at YAXPEAX@Z"(i8*) local_unnamed_addr #10
-declare i8* @llvm.coro.free(token, i8* nocapture readonly) #2
-declare i1 @llvm.coro.end(i8*, i1) #3
-declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #4
-declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #4
+declare void @"\01??3 at YAXPEAX@Z"(ptr) local_unnamed_addr #10
+declare ptr @llvm.coro.free(token, ptr nocapture readonly) #2
+declare i1 @llvm.coro.end(ptr, i1) #3
+declare void @llvm.lifetime.start.p0(i64, ptr nocapture) #4
+declare void @llvm.lifetime.end.p0(i64, ptr nocapture) #4
diff --git a/llvm/test/Transforms/Coroutines/coro-split-sink-lifetime-04.ll b/llvm/test/Transforms/Coroutines/coro-split-sink-lifetime-04.ll
index c17bbe5a07019..ddb45108d6786 100644
--- a/llvm/test/Transforms/Coroutines/coro-split-sink-lifetime-04.ll
+++ b/llvm/test/Transforms/Coroutines/coro-split-sink-lifetime-04.ll
@@ -1,12 +1,12 @@
; Tests that coro-split will optimize the lifetime.start maker of each local variable,
; sink them to the places after the suspend block.
-; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s
-%"struct.std::coroutine_handle" = type { i8* }
+%"struct.std::coroutine_handle" = type { ptr }
%"struct.std::coroutine_handle.0" = type { %"struct.std::coroutine_handle" }
%"struct.lean_future<int>::Awaiter" = type { i32, %"struct.std::coroutine_handle.0" }
-declare i8* @malloc(i64)
+declare ptr @malloc(i64)
declare void @print(i32)
declare void @consume.i8(i8)
@@ -15,55 +15,52 @@ entry:
%ref.tmp7 = alloca %"struct.lean_future<int>::Awaiter", align 8
%testval = alloca i8
; lifetime of %testval starts here, but not used until await.ready.
- call void @llvm.lifetime.start.p0i8(i64 1, i8* %testval)
- %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
- %alloc = call i8* @malloc(i64 16) #3
- %vFrame = call noalias nonnull i8* @llvm.coro.begin(token %id, i8* %alloc)
+ call void @llvm.lifetime.start.p0(i64 1, ptr %testval)
+ %id = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
+ %alloc = call ptr @malloc(i64 16) #3
+ %vFrame = call noalias nonnull ptr @llvm.coro.begin(token %id, ptr %alloc)
- %save = call token @llvm.coro.save(i8* null)
- %Result.i19 = getelementptr inbounds %"struct.lean_future<int>::Awaiter", %"struct.lean_future<int>::Awaiter"* %ref.tmp7, i64 0, i32 0
+ %save = call token @llvm.coro.save(ptr null)
%suspend = call i8 @llvm.coro.suspend(token %save, i1 false)
switch i8 %suspend, label %exit [
i8 0, label %await.ready
i8 1, label %exit
]
await.ready:
- %StrayCoroSave = call token @llvm.coro.save(i8* null)
- %val = load i32, i32* %Result.i19
- %test = load i8, i8* %testval
+ %StrayCoroSave = call token @llvm.coro.save(ptr null)
+ %val = load i32, ptr %ref.tmp7
+ %test = load i8, ptr %testval
call void @consume.i8(i8 %test)
- call void @llvm.lifetime.end.p0i8(i64 1, i8* %testval)
+ call void @llvm.lifetime.end.p0(i64 1, ptr %testval)
call void @print(i32 %val)
br label %exit
exit:
- call i1 @llvm.coro.end(i8* null, i1 false)
+ call i1 @llvm.coro.end(ptr null, i1 false)
ret void
}
; CHECK-LABEL: @a.resume(
; CHECK: %testval = alloca i8, align 1
-; CHECK-NEXT: getelementptr inbounds %a.Frame
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 1, i8* %testval)
-; CHECK-NEXT: getelementptr inbounds %"struct.lean_future<int>::Awaiter"
-; CHECK-NEXT: %val = load i32, i32* %Result
-; CHECK-NEXT: %test = load i8, i8* %testval
+; CHECK: call void @llvm.lifetime.start.p0(i64 1, ptr %testval)
+; CHECK-NEXT: %val = load i32, ptr %ref.tmp7
+; CHECK-NEXT: %test = load i8, ptr %testval
; CHECK-NEXT: call void @consume.i8(i8 %test)
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 1, i8* %testval)
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 1, ptr %testval)
; CHECK-NEXT: call void @print(i32 %val)
; CHECK-NEXT: ret void
-declare token @llvm.coro.id(i32, i8* readnone, i8* nocapture readonly, i8*)
+declare token @llvm.coro.id(i32, ptr readnone, ptr nocapture readonly, ptr)
declare i1 @llvm.coro.alloc(token) #3
-declare noalias nonnull i8* @"\01??2 at YAPEAX_K@Z"(i64) local_unnamed_addr
+declare noalias nonnull ptr @"\01??2 at YAPEAX_K@Z"(i64) local_unnamed_addr
declare i64 @llvm.coro.size.i64() #5
-declare i8* @llvm.coro.begin(token, i8* writeonly) #3
+declare ptr @llvm.coro.begin(token, ptr writeonly) #3
declare void @"\01?puts@@YAXZZ"(...)
-declare token @llvm.coro.save(i8*) #3
-declare i8* @llvm.coro.frame() #5
+declare token @llvm.coro.save(ptr) #3
+declare ptr @llvm.coro.frame() #5
declare i8 @llvm.coro.suspend(token, i1) #3
-declare void @"\01??3 at YAXPEAX@Z"(i8*) local_unnamed_addr #10
-declare i8* @llvm.coro.free(token, i8* nocapture readonly) #2
-declare i1 @llvm.coro.end(i8*, i1) #3
-declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #4
-declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #4
+declare void @"\01??3 at YAXPEAX@Z"(ptr) local_unnamed_addr #10
+declare ptr @llvm.coro.free(token, ptr nocapture readonly) #2
+declare i1 @llvm.coro.end(ptr, i1) #3
+declare void @llvm.lifetime.start.p0(i64, ptr nocapture) #4
+declare void @llvm.lifetime.end.p0(i64, ptr nocapture) #4
diff --git a/llvm/test/Transforms/Coroutines/coro-zero-alloca.ll b/llvm/test/Transforms/Coroutines/coro-zero-alloca.ll
index 098bbf9988fa0..14a5be073211c 100644
--- a/llvm/test/Transforms/Coroutines/coro-zero-alloca.ll
+++ b/llvm/test/Transforms/Coroutines/coro-zero-alloca.ll
@@ -1,17 +1,17 @@
-; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
-declare i8* @malloc(i64)
-declare void @free(i8*)
-declare void @usePointer(i8*)
-declare void @usePointer2([0 x i8]*)
+declare ptr @malloc(i64)
+declare void @free(ptr)
+declare void @usePointer(ptr)
+declare void @usePointer2(ptr)
-declare token @llvm.coro.id(i32, i8* readnone, i8* nocapture readonly, i8*)
+declare token @llvm.coro.id(i32, ptr readnone, ptr nocapture readonly, ptr)
declare i64 @llvm.coro.size.i64()
-declare i8* @llvm.coro.begin(token, i8* writeonly)
+declare ptr @llvm.coro.begin(token, ptr writeonly)
declare i8 @llvm.coro.suspend(token, i1)
-declare i1 @llvm.coro.end(i8*, i1)
-declare i8* @llvm.coro.free(token, i8* nocapture readonly)
-declare token @llvm.coro.save(i8*)
+declare i1 @llvm.coro.end(ptr, i1)
+declare ptr @llvm.coro.free(token, ptr nocapture readonly)
+declare token @llvm.coro.save(ptr)
define void @foo() presplitcoroutine {
entry:
@@ -21,16 +21,11 @@ entry:
%a3 = alloca [0 x i8]
%a4 = alloca i16
%a5 = alloca [0 x i8]
- %a0.cast = bitcast [0 x i8]* %a0 to i8*
- %a1.cast = bitcast i32* %a1 to i8*
- %a2.cast = bitcast [0 x i8]* %a2 to i8*
- %a3.cast = bitcast [0 x i8]* %a3 to i8*
- %a4.cast = bitcast i16* %a4 to i8*
- %coro.id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
+ %coro.id = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
%coro.size = call i64 @llvm.coro.size.i64()
- %coro.alloc = call i8* @malloc(i64 %coro.size)
- %coro.state = call i8* @llvm.coro.begin(token %coro.id, i8* %coro.alloc)
- %coro.save = call token @llvm.coro.save(i8* %coro.state)
+ %coro.alloc = call ptr @malloc(i64 %coro.size)
+ %coro.state = call ptr @llvm.coro.begin(token %coro.id, ptr %coro.alloc)
+ %coro.save = call token @llvm.coro.save(ptr %coro.state)
%call.suspend = call i8 @llvm.coro.suspend(token %coro.save, i1 false)
switch i8 %call.suspend, label %suspend [
i8 0, label %wakeup
@@ -38,41 +33,35 @@ entry:
]
wakeup: ; preds = %entry
- call void @usePointer(i8* %a0.cast)
- call void @usePointer(i8* %a1.cast)
- call void @usePointer(i8* %a2.cast)
- call void @usePointer(i8* %a3.cast)
- call void @usePointer(i8* %a4.cast)
- call void @usePointer2([0 x i8]* %a5)
+ call void @usePointer(ptr %a0)
+ call void @usePointer(ptr %a1)
+ call void @usePointer(ptr %a2)
+ call void @usePointer(ptr %a3)
+ call void @usePointer(ptr %a4)
+ call void @usePointer2(ptr %a5)
br label %cleanup
suspend: ; preds = %cleanup, %entry
- %unused = call i1 @llvm.coro.end(i8* %coro.state, i1 false)
+ %unused = call i1 @llvm.coro.end(ptr %coro.state, i1 false)
ret void
cleanup: ; preds = %wakeup, %entry
- %coro.memFree = call i8* @llvm.coro.free(token %coro.id, i8* %coro.state)
- call void @free(i8* %coro.memFree)
+ %coro.memFree = call ptr @llvm.coro.free(token %coro.id, ptr %coro.state)
+ call void @free(ptr %coro.memFree)
br label %suspend
}
-; CHECK: %foo.Frame = type { void (%foo.Frame*)*, void (%foo.Frame*)*, i32, i16, i1 }
+; CHECK: %foo.Frame = type { ptr, ptr, i32, i16, i1 }
; CHECK-LABEL: @foo.resume(
; CHECK-NEXT: entry.resume:
-; CHECK-NEXT: [[VFRAME:%.*]] = bitcast %foo.Frame* [[FRAMEPTR:%.*]] to i8*
-; CHECK-NEXT: [[TMP0:%.*]] = getelementptr inbounds [[FOO_FRAME:%.*]], %foo.Frame* [[FRAMEPTR]], i32 0, i32 0
-; CHECK-NEXT: [[A0_RELOAD_ADDR:%.*]] = bitcast void (%foo.Frame*)** [[TMP0]] to [0 x i8]*
-; CHECK-NEXT: [[A1_RELOAD_ADDR:%.*]] = getelementptr inbounds [[FOO_FRAME]], %foo.Frame* [[FRAMEPTR]], i32 0, i32 2
-; CHECK-NEXT: [[A4_RELOAD_ADDR:%.*]] = getelementptr inbounds [[FOO_FRAME]], %foo.Frame* [[FRAMEPTR]], i32 0, i32 3
-; CHECK-NEXT: [[A4_CAST5:%.*]] = bitcast i16* [[A4_RELOAD_ADDR]] to i8*
-; CHECK-NEXT: [[A3_CAST4:%.*]] = bitcast [0 x i8]* [[A0_RELOAD_ADDR]] to i8*
-; CHECK-NEXT: [[A1_CAST2:%.*]] = bitcast i32* [[A1_RELOAD_ADDR]] to i8*
-; CHECK-NEXT: call void @usePointer(i8* [[A3_CAST4]])
-; CHECK-NEXT: call void @usePointer(i8* [[A1_CAST2]])
-; CHECK-NEXT: call void @usePointer(i8* [[A3_CAST4]])
-; CHECK-NEXT: call void @usePointer(i8* [[A3_CAST4]])
-; CHECK-NEXT: call void @usePointer(i8* [[A4_CAST5]])
-; CHECK-NEXT: call void @usePointer2([0 x i8]* [[A0_RELOAD_ADDR]])
-; CHECK-NEXT: call void @free(i8* [[VFRAME]])
+; CHECK-NEXT: [[A1_RELOAD_ADDR:%.*]] = getelementptr inbounds [[FOO_FRAME:%foo.Frame]], ptr [[FRAMEPTR:%.*]], i32 0, i32 2
+; CHECK-NEXT: [[A4_RELOAD_ADDR:%.*]] = getelementptr inbounds [[FOO_FRAME]], ptr [[FRAMEPTR]], i32 0, i32 3
+; CHECK-NEXT: call void @usePointer(ptr [[FRAMEPTR]])
+; CHECK-NEXT: call void @usePointer(ptr [[A1_RELOAD_ADDR]])
+; CHECK-NEXT: call void @usePointer(ptr [[FRAMEPTR]])
+; CHECK-NEXT: call void @usePointer(ptr [[FRAMEPTR]])
+; CHECK-NEXT: call void @usePointer(ptr [[A4_RELOAD_ADDR]])
+; CHECK-NEXT: call void @usePointer2(ptr [[FRAMEPTR]])
+; CHECK-NEXT: call void @free(ptr [[FRAMEPTR]])
; CHECK-NEXT: ret void
diff --git a/llvm/test/Transforms/Coroutines/no-suspend.ll b/llvm/test/Transforms/Coroutines/no-suspend.ll
index d7d7a5855ce13..dbbdd7feda187 100644
--- a/llvm/test/Transforms/Coroutines/no-suspend.ll
+++ b/llvm/test/Transforms/Coroutines/no-suspend.ll
@@ -1,40 +1,38 @@
; Test no suspend coroutines
-; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s
; Coroutine with no-suspends will turn into:
;
; CHECK-LABEL: define void @no_suspends(
; CHECK-NEXT: entry:
-; CHECK-NEXT: alloca
-; CHECK-NEXT: bitcast
; CHECK-NEXT: call void @print(i32 %n)
; CHECK-NEXT: ret void
;
define void @no_suspends(i32 %n) presplitcoroutine {
entry:
- %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
+ %id = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
%need.dyn.alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin
dyn.alloc:
%size = call i32 @llvm.coro.size.i32()
- %alloc = call i8* @malloc(i32 %size)
+ %alloc = call ptr @malloc(i32 %size)
br label %coro.begin
coro.begin:
- %phi = phi i8* [ null, %entry ], [ %alloc, %dyn.alloc ]
- %hdl = call noalias i8* @llvm.coro.begin(token %id, i8* %phi)
+ %phi = phi ptr [ null, %entry ], [ %alloc, %dyn.alloc ]
+ %hdl = call noalias ptr @llvm.coro.begin(token %id, ptr %phi)
br label %body
body:
call void @print(i32 %n)
br label %cleanup
cleanup:
- %mem = call i8* @llvm.coro.free(token %id, i8* %hdl)
- %need.dyn.free = icmp ne i8* %mem, null
+ %mem = call ptr @llvm.coro.free(token %id, ptr %hdl)
+ %need.dyn.free = icmp ne ptr %mem, null
br i1 %need.dyn.free, label %dyn.free, label %suspend
dyn.free:
- call void @free(i8* %mem)
+ call void @free(ptr %mem)
br label %suspend
suspend:
- call i1 @llvm.coro.end(i8* %hdl, i1 false)
+ call i1 @llvm.coro.end(ptr %hdl, i1 false)
ret void
}
@@ -44,32 +42,29 @@ suspend:
;
; CHECK-LABEL: define void @simplify_resume(
; CHECK-NEXT: entry:
-; CHECK-NEXT: alloca
-; CHECK-NEXT: bitcast
; CHECK-NEXT: call void @llvm.memcpy
; CHECK-NEXT: call void @print(i32 0)
; CHECK-NEXT: ret void
;
-define void @simplify_resume(i8* %src, i8* %dst) presplitcoroutine {
+define void @simplify_resume(ptr %src, ptr %dst) presplitcoroutine {
entry:
- %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
+ %id = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
%need.dyn.alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin
dyn.alloc:
%size = call i32 @llvm.coro.size.i32()
- %alloc = call i8* @malloc(i32 %size)
+ %alloc = call ptr @malloc(i32 %size)
br label %coro.begin
coro.begin:
- %phi = phi i8* [ null, %entry ], [ %alloc, %dyn.alloc ]
- %hdl = call noalias i8* @llvm.coro.begin(token %id, i8* %phi)
+ %phi = phi ptr [ null, %entry ], [ %alloc, %dyn.alloc ]
+ %hdl = call noalias ptr @llvm.coro.begin(token %id, ptr %phi)
br label %body
body:
- %save = call token @llvm.coro.save(i8* %hdl)
+ %save = call token @llvm.coro.save(ptr %hdl)
; memcpy intrinsics should not prevent simplification.
- call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 1, i1 false)
- %subfn = call i8* @llvm.coro.subfn.addr(i8* %hdl, i8 0)
- %bres = bitcast i8* %subfn to void (i8*)*
- call fastcc void %bres(i8* %hdl)
+ call void @llvm.memcpy.p0.p0.i64(ptr %dst, ptr %src, i64 1, i1 false)
+ %subfn = call ptr @llvm.coro.subfn.addr(ptr %hdl, i8 0)
+ call fastcc void %subfn(ptr %hdl)
%0 = call i8 @llvm.coro.suspend(token %save, i1 false)
switch i8 %0, label %suspend [i8 0, label %resume
i8 1, label %pre.cleanup]
@@ -82,11 +77,11 @@ pre.cleanup:
br label %cleanup
cleanup:
- %mem = call i8* @llvm.coro.free(token %id, i8* %hdl)
- call void @free(i8* %mem)
+ %mem = call ptr @llvm.coro.free(token %id, ptr %hdl)
+ call void @free(ptr %mem)
br label %suspend
suspend:
- call i1 @llvm.coro.end(i8* %hdl, i1 false)
+ call i1 @llvm.coro.end(ptr %hdl, i1 false)
ret void
}
@@ -96,29 +91,26 @@ suspend:
;
; CHECK-LABEL: define void @simplify_destroy(
; CHECK-NEXT: entry:
-; CHECK-NEXT: alloca
-; CHECK-NEXT: bitcast
; CHECK-NEXT: call void @print(i32 1)
; CHECK-NEXT: ret void
;
define void @simplify_destroy() presplitcoroutine personality i32 0 {
entry:
- %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
+ %id = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
%need.dyn.alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin
dyn.alloc:
%size = call i32 @llvm.coro.size.i32()
- %alloc = call i8* @malloc(i32 %size)
+ %alloc = call ptr @malloc(i32 %size)
br label %coro.begin
coro.begin:
- %phi = phi i8* [ null, %entry ], [ %alloc, %dyn.alloc ]
- %hdl = call noalias i8* @llvm.coro.begin(token %id, i8* %phi)
+ %phi = phi ptr [ null, %entry ], [ %alloc, %dyn.alloc ]
+ %hdl = call noalias ptr @llvm.coro.begin(token %id, ptr %phi)
br label %body
body:
- %save = call token @llvm.coro.save(i8* %hdl)
- %subfn = call i8* @llvm.coro.subfn.addr(i8* %hdl, i8 1)
- %bcast = bitcast i8* %subfn to void (i8*)*
- invoke fastcc void %bcast(i8* %hdl) to label %real_susp unwind label %lpad
+ %save = call token @llvm.coro.save(ptr %hdl)
+ %subfn = call ptr @llvm.coro.subfn.addr(ptr %hdl, i8 1)
+ invoke fastcc void %subfn(ptr %hdl) to label %real_susp unwind label %lpad
real_susp:
%0 = call i8 @llvm.coro.suspend(token %save, i1 false)
@@ -133,18 +125,18 @@ pre.cleanup:
br label %cleanup
cleanup:
- %mem = call i8* @llvm.coro.free(token %id, i8* %hdl)
- call void @free(i8* %mem)
+ %mem = call ptr @llvm.coro.free(token %id, ptr %hdl)
+ call void @free(ptr %mem)
br label %suspend
suspend:
- call i1 @llvm.coro.end(i8* %hdl, i1 false)
+ call i1 @llvm.coro.end(ptr %hdl, i1 false)
ret void
lpad:
- %lpval = landingpad { i8*, i32 }
+ %lpval = landingpad { ptr, i32 }
cleanup
call void @print(i32 2)
- resume { i8*, i32 } %lpval
+ resume { ptr, i32 } %lpval
}
; SimplifySuspendPoint will detect that coro.resume resumes itself and will
@@ -153,38 +145,35 @@ lpad:
;
; CHECK-LABEL: define void @simplify_resume_with_inlined_if(
; CHECK-NEXT: entry:
-; CHECK-NEXT: alloca
-; CHECK-NEXT: bitcast
; CHECK-NEXT: br i1
; CHECK: call void @print(i32 0)
; CHECK-NEXT: ret void
;
-define void @simplify_resume_with_inlined_if(i8* %src, i8* %dst, i1 %cond) presplitcoroutine {
+define void @simplify_resume_with_inlined_if(ptr %src, ptr %dst, i1 %cond) presplitcoroutine {
entry:
- %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
+ %id = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
%need.dyn.alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin
dyn.alloc:
%size = call i32 @llvm.coro.size.i32()
- %alloc = call i8* @malloc(i32 %size)
+ %alloc = call ptr @malloc(i32 %size)
br label %coro.begin
coro.begin:
- %phi = phi i8* [ null, %entry ], [ %alloc, %dyn.alloc ]
- %hdl = call noalias i8* @llvm.coro.begin(token %id, i8* %phi)
+ %phi = phi ptr [ null, %entry ], [ %alloc, %dyn.alloc ]
+ %hdl = call noalias ptr @llvm.coro.begin(token %id, ptr %phi)
br label %body
body:
- %save = call token @llvm.coro.save(i8* %hdl)
+ %save = call token @llvm.coro.save(ptr %hdl)
br i1 %cond, label %if.then, label %if.else
if.then:
- call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 1, i1 false)
+ call void @llvm.memcpy.p0.p0.i64(ptr %dst, ptr %src, i64 1, i1 false)
br label %if.end
if.else:
- call void @llvm.memcpy.p0i8.p0i8.i64(i8* %src, i8* %dst, i64 1, i1 false)
+ call void @llvm.memcpy.p0.p0.i64(ptr %src, ptr %dst, i64 1, i1 false)
br label %if.end
if.end:
- %subfn = call i8* @llvm.coro.subfn.addr(i8* %hdl, i8 0)
- %bres = bitcast i8* %subfn to void (i8*)*
- call fastcc void %bres(i8* %hdl)
+ %subfn = call ptr @llvm.coro.subfn.addr(ptr %hdl, i8 0)
+ call fastcc void %subfn(ptr %hdl)
%0 = call i8 @llvm.coro.suspend(token %save, i1 false)
switch i8 %0, label %suspend [i8 0, label %resume
i8 1, label %pre.cleanup]
@@ -197,11 +186,11 @@ pre.cleanup:
br label %cleanup
cleanup:
- %mem = call i8* @llvm.coro.free(token %id, i8* %hdl)
- call void @free(i8* %mem)
+ %mem = call ptr @llvm.coro.free(token %id, ptr %hdl)
+ call void @free(ptr %mem)
br label %suspend
suspend:
- call i1 @llvm.coro.end(i8* %hdl, i1 false)
+ call i1 @llvm.coro.end(ptr %hdl, i1 false)
ret void
}
@@ -217,19 +206,19 @@ suspend:
define void @cannot_simplify_other_calls() presplitcoroutine {
entry:
- %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
+ %id = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
%need.dyn.alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin
dyn.alloc:
%size = call i32 @llvm.coro.size.i32()
- %alloc = call i8* @malloc(i32 %size)
+ %alloc = call ptr @malloc(i32 %size)
br label %coro.begin
coro.begin:
- %phi = phi i8* [ null, %entry ], [ %alloc, %dyn.alloc ]
- %hdl = call noalias i8* @llvm.coro.begin(token %id, i8* %phi)
+ %phi = phi ptr [ null, %entry ], [ %alloc, %dyn.alloc ]
+ %hdl = call noalias ptr @llvm.coro.begin(token %id, ptr %phi)
br label %body
body:
- %save = call token @llvm.coro.save(i8* %hdl)
+ %save = call token @llvm.coro.save(ptr %hdl)
br label %body1
body1:
@@ -237,9 +226,8 @@ body1:
br label %body2
body2:
- %subfn = call i8* @llvm.coro.subfn.addr(i8* %hdl, i8 1)
- %bcast = bitcast i8* %subfn to void (i8*)*
- call fastcc void %bcast(i8* %hdl)
+ %subfn = call ptr @llvm.coro.subfn.addr(ptr %hdl, i8 1)
+ call fastcc void %subfn(ptr %hdl)
%0 = call i8 @llvm.coro.suspend(token %save, i1 false)
switch i8 %0, label %suspend [i8 0, label %resume
i8 1, label %pre.cleanup]
@@ -252,11 +240,11 @@ pre.cleanup:
br label %cleanup
cleanup:
- %mem = call i8* @llvm.coro.free(token %id, i8* %hdl)
- call void @free(i8* %mem)
+ %mem = call ptr @llvm.coro.free(token %id, ptr %hdl)
+ call void @free(ptr %mem)
br label %suspend
suspend:
- call i1 @llvm.coro.end(i8* %hdl, i1 false)
+ call i1 @llvm.coro.end(ptr %hdl, i1 false)
ret void
}
@@ -270,24 +258,23 @@ suspend:
define void @cannot_simplify_calls_in_terminator() presplitcoroutine personality i32 0 {
entry:
- %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
+ %id = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
%need.dyn.alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin
dyn.alloc:
%size = call i32 @llvm.coro.size.i32()
- %alloc = call i8* @malloc(i32 %size)
+ %alloc = call ptr @malloc(i32 %size)
br label %coro.begin
coro.begin:
- %phi = phi i8* [ null, %entry ], [ %alloc, %dyn.alloc ]
- %hdl = call noalias i8* @llvm.coro.begin(token %id, i8* %phi)
+ %phi = phi ptr [ null, %entry ], [ %alloc, %dyn.alloc ]
+ %hdl = call noalias ptr @llvm.coro.begin(token %id, ptr %phi)
br label %body
body:
- %save = call token @llvm.coro.save(i8* %hdl)
+ %save = call token @llvm.coro.save(ptr %hdl)
invoke void @foo() to label %resume_cont unwind label %lpad
resume_cont:
- %subfn = call i8* @llvm.coro.subfn.addr(i8* %hdl, i8 1)
- %bcast = bitcast i8* %subfn to void (i8*)*
- call fastcc void %bcast(i8* %hdl)
+ %subfn = call ptr @llvm.coro.subfn.addr(ptr %hdl, i8 1)
+ call fastcc void %subfn(ptr %hdl)
%0 = call i8 @llvm.coro.suspend(token %save, i1 false)
switch i8 %0, label %suspend [i8 0, label %resume
i8 1, label %pre.cleanup]
@@ -300,18 +287,18 @@ pre.cleanup:
br label %cleanup
cleanup:
- %mem = call i8* @llvm.coro.free(token %id, i8* %hdl)
- call void @free(i8* %mem)
+ %mem = call ptr @llvm.coro.free(token %id, ptr %hdl)
+ call void @free(ptr %mem)
br label %suspend
suspend:
- call i1 @llvm.coro.end(i8* %hdl, i1 false)
+ call i1 @llvm.coro.end(ptr %hdl, i1 false)
ret void
lpad:
- %lpval = landingpad { i8*, i32 }
+ %lpval = landingpad { ptr, i32 }
cleanup
call void @print(i32 2)
- resume { i8*, i32 } %lpval
+ resume { ptr, i32 } %lpval
}
; SimplifySuspendPoint won't be able to simplify if it detects that resume or
@@ -321,26 +308,25 @@ lpad:
; CHECK-NEXT: entry:
; CHECK-NEXT: llvm.coro.id
-define void @cannot_simplify_not_last_instr(i8* %dst, i8* %src) presplitcoroutine {
+define void @cannot_simplify_not_last_instr(ptr %dst, ptr %src) presplitcoroutine {
entry:
- %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
+ %id = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
%need.dyn.alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin
dyn.alloc:
%size = call i32 @llvm.coro.size.i32()
- %alloc = call i8* @malloc(i32 %size)
+ %alloc = call ptr @malloc(i32 %size)
br label %coro.begin
coro.begin:
- %phi = phi i8* [ null, %entry ], [ %alloc, %dyn.alloc ]
- %hdl = call noalias i8* @llvm.coro.begin(token %id, i8* %phi)
+ %phi = phi ptr [ null, %entry ], [ %alloc, %dyn.alloc ]
+ %hdl = call noalias ptr @llvm.coro.begin(token %id, ptr %phi)
br label %body
body:
- %save = call token @llvm.coro.save(i8* %hdl)
- %subfn = call i8* @llvm.coro.subfn.addr(i8* %hdl, i8 1)
- %bcast = bitcast i8* %subfn to void (i8*)*
- call fastcc void %bcast(i8* %hdl)
+ %save = call token @llvm.coro.save(ptr %hdl)
+ %subfn = call ptr @llvm.coro.subfn.addr(ptr %hdl, i8 1)
+ call fastcc void %subfn(ptr %hdl)
; memcpy separates destory from suspend, therefore cannot simplify.
- call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 1, i1 false)
+ call void @llvm.memcpy.p0.p0.i64(ptr %dst, ptr %src, i64 1, i1 false)
%0 = call i8 @llvm.coro.suspend(token %save, i1 false)
switch i8 %0, label %suspend [i8 0, label %resume
i8 1, label %pre.cleanup]
@@ -353,11 +339,11 @@ pre.cleanup:
br label %cleanup
cleanup:
- %mem = call i8* @llvm.coro.free(token %id, i8* %hdl)
- call void @free(i8* %mem)
+ %mem = call ptr @llvm.coro.free(token %id, ptr %hdl)
+ call void @free(ptr %mem)
br label %suspend
suspend:
- call i1 @llvm.coro.end(i8* %hdl, i1 false)
+ call i1 @llvm.coro.end(ptr %hdl, i1 false)
ret void
}
@@ -369,22 +355,21 @@ suspend:
;
define void @cannot_simplify_final_suspend() presplitcoroutine personality i32 0 {
entry:
- %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
+ %id = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
%need.dyn.alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin
dyn.alloc:
%size = call i32 @llvm.coro.size.i32()
- %alloc = call i8* @malloc(i32 %size)
+ %alloc = call ptr @malloc(i32 %size)
br label %coro.begin
coro.begin:
- %phi = phi i8* [ null, %entry ], [ %alloc, %dyn.alloc ]
- %hdl = call noalias i8* @llvm.coro.begin(token %id, i8* %phi)
+ %phi = phi ptr [ null, %entry ], [ %alloc, %dyn.alloc ]
+ %hdl = call noalias ptr @llvm.coro.begin(token %id, ptr %phi)
br label %body
body:
- %save = call token @llvm.coro.save(i8* %hdl)
- %subfn = call i8* @llvm.coro.subfn.addr(i8* %hdl, i8 1)
- %bcast = bitcast i8* %subfn to void (i8*)*
- invoke fastcc void %bcast(i8* %hdl) to label %real_susp unwind label %lpad
+ %save = call token @llvm.coro.save(ptr %hdl)
+ %subfn = call ptr @llvm.coro.subfn.addr(ptr %hdl, i8 1)
+ invoke fastcc void %subfn(ptr %hdl) to label %real_susp unwind label %lpad
real_susp:
%0 = call i8 @llvm.coro.suspend(token %save, i1 1)
@@ -399,34 +384,34 @@ pre.cleanup:
br label %cleanup
cleanup:
- %mem = call i8* @llvm.coro.free(token %id, i8* %hdl)
- call void @free(i8* %mem)
+ %mem = call ptr @llvm.coro.free(token %id, ptr %hdl)
+ call void @free(ptr %mem)
br label %suspend
suspend:
- call i1 @llvm.coro.end(i8* %hdl, i1 false)
+ call i1 @llvm.coro.end(ptr %hdl, i1 false)
ret void
lpad:
- %lpval = landingpad { i8*, i32 }
+ %lpval = landingpad { ptr, i32 }
cleanup
call void @print(i32 2)
- resume { i8*, i32 } %lpval
+ resume { ptr, i32 } %lpval
}
-declare i8* @malloc(i32) allockind("alloc,uninitialized") allocsize(0)
-declare void @free(i8*) willreturn allockind("free")
+declare ptr @malloc(i32) allockind("alloc,uninitialized") allocsize(0)
+declare void @free(ptr) willreturn allockind("free")
declare void @print(i32)
declare void @foo()
-declare token @llvm.coro.id(i32, i8*, i8*, i8*)
+declare token @llvm.coro.id(i32, ptr, ptr, ptr)
declare i1 @llvm.coro.alloc(token)
declare i32 @llvm.coro.size.i32()
-declare i8* @llvm.coro.begin(token, i8*)
-declare token @llvm.coro.save(i8* %hdl)
+declare ptr @llvm.coro.begin(token, ptr)
+declare token @llvm.coro.save(ptr %hdl)
declare i8 @llvm.coro.suspend(token, i1)
-declare i8* @llvm.coro.free(token, i8*)
-declare i1 @llvm.coro.end(i8*, i1)
+declare ptr @llvm.coro.free(token, ptr)
+declare i1 @llvm.coro.end(ptr, i1)
-declare i8* @llvm.coro.subfn.addr(i8*, i8)
+declare ptr @llvm.coro.subfn.addr(ptr, i8)
-declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i1)
+declare void @llvm.memcpy.p0.p0.i64(ptr nocapture writeonly, ptr nocapture readonly, i64, i1)
More information about the llvm-commits
mailing list