[llvm-branch-commits] [llvm] llvm-reduce: Change function return types if function is not called (PR #134035)
Matt Arsenault via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Wed Apr 2 00:51:19 PDT 2025
https://github.com/arsenm updated https://github.com/llvm/llvm-project/pull/134035
>From c6252c5dc0d1326a139c73a75b2a7892d0670ad0 Mon Sep 17 00:00:00 2001
From: Matt Arsenault <Matthew.Arsenault at amd.com>
Date: Wed, 2 Apr 2025 11:45:24 +0700
Subject: [PATCH 1/4] llvm-reduce: Change function return types if function is
not called
Extend the early return on value reduction to mutate the function return
type if the function has no call uses. This could be generalized to rewrite
cases where all callsites are used, but it turns out that complicates the
visitation order given we try to compute all opportunities up front.
This is enough to cleanup the common case where we end up with one
function with a return of an uninteresting constant.
---
...reduce-values-to-return-new-return-type.ll | 95 +++++++++++++++++++
.../llvm-reduce/reduce-values-to-return.ll | 20 +++-
.../deltas/ReduceValuesToReturn.cpp | 7 +-
3 files changed, 118 insertions(+), 4 deletions(-)
create mode 100644 llvm/test/tools/llvm-reduce/reduce-values-to-return-new-return-type.ll
diff --git a/llvm/test/tools/llvm-reduce/reduce-values-to-return-new-return-type.ll b/llvm/test/tools/llvm-reduce/reduce-values-to-return-new-return-type.ll
new file mode 100644
index 0000000000000..9ddbbe3def44f
--- /dev/null
+++ b/llvm/test/tools/llvm-reduce/reduce-values-to-return-new-return-type.ll
@@ -0,0 +1,95 @@
+; Test that llvm-reduce can move intermediate values by inserting
+; early returns when the function already has a different return type
+;
+; RUN: llvm-reduce --abort-on-invalid-reduction --delta-passes=instructions-to-return --test FileCheck --test-arg --check-prefix=INTERESTING --test-arg %s --test-arg --input-file %s -o %t
+; RUN: FileCheck --check-prefix=RESULT %s < %t
+
+
+ at gv = global i32 0, align 4
+ at ptr_array = global [2 x ptr] [ptr @inst_to_return_has_different_type_but_no_func_call_use,
+ ptr @multiple_callsites_wrong_return_type]
+
+; Should rewrite this return from i64 to i32 since the function has no
+; uses.
+; INTERESTING-LABEL: @inst_to_return_has_different_type_but_no_func_call_use(
+; RESULT-LABEL: define i32 @inst_to_return_has_different_type_but_no_func_call_use(ptr %arg) {
+; RESULT-NEXT: %load = load i32, ptr %arg, align 4
+; RESULT-NEXT: ret i32 %load
+define i64 @inst_to_return_has_different_type_but_no_func_call_use(ptr %arg) {
+ %load = load i32, ptr %arg
+ store i32 %load, ptr @gv
+ ret i64 0
+}
+
+; INTERESTING-LABEL: @callsite_different_type_unused_0(
+; RESULT-LABEL: define i64 @inst_to_return_has_different_type_but_call_result_unused(
+; RESULT-NEXT: %load = load i32, ptr %arg
+; RESULT-NEXT: store i32 %load, ptr @gv
+; RESULT-NEXT: ret i64 0
+define void @callsite_different_type_unused_0(ptr %arg) {
+ %unused0 = call i64 @inst_to_return_has_different_type_but_call_result_unused(ptr %arg)
+ %unused1 = call i64 @inst_to_return_has_different_type_but_call_result_unused(ptr null)
+ ret void
+}
+
+; TODO: Could rewrite this return from i64 to i32 since the callsite is unused.
+; INTERESTING-LABEL: @inst_to_return_has_different_type_but_call_result_unused(
+; RESULT-LABEL: define i64 @inst_to_return_has_different_type_but_call_result_unused(
+; RESULT: ret i64 0
+define i64 @inst_to_return_has_different_type_but_call_result_unused(ptr %arg) {
+ %load = load i32, ptr %arg
+ store i32 %load, ptr @gv
+ ret i64 0
+}
+
+; INTERESTING-LABEL: @multiple_callsites_wrong_return_type(
+; RESULT-LABEL: define i64 @multiple_callsites_wrong_return_type(
+; RESULT: ret i64 0
+define i64 @multiple_callsites_wrong_return_type(ptr %arg) {
+ %load = load i32, ptr %arg
+ store i32 %load, ptr @gv
+ ret i64 0
+}
+
+; INTERESTING-LABEL: @unused_with_wrong_return_types(
+; RESULT-LABEL: define i64 @unused_with_wrong_return_types(
+; RESULT-NEXT: %unused0 = call i64 @multiple_callsites_wrong_return_type(ptr %arg)
+; RESULT-NEXT: ret i64 %unused0
+define void @unused_with_wrong_return_types(ptr %arg) {
+ %unused0 = call i64 @multiple_callsites_wrong_return_type(ptr %arg)
+ %unused1 = call i32 @multiple_callsites_wrong_return_type(ptr %arg)
+ %unused2 = call ptr @multiple_callsites_wrong_return_type(ptr %arg)
+ ret void
+}
+
+; INTERESTING-LABEL: @multiple_returns_wrong_return_type(
+; INTERESTING: %load0 = load i32,
+
+; RESULT-LABEL: define i32 @multiple_returns_wrong_return_type(
+; RESULT: ret i32
+; RESULT: ret i32
+; RESULT: ret i32
+define i32 @multiple_returns_wrong_return_type(ptr %arg, i1 %cond, i32 %arg2) {
+entry:
+ br i1 %cond, label %bb0, label %bb1
+
+bb0:
+ %load0 = load i32, ptr %arg
+ store i32 %load0, ptr @gv
+ ret i32 234
+
+bb1:
+ ret i32 %arg2
+
+bb2:
+ ret i32 34
+}
+
+; INTERESTING-LABEL: @call_multiple_returns_wrong_return_type(
+; RESULT-LABEL: define <2 x i32> @call_multiple_returns_wrong_return_type(
+; RESULT-NEXT: %unused = call <2 x i32> @multiple_returns_wrong_return_type(
+; RESULT-NEXT: ret <2 x i32> %unused
+define void @call_multiple_returns_wrong_return_type(ptr %arg, i1 %cond, i32 %arg2) {
+ %unused = call <2 x i32> @multiple_returns_wrong_return_type(ptr %arg, i1 %cond, i32 %arg2)
+ ret void
+}
diff --git a/llvm/test/tools/llvm-reduce/reduce-values-to-return.ll b/llvm/test/tools/llvm-reduce/reduce-values-to-return.ll
index 2af87aad05169..77501418f5283 100644
--- a/llvm/test/tools/llvm-reduce/reduce-values-to-return.ll
+++ b/llvm/test/tools/llvm-reduce/reduce-values-to-return.ll
@@ -196,13 +196,25 @@ define i32 @callsite_already_new_return_type(ptr %arg) {
; INTERESTING: ret
; RESULT-LABEL: define ptr @non_void_no_op(
-; RESULT: ret ptr null
+; RESULT-NEXT: %load = load i32, ptr %arg
+; RESULT-NEXT: store i32 %load, ptr @gv
+; RESULT-NEXT: ret ptr null
define ptr @non_void_no_op(ptr %arg) {
%load = load i32, ptr %arg
store i32 %load, ptr @gv
ret ptr null
}
+; INTERESTING-LABEL: @non_void_no_op_caller(
+
+; RESULT-LABEL: define ptr @non_void_no_op_caller(ptr %arg) {
+; RESULT-NEXT: %call = call ptr @non_void_no_op(ptr %arg)
+; RESULT-NEXT: ret ptr %call
+define ptr @non_void_no_op_caller(ptr %arg) {
+ %call = call ptr @non_void_no_op(ptr %arg)
+ ret ptr %call
+}
+
; INTERESTING-LABEL: @non_void_same_type_use(
; INTERESTING: = load
; INTERESTING: ret
@@ -230,6 +242,12 @@ define i32 @non_void_bitcastable_type_use(ptr %arg) {
ret i32 0
}
+; INTERESTING-LABEL: @non_void_bitcastable_type_use_caller(
+define i32 @non_void_bitcastable_type_use_caller(ptr %arg) {
+ %ret = call i32 @non_void_bitcastable_type_use(ptr %arg)
+ ret i32 %ret
+}
+
; INTERESTING-LABEL: @form_return_struct(
; INTERESTING: = load { i32, float }
diff --git a/llvm/tools/llvm-reduce/deltas/ReduceValuesToReturn.cpp b/llvm/tools/llvm-reduce/deltas/ReduceValuesToReturn.cpp
index 3e400ffc89482..0a02298acc73e 100644
--- a/llvm/tools/llvm-reduce/deltas/ReduceValuesToReturn.cpp
+++ b/llvm/tools/llvm-reduce/deltas/ReduceValuesToReturn.cpp
@@ -164,7 +164,9 @@ static bool canReplaceFuncUsers(const Function &F, Type *NewRetTy) {
if (CB->getType() == NewRetTy)
continue;
- LLVM_DEBUG(dbgs() << "Cannot replace callsite with wrong type: " << *CB
+ // TODO: If all callsites have no uses, we could mutate the type of all the
+ // callsites. This will complicate the visit and rewrite ordering though.
+ LLVM_DEBUG(dbgs() << "Cannot replace used callsite with wrong type: " << *CB
<< '\n');
return false;
}
@@ -200,8 +202,7 @@ static bool shouldForwardValueToReturn(const BasicBlock &BB, const Value *V,
if (!isReallyValidReturnType(V->getType()))
return false;
- return (RetTy->isVoidTy() ||
- (RetTy == V->getType() && shouldReplaceNonVoidReturnValue(BB, V))) &&
+ return (RetTy->isVoidTy() || shouldReplaceNonVoidReturnValue(BB, V)) &&
canReplaceFuncUsers(*BB.getParent(), V->getType());
}
>From 75841c9d2c0abe4d75b0575088013b79a26c7b57 Mon Sep 17 00:00:00 2001
From: Matt Arsenault <Matthew.Arsenault at amd.com>
Date: Wed, 2 Apr 2025 13:32:07 +0700
Subject: [PATCH 2/4] Fix multiple return case
---
...reduce-values-to-return-new-return-type.ll | 41 ++++++++++++++++---
.../deltas/ReduceValuesToReturn.cpp | 2 +-
2 files changed, 36 insertions(+), 7 deletions(-)
diff --git a/llvm/test/tools/llvm-reduce/reduce-values-to-return-new-return-type.ll b/llvm/test/tools/llvm-reduce/reduce-values-to-return-new-return-type.ll
index 9ddbbe3def44f..ae1ef4b5353f1 100644
--- a/llvm/test/tools/llvm-reduce/reduce-values-to-return-new-return-type.ll
+++ b/llvm/test/tools/llvm-reduce/reduce-values-to-return-new-return-type.ll
@@ -21,11 +21,38 @@ define i64 @inst_to_return_has_different_type_but_no_func_call_use(ptr %arg) {
ret i64 0
}
-; INTERESTING-LABEL: @callsite_different_type_unused_0(
-; RESULT-LABEL: define i64 @inst_to_return_has_different_type_but_call_result_unused(
-; RESULT-NEXT: %load = load i32, ptr %arg
-; RESULT-NEXT: store i32 %load, ptr @gv
-; RESULT-NEXT: ret i64 0
+; INTERESTING-LABEL: @multiple_returns_wrong_return_type_no_callers(
+; RESULT-LABEL: define i32 @multiple_returns_wrong_return_type_no_callers(
+
+; RESULT: bb0:
+; RESULT-NEXT: %load0 = load i32,
+; RESULT-NEXT: ret i32 %load0
+
+; RESULT: bb1:
+; RESULT-NEXT: store i32 8, ptr null
+; RESULT-NEXT: ret i32 0
+define i64 @multiple_returns_wrong_return_type_no_callers(ptr %arg, i1 %cond, i64 %arg2) {
+entry:
+ br i1 %cond, label %bb0, label %bb1
+
+bb0:
+ %load0 = load i32, ptr %arg
+ store i32 %load0, ptr @gv
+ ret i64 234
+
+bb1:
+ store i32 8, ptr null
+ ret i64 %arg2
+
+bb2:
+ ret i64 34
+}
+
+; INTERESTING-LABEL: define {{.+}} @callsite_different_type_unused_0(
+
+; RESULT-LABEL: define i64 @callsite_different_type_unused_0(ptr %arg) {
+; RESULT-NEXT: %unused0 = call i64 @inst_to_return_has_different_type_but_call_result_unused(ptr %arg)
+; RESULT-NEXT: ret i64 %unused0
define void @callsite_different_type_unused_0(ptr %arg) {
%unused0 = call i64 @inst_to_return_has_different_type_but_call_result_unused(ptr %arg)
%unused1 = call i64 @inst_to_return_has_different_type_but_call_result_unused(ptr null)
@@ -33,8 +60,10 @@ define void @callsite_different_type_unused_0(ptr %arg) {
}
; TODO: Could rewrite this return from i64 to i32 since the callsite is unused.
-; INTERESTING-LABEL: @inst_to_return_has_different_type_but_call_result_unused(
+; INTERESTING-LABEL: define {{.+}} @inst_to_return_has_different_type_but_call_result_unused(
; RESULT-LABEL: define i64 @inst_to_return_has_different_type_but_call_result_unused(
+; RESULT-NEXT: %load = load i32, ptr %arg
+; RESULT-NEXT: store i32 %load, ptr @gv
; RESULT: ret i64 0
define i64 @inst_to_return_has_different_type_but_call_result_unused(ptr %arg) {
%load = load i32, ptr %arg
diff --git a/llvm/tools/llvm-reduce/deltas/ReduceValuesToReturn.cpp b/llvm/tools/llvm-reduce/deltas/ReduceValuesToReturn.cpp
index 0a02298acc73e..a2548f46b5fe4 100644
--- a/llvm/tools/llvm-reduce/deltas/ReduceValuesToReturn.cpp
+++ b/llvm/tools/llvm-reduce/deltas/ReduceValuesToReturn.cpp
@@ -56,7 +56,7 @@ static void rewriteFuncWithReturnType(Function &OldF, Value *NewRetValue) {
NewRetI ? NewRetI->getIterator() : EntryBB.end();
// Hack up any return values in other blocks, we can't leave them as ret void.
- if (OldFuncTy->getReturnType()->isVoidTy()) {
+ if (OldFuncTy->getReturnType() != NewRetTy) {
for (BasicBlock &OtherRetBB : OldF) {
if (&OtherRetBB != NewRetBlock) {
auto *OrigRI = dyn_cast<ReturnInst>(OtherRetBB.getTerminator());
>From 2af47b44da4217566fd6fed3d8784b68fbe22ce5 Mon Sep 17 00:00:00 2001
From: Matt Arsenault <Matthew.Arsenault at amd.com>
Date: Wed, 2 Apr 2025 14:05:02 +0700
Subject: [PATCH 3/4] Fix return attributes
---
...reduce-values-to-return-new-return-type.ll | 35 +++++++++++++++++--
.../deltas/ReduceValuesToReturn.cpp | 15 +++++++-
2 files changed, 47 insertions(+), 3 deletions(-)
diff --git a/llvm/test/tools/llvm-reduce/reduce-values-to-return-new-return-type.ll b/llvm/test/tools/llvm-reduce/reduce-values-to-return-new-return-type.ll
index ae1ef4b5353f1..d8c878c5dc7cb 100644
--- a/llvm/test/tools/llvm-reduce/reduce-values-to-return-new-return-type.ll
+++ b/llvm/test/tools/llvm-reduce/reduce-values-to-return-new-return-type.ll
@@ -51,10 +51,10 @@ bb2:
; INTERESTING-LABEL: define {{.+}} @callsite_different_type_unused_0(
; RESULT-LABEL: define i64 @callsite_different_type_unused_0(ptr %arg) {
-; RESULT-NEXT: %unused0 = call i64 @inst_to_return_has_different_type_but_call_result_unused(ptr %arg)
+; RESULT-NEXT: %unused0 = call range(i64 99, 1024) i64 @inst_to_return_has_different_type_but_call_result_unused(ptr %arg)
; RESULT-NEXT: ret i64 %unused0
define void @callsite_different_type_unused_0(ptr %arg) {
- %unused0 = call i64 @inst_to_return_has_different_type_but_call_result_unused(ptr %arg)
+ %unused0 = call range(i64 99, 1024) i64 @inst_to_return_has_different_type_but_call_result_unused(ptr %arg)
%unused1 = call i64 @inst_to_return_has_different_type_but_call_result_unused(ptr null)
ret void
}
@@ -122,3 +122,34 @@ define void @call_multiple_returns_wrong_return_type(ptr %arg, i1 %cond, i32 %ar
%unused = call <2 x i32> @multiple_returns_wrong_return_type(ptr %arg, i1 %cond, i32 %arg2)
ret void
}
+
+; INTERESTING-LABEL: @drop_incompatible_type_return_attrs(
+
+; RESULT-LABEL: define i32 @drop_incompatible_type_return_attrs(ptr %arg, float %arg1) {
+; RESULT-NEXT: %load = load i32, ptr %arg, align 4
+; RESULT-NEXT: ret i32 %load
+define nofpclass(nan inf) float @drop_incompatible_type_return_attrs(ptr %arg, float %arg1) {
+ %load = load i32, ptr %arg
+ store i32 %load, ptr @gv
+ ret float %arg1
+}
+
+; INTERESTING-LABEL: @drop_incompatible_return_range(
+; RESULT-LABEL: define i32 @drop_incompatible_return_range(ptr %arg, i64 %arg1) {
+; RESULT-NEXT: %load = load i32, ptr %arg, align 4
+; RESULT-NEXT: ret i32 %load
+define range(i64 8, 256) i64 @drop_incompatible_return_range(ptr %arg, i64 %arg1) {
+ %load = load i32, ptr %arg
+ store i32 %load, ptr @gv
+ ret i64 %arg1
+}
+
+; INTERESTING-LABEL: @preserve_compatible_return_range(
+; RESULT-LABEL: define range(i32 8, 256) i32 @preserve_compatible_return_range(ptr %arg, <2 x i32> %arg1) {
+; RESULT-NEXT: %load = load i32, ptr %arg, align 4
+; RESULT-NEXT: ret i32 %load
+define range(i32 8, 256) <2 x i32> @preserve_compatible_return_range(ptr %arg, <2 x i32> %arg1) {
+ %load = load i32, ptr %arg
+ store i32 %load, ptr @gv
+ ret <2 x i32> %arg1
+}
diff --git a/llvm/tools/llvm-reduce/deltas/ReduceValuesToReturn.cpp b/llvm/tools/llvm-reduce/deltas/ReduceValuesToReturn.cpp
index a2548f46b5fe4..c843a2150adf9 100644
--- a/llvm/tools/llvm-reduce/deltas/ReduceValuesToReturn.cpp
+++ b/llvm/tools/llvm-reduce/deltas/ReduceValuesToReturn.cpp
@@ -18,6 +18,8 @@
#include "Delta.h"
#include "Utils.h"
+#include "llvm/IR/AttributeMask.h"
+#include "llvm/IR/Attributes.h"
#include "llvm/IR/CFG.h"
#include "llvm/IR/Instructions.h"
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
@@ -55,8 +57,10 @@ static void rewriteFuncWithReturnType(Function &OldF, Value *NewRetValue) {
BasicBlock::iterator NewValIt =
NewRetI ? NewRetI->getIterator() : EntryBB.end();
+ Type *OldRetTy = OldFuncTy->getReturnType();
+
// Hack up any return values in other blocks, we can't leave them as ret void.
- if (OldFuncTy->getReturnType() != NewRetTy) {
+ if (OldRetTy != NewRetTy) {
for (BasicBlock &OtherRetBB : OldF) {
if (&OtherRetBB != NewRetBlock) {
auto *OrigRI = dyn_cast<ReturnInst>(OtherRetBB.getTerminator());
@@ -92,6 +96,15 @@ static void rewriteFuncWithReturnType(Function &OldF, Value *NewRetValue) {
// result of our pruning here.
EliminateUnreachableBlocks(OldF);
+
+ // Drop the incompatible attributes before we copy over to the new function.
+ if (OldRetTy != NewRetTy) {
+ AttributeList AL = OldF.getAttributes();
+ AttributeMask IncompatibleAttrs =
+ AttributeFuncs::typeIncompatible(NewRetTy, AL.getRetAttrs());
+ OldF.removeRetAttrs(IncompatibleAttrs);
+ }
+
Function *NewF =
Function::Create(NewFuncTy, OldF.getLinkage(), OldF.getAddressSpace(), "",
OldF.getParent());
>From 54900733a4a81dc09e85e86c805190b60f550dc6 Mon Sep 17 00:00:00 2001
From: Matt Arsenault <Matthew.Arsenault at amd.com>
Date: Wed, 2 Apr 2025 14:31:05 +0700
Subject: [PATCH 4/4] Fix returned attr
---
...reduce-values-to-return-new-return-type.ll | 33 +++++++++++++++++++
.../deltas/ReduceValuesToReturn.cpp | 5 ++-
2 files changed, 37 insertions(+), 1 deletion(-)
diff --git a/llvm/test/tools/llvm-reduce/reduce-values-to-return-new-return-type.ll b/llvm/test/tools/llvm-reduce/reduce-values-to-return-new-return-type.ll
index d8c878c5dc7cb..76ae1d17f885c 100644
--- a/llvm/test/tools/llvm-reduce/reduce-values-to-return-new-return-type.ll
+++ b/llvm/test/tools/llvm-reduce/reduce-values-to-return-new-return-type.ll
@@ -153,3 +153,36 @@ define range(i32 8, 256) <2 x i32> @preserve_compatible_return_range(ptr %arg, <
store i32 %load, ptr @gv
ret <2 x i32> %arg1
}
+
+; INTERESTING-LABEL: @drop_incompatible_returned_param_attr_0(
+
+; RESULT-LABEL: define i32 @drop_incompatible_returned_param_attr_0(ptr %arg, ptr %arg1) {
+; RESULT-NEXT: %load = load i32, ptr %arg
+; RESULT-NEXT: ret i32 %load
+define ptr @drop_incompatible_returned_param_attr_0(ptr returned %arg, ptr %arg1) {
+ %load = load i32, ptr %arg
+ store i32 %load, ptr @gv
+ ret ptr %arg
+}
+
+; INTERESTING-LABEL: @drop_incompatible_returned_param_attr_1(
+
+; RESULT-LABEL: define i32 @drop_incompatible_returned_param_attr_1(ptr %arg, ptr %arg1) {
+; RESULT-NEXT: %load = load i32, ptr %arg
+; RESULT-NEXT: ret i32 %load
+define ptr @drop_incompatible_returned_param_attr_1(ptr %arg, ptr returned %arg1) {
+ %load = load i32, ptr %arg
+ store i32 %load, ptr @gv
+ ret ptr %arg
+}
+
+; INTERESTING-LABEL: @drop_incompatible_returned_param_attr_2
+
+; RESULT-LABEL: define ptr @drop_incompatible_returned_param_attr_2(ptr %arg, ptr %arg1) {
+; RESULT-NEXT: %load = load ptr, ptr %arg
+; RESULT-NEXT: ret ptr %load
+define ptr @drop_incompatible_returned_param_attr_2(ptr %arg, ptr returned %arg1) {
+ %load = load ptr, ptr %arg
+ store ptr %load, ptr @gv
+ ret ptr %arg1
+}
diff --git a/llvm/tools/llvm-reduce/deltas/ReduceValuesToReturn.cpp b/llvm/tools/llvm-reduce/deltas/ReduceValuesToReturn.cpp
index c843a2150adf9..72cfa830579a2 100644
--- a/llvm/tools/llvm-reduce/deltas/ReduceValuesToReturn.cpp
+++ b/llvm/tools/llvm-reduce/deltas/ReduceValuesToReturn.cpp
@@ -96,7 +96,6 @@ static void rewriteFuncWithReturnType(Function &OldF, Value *NewRetValue) {
// result of our pruning here.
EliminateUnreachableBlocks(OldF);
-
// Drop the incompatible attributes before we copy over to the new function.
if (OldRetTy != NewRetTy) {
AttributeList AL = OldF.getAttributes();
@@ -105,6 +104,10 @@ static void rewriteFuncWithReturnType(Function &OldF, Value *NewRetValue) {
OldF.removeRetAttrs(IncompatibleAttrs);
}
+ // Now we need to remove any returned attributes from parameters.
+ for (Argument &A : OldF.args())
+ OldF.removeParamAttr(A.getArgNo(), Attribute::Returned);
+
Function *NewF =
Function::Create(NewFuncTy, OldF.getLinkage(), OldF.getAddressSpace(), "",
OldF.getParent());
More information about the llvm-branch-commits
mailing list