This is an archive of the discontinued LLVM Phabricator instance.

Differential D115003

[funcattrs] Infer writeonly argument attribute [part 2]
ClosedPublic

Authored by reames on Dec 2 2021, 3:05 PM.

Details

Reviewers
jdoerfert
anna
aeubanks
modimo
sstefan1
nikic
Commits
rG0b09313cd533: [funcattrs] Infer writeonly argument attribute [part 2]
Summary

This builds on the code from D114963, and extends it to handle calls both direct and indirect. With the revised code structure (from series of previously landed NFCs), this is pretty straight forward.

One thing to note is that we can not infer writeonly for arguments which might be captured. If the pointer can be read back by the caller, and then read through, we have no way to track that. This is the same restriction we have for readonly, except that we get no mileage out of the "callee can be readonly" exception since a writeonly param on a readonly function is either a) readnone or b) UB. This means we can't actually infer much unless nocapture has already been inferred.

Diff Detail

Event Timeline

reames created this revision.Dec 2 2021, 3:05 PM
Herald added subscribers: jeroen.dobbelaere, ormris, kerbowa and 6 others. · View Herald TranscriptDec 2 2021, 3:05 PM
reames requested review of this revision.Dec 2 2021, 3:05 PM
Herald added projects: Restricted Project, Restricted Project. · View Herald TranscriptDec 2 2021, 3:05 PM
Herald added subscribers: cfe-commits, aheejin. · View Herald Transcript
Harbormaster completed remote builds in B137243: Diff 391474.Dec 2 2021, 4:41 PM
reames added a child revision: D115021: [funcatts] Rewrite callsite operand handling in memory access inference.Dec 2 2021, 7:44 PM
reames planned changes to this revision.Dec 3 2021, 10:31 AM

Has the same propagation bug fixed in 7b54de5f, need to rework.

reames updated this revision to Diff 397124.Jan 3 2022, 12:50 PM
reames edited the summary of this revision. (Show Details)

Rework account for only being to infer on nocapture arguments.

Harbormaster completed remote builds in B141372: Diff 397124.Jan 3 2022, 2:13 PM
nikic accepted this revision.Jan 4 2022, 1:13 AM
nikic added a subscriber: nikic.

LGTM

llvm/lib/Transforms/IPO/FunctionAttrs.cpp
744

This could be written as CB.doesNotReadMemory() || CB.doesNotReadMemory(UseIndex) for symmetry with the other cases. Though personally I find the naming of these methods really unfortunate (they should probably be called onlyWritesMemory()) so maybe the explicit form is better.

This revision is now accepted and ready to land.Jan 4 2022, 1:13 AM
reames added inline comments.Jan 4 2022, 8:52 AM
llvm/lib/Transforms/IPO/FunctionAttrs.cpp
744

I'm leaving this as is, but I agree we could use some naming cleanup here. (I may even do it since this is the second time I've hit this.)

Though to highlight "does not read memory" and "WriteOnly" are not quite the same. The former allows readnone which is correct, but surprising here. Personally, I hate subtle semantic surprises and am increasing of the view that we should check the attributes we mean. (At least in inference code.)

This revision was landed with ongoing or failed builds.Jan 4 2022, 9:08 AM
Closed by commit rG0b09313cd533: [funcattrs] Infer writeonly argument attribute [part 2] (authored by reames). · Explain Why
This revision was automatically updated to reflect the committed changes.
reames added a commit: rG0b09313cd533: [funcattrs] Infer writeonly argument attribute [part 2].

Revision Contents

PathSize
clang/
test/
CodeGen/
2 lines
CodeGenCXX/
2 lines
CodeGenOpenCL/
6 lines
llvm/
lib/
Transforms/
IPO/
14 lines
test/
Analysis/
TypeBasedAliasAnalysis/
2 lines
Other/
2 lines
Transforms/
FunctionAttrs/
4 lines
2 lines
6 lines

Diff 391474

clang/test/CodeGen/arm-vfp16-arguments.c

Show First 20 Lines • Show All 65 Lines • ▼ Show 20 Lines
void test_hfa(hfa_t a) {} void test_hfa(hfa_t a) {}
// CHECK-SOFT: define{{.*}} void @test_hfa([2 x i64] %a.coerce) // CHECK-SOFT: define{{.*}} void @test_hfa([2 x i64] %a.coerce)
// CHECK-HARD: define{{.*}} arm_aapcs_vfpcc void @test_hfa([2 x <2 x i32>] %a.coerce) // CHECK-HARD: define{{.*}} arm_aapcs_vfpcc void @test_hfa([2 x <2 x i32>] %a.coerce)
// CHECK-FULL: define{{.*}} arm_aapcs_vfpcc void @test_hfa(%struct.hfa_t %a.coerce) // CHECK-FULL: define{{.*}} arm_aapcs_vfpcc void @test_hfa(%struct.hfa_t %a.coerce)
hfa_t ghfa; hfa_t ghfa;
hfa_t test_ret_hfa(void) { return ghfa; } hfa_t test_ret_hfa(void) { return ghfa; }
// CHECK-SOFT: define{{.*}} void @test_ret_hfa(%struct.hfa_t* noalias nocapture sret(%struct.hfa_t) align 8 %agg.result) // CHECK-SOFT: define{{.*}} void @test_ret_hfa(%struct.hfa_t* noalias nocapture writeonly sret(%struct.hfa_t) align 8 %agg.result)
// CHECK-HARD: define{{.*}} arm_aapcs_vfpcc [2 x <2 x i32>] @test_ret_hfa() // CHECK-HARD: define{{.*}} arm_aapcs_vfpcc [2 x <2 x i32>] @test_ret_hfa()
// CHECK-FULL: define{{.*}} arm_aapcs_vfpcc %struct.hfa_t @test_ret_hfa() // CHECK-FULL: define{{.*}} arm_aapcs_vfpcc %struct.hfa_t @test_ret_hfa()

clang/test/CodeGenCXX/wasm-args-returns.cpp

Show All 24 Lines
// //
// CHECK: declare void @_Z3use9one_field(double) // CHECK: declare void @_Z3use9one_field(double)
// CHECK: declare double @_Z13def_one_fieldv() // CHECK: declare double @_Z13def_one_fieldv()
struct two_fields { struct two_fields {
double d, e; double d, e;
}; };
test(two_fields); test(two_fields);
// CHECK: define void @_Z7forward10two_fields(%struct.two_fields* noalias nocapture sret(%struct.two_fields) align 8 %{{.*}}, %struct.two_fields* nocapture readonly byval(%struct.two_fields) align 8 %{{.*}}) // CHECK: define void @_Z7forward10two_fields(%struct.two_fields* noalias nocapture writeonly sret(%struct.two_fields) align 8 %{{.*}}, %struct.two_fields* nocapture readonly byval(%struct.two_fields) align 8 %{{.*}})
// //
// CHECK: define void @_Z15test_two_fieldsv() // CHECK: define void @_Z15test_two_fieldsv()
// CHECK: %[[tmp:.*]] = alloca %struct.two_fields, align 8 // CHECK: %[[tmp:.*]] = alloca %struct.two_fields, align 8
// CHECK: call void @_Z14def_two_fieldsv(%struct.two_fields* nonnull sret(%struct.two_fields) align 8 %[[tmp]]) // CHECK: call void @_Z14def_two_fieldsv(%struct.two_fields* nonnull sret(%struct.two_fields) align 8 %[[tmp]])
// CHECK: call void @_Z3use10two_fields(%struct.two_fields* nonnull byval(%struct.two_fields) align 8 %[[tmp]]) // CHECK: call void @_Z3use10two_fields(%struct.two_fields* nonnull byval(%struct.two_fields) align 8 %[[tmp]])
// CHECK: ret void // CHECK: ret void
// //
// CHECK: declare void @_Z3use10two_fields(%struct.two_fields* byval(%struct.two_fields) align 8) // CHECK: declare void @_Z3use10two_fields(%struct.two_fields* byval(%struct.two_fields) align 8)
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

clang/test/CodeGenOpenCL/amdgpu-abi-struct-coerce.cl

Show First 20 Lines • Show All 397 Lines • ▼ Show 20 Lines
// CHECK: define{{.*}} %struct.struct_arr16 @func_ret_struct_arr16() // CHECK: define{{.*}} %struct.struct_arr16 @func_ret_struct_arr16()
// CHECK: ret %struct.struct_arr16 zeroinitializer // CHECK: ret %struct.struct_arr16 zeroinitializer
struct_arr16 func_ret_struct_arr16() struct_arr16 func_ret_struct_arr16()
{ {
struct_arr16 s = { 0 }; struct_arr16 s = { 0 };
return s; return s;
} }
// CHECK: define{{.*}} void @func_ret_struct_arr32(%struct.struct_arr32 addrspace(5)* noalias nocapture sret(%struct.struct_arr32) align 4 %agg.result) // CHECK: define{{.*}} void @func_ret_struct_arr32(%struct.struct_arr32 addrspace(5)* noalias nocapture writeonly sret(%struct.struct_arr32) align 4 %agg.result)
struct_arr32 func_ret_struct_arr32() struct_arr32 func_ret_struct_arr32()
{ {
struct_arr32 s = { 0 }; struct_arr32 s = { 0 };
return s; return s;
} }
// CHECK: define{{.*}} void @func_ret_struct_arr33(%struct.struct_arr33 addrspace(5)* noalias nocapture sret(%struct.struct_arr33) align 4 %agg.result) // CHECK: define{{.*}} void @func_ret_struct_arr33(%struct.struct_arr33 addrspace(5)* noalias nocapture writeonly sret(%struct.struct_arr33) align 4 %agg.result)
struct_arr33 func_ret_struct_arr33() struct_arr33 func_ret_struct_arr33()
{ {
struct_arr33 s = { 0 }; struct_arr33 s = { 0 };
return s; return s;
} }
// CHECK: define{{.*}} %struct.struct_char_arr32 @func_ret_struct_char_arr32() // CHECK: define{{.*}} %struct.struct_char_arr32 @func_ret_struct_char_arr32()
struct_char_arr32 func_ret_struct_char_arr32() struct_char_arr32 func_ret_struct_char_arr32()
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
double_nested_struct func_double_nested_struct_ret(int4 arg0, int arg1) { double_nested_struct func_double_nested_struct_ret(int4 arg0, int arg1) {
double_nested_struct s = { 0 }; double_nested_struct s = { 0 };
return s; return s;
} }
// CHECK: define{{.*}} void @func_large_struct_padding_arg_direct(i8 %arg.coerce0, i32 %arg.coerce1, i8 %arg.coerce2, i32 %arg.coerce3, i8 %arg.coerce4, i8 %arg.coerce5, i16 %arg.coerce6, i16 %arg.coerce7, [3 x i8] %arg.coerce8, i64 %arg.coerce9, i32 %arg.coerce10, i8 %arg.coerce11, i32 %arg.coerce12, i16 %arg.coerce13, i8 %arg.coerce14) // CHECK: define{{.*}} void @func_large_struct_padding_arg_direct(i8 %arg.coerce0, i32 %arg.coerce1, i8 %arg.coerce2, i32 %arg.coerce3, i8 %arg.coerce4, i8 %arg.coerce5, i16 %arg.coerce6, i16 %arg.coerce7, [3 x i8] %arg.coerce8, i64 %arg.coerce9, i32 %arg.coerce10, i8 %arg.coerce11, i32 %arg.coerce12, i16 %arg.coerce13, i8 %arg.coerce14)
void func_large_struct_padding_arg_direct(large_struct_padding arg) { } void func_large_struct_padding_arg_direct(large_struct_padding arg) { }
// CHECK: define{{.*}} void @func_large_struct_padding_arg_store(%struct.large_struct_padding addrspace(1)* nocapture %out, %struct.large_struct_padding addrspace(5)* nocapture readonly byval(%struct.large_struct_padding) align 8 %arg) // CHECK: define{{.*}} void @func_large_struct_padding_arg_store(%struct.large_struct_padding addrspace(1)* nocapture writeonly %out, %struct.large_struct_padding addrspace(5)* nocapture readonly byval(%struct.large_struct_padding) align 8 %arg)
void func_large_struct_padding_arg_store(global large_struct_padding* out, large_struct_padding arg) { void func_large_struct_padding_arg_store(global large_struct_padding* out, large_struct_padding arg) {
*out = arg; *out = arg;
} }
// CHECK: define{{.*}} void @v3i32_reg_count(<3 x i32> %arg1, <3 x i32> %arg2, <3 x i32> %arg3, <3 x i32> %arg4, i32 %arg5.coerce0, float %arg5.coerce1, i32 %arg5.coerce2) // CHECK: define{{.*}} void @v3i32_reg_count(<3 x i32> %arg1, <3 x i32> %arg2, <3 x i32> %arg3, <3 x i32> %arg4, i32 %arg5.coerce0, float %arg5.coerce1, i32 %arg5.coerce2)
void v3i32_reg_count(int3 arg1, int3 arg2, int3 arg3, int3 arg4, struct_arg_t arg5) { } void v3i32_reg_count(int3 arg1, int3 arg2, int3 arg3, int3 arg4, struct_arg_t arg5) { }
// Function signature from blender, nothing should be passed byval. The v3i32 // Function signature from blender, nothing should be passed byval. The v3i32
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

llvm/lib/Transforms/IPO/FunctionAttrs.cpp

Show First 20 Lines • Show All 707 Lines • ▼ Show 20 Lines case Instruction::Invoke: {
} }
Function *F = CB.getCalledFunction(); Function *F = CB.getCalledFunction();
if (!F) { if (!F) {
if (CB.onlyReadsMemory()) { if (CB.onlyReadsMemory()) {
IsRead = true; IsRead = true;
AddUsersToWorklistIfCapturing(); AddUsersToWorklistIfCapturing();
continue; continue;
} else if (!CB.isCallee(U) && CB.hasFnAttr(Attribute::WriteOnly)) {
IsWrite = true;
AddUsersToWorklistIfCapturing();
continue;
} }
return Attribute::None; return Attribute::None;
} }
// Note: the callee and the two successor blocks *follow* the argument // Note: the callee and the two successor blocks *follow* the argument
// operands. This means there is no need to adjust UseIndex to account // operands. This means there is no need to adjust UseIndex to account
// for these. // for these.
unsigned UseIndex = std::distance(CB.arg_begin(), U); unsigned UseIndex = std::distance(CB.arg_begin(), U);
// U cannot be the callee operand use: since we're exploring the // U cannot be the callee operand use: since we're exploring the
// transitive uses of an Argument, having such a use be a callee would // transitive uses of an Argument, having such a use be a callee would
// imply the call site is an indirect call or invoke; and we'd take the // imply the call site is an indirect call or invoke; and we'd take the
// early exit above. // early exit above.
assert(UseIndex < CB.data_operands_size() && assert(UseIndex < CB.data_operands_size() &&
"Data operand use expected!"); "Data operand use expected!");
bool IsOperandBundleUse = UseIndex >= CB.arg_size(); bool IsOperandBundleUse = UseIndex >= CB.arg_size();
if (UseIndex >= F->arg_size() && !IsOperandBundleUse) { if (UseIndex >= F->arg_size() && !IsOperandBundleUse) {
assert(F->isVarArg() && "More params than args in non-varargs call"); assert(F->isVarArg() && "More params than args in non-varargs call");
return Attribute::None; return Attribute::None;
} }
Captures &= !CB.doesNotCapture(UseIndex); Captures &= !CB.doesNotCapture(UseIndex);
nikicUnsubmitted
Not Done
ReplyInline Actions

This could be written as CB.doesNotReadMemory() || CB.doesNotReadMemory(UseIndex) for symmetry with the other cases. Though personally I find the naming of these methods really unfortunate (they should probably be called onlyWritesMemory()) so maybe the explicit form is better.

nikic: This could be written as `CB.doesNotReadMemory() || CB.doesNotReadMemory(UseIndex)` for…
reamesAuthorUnsubmitted
Done
ReplyInline Actions

I'm leaving this as is, but I agree we could use some naming cleanup here. (I may even do it since this is the second time I've hit this.)

Though to highlight "does not read memory" and "WriteOnly" are not quite the same. The former allows readnone which is correct, but surprising here. Personally, I hate subtle semantic surprises and am increasing of the view that we should check the attributes we mean. (At least in inference code.)

reames: I'm leaving this as is, but I agree we could use some naming cleanup here. (I may even do it…
// Since the optimizer (by design) cannot see the data flow corresponding // Since the optimizer (by design) cannot see the data flow corresponding
// to a operand bundle use, these cannot participate in the optimistic SCC // to a operand bundle use, these cannot participate in the optimistic SCC
// analysis. Instead, we model the operand bundle uses as arguments in // analysis. Instead, we model the operand bundle uses as arguments in
// call to a function external to the SCC. // call to a function external to the SCC.
if (IsOperandBundleUse || if (IsOperandBundleUse ||
!SCCNodes.count(&*std::next(F->arg_begin(), UseIndex))) { !SCCNodes.count(&*std::next(F->arg_begin(), UseIndex))) {
// The accessors used on call site here do the right thing for calls and // The accessors used on call site here do the right thing for calls and
// invokes with operand bundles. // invokes with operand bundles.
if (!CB.onlyReadsMemory() && !CB.onlyReadsMemory(UseIndex)) if (CB.doesNotAccessMemory(UseIndex)) { /* nop */ }
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-        if (CB.doesNotAccessMemory(UseIndex)) { /* nop */ }
-        else if (CB.onlyReadsMemory() || CB.onlyReadsMemory(UseIndex))
+        if (CB.doesNotAccessMemory(UseIndex)) { /* nop */
+        } else if (CB.onlyReadsMemory() || CB.onlyReadsMemory(UseIndex))
Lint: Pre-merge checks: clang-format: please reformat the code ``` - if (CB.doesNotAccessMemory(UseIndex)) { /*…
return Attribute::None; else if (CB.onlyReadsMemory() || CB.onlyReadsMemory(UseIndex))
if (!CB.doesNotAccessMemory(UseIndex))
IsRead = true; IsRead = true;
else if (CB.hasFnAttr(Attribute::WriteOnly) ||
CB.dataOperandHasImpliedAttr(UseIndex, Attribute::WriteOnly))
IsWrite = true;
else
return Attribute::None;
} }
AddUsersToWorklistIfCapturing(); AddUsersToWorklistIfCapturing();
break; break;
} }
case Instruction::Load: case Instruction::Load:
// A volatile load has side effects beyond what readonly can be relied // A volatile load has side effects beyond what readonly can be relied
▲ Show 20 Lines • Show All 1,288 Lines • Show Last 20 Lines

llvm/test/Analysis/TypeBasedAliasAnalysis/functionattrs.ll

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
; isn't necessarily invalid. ; isn't necessarily invalid.
; CHECK: define void @test2_yes(i8* nocapture %p, i8* nocapture %q, i64 %n) #4 { ; CHECK: define void @test2_yes(i8* nocapture %p, i8* nocapture %q, i64 %n) #4 {
define void @test2_yes(i8* %p, i8* %q, i64 %n) nounwind { define void @test2_yes(i8* %p, i8* %q, i64 %n) nounwind {
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %p, i8* %q, i64 %n, i1 false), !tbaa !1 call void @llvm.memcpy.p0i8.p0i8.i64(i8* %p, i8* %q, i64 %n, i1 false), !tbaa !1
ret void ret void
} }
; CHECK: define void @test2_no(i8* nocapture %p, i8* nocapture readonly %q, i64 %n) #5 { ; CHECK: define void @test2_no(i8* nocapture writeonly %p, i8* nocapture readonly %q, i64 %n) #5 {
define void @test2_no(i8* %p, i8* %q, i64 %n) nounwind { define void @test2_no(i8* %p, i8* %q, i64 %n) nounwind {
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %p, i8* %q, i64 %n, i1 false), !tbaa !2 call void @llvm.memcpy.p0i8.p0i8.i64(i8* %p, i8* %q, i64 %n, i1 false), !tbaa !2
ret void ret void
} }
; Similar to the others, va_arg only accesses memory through its operand. ; Similar to the others, va_arg only accesses memory through its operand.
; CHECK: define i32 @test3_yes(i8* nocapture %p) #0 { ; CHECK: define i32 @test3_yes(i8* nocapture %p) #0 {
Show All 31 Lines

llvm/test/Other/cgscc-devirt-iteration.ll

Show First 20 Lines • Show All 106 Lines • ▼ Show 20 Lines
; creates the memcpy intrinsic call, and we rely on the count of indirect calls ; creates the memcpy intrinsic call, and we rely on the count of indirect calls
; decreasing and the count of direct calls increasing. ; decreasing and the count of direct calls increasing.
; Adding 'noinline' attribute to force attributes for improved matching. ; Adding 'noinline' attribute to force attributes for improved matching.
define void @test3(i8* %src, i8* %dest, i64 %size) noinline { define void @test3(i8* %src, i8* %dest, i64 %size) noinline {
; CHECK: Function Attrs ; CHECK: Function Attrs
; CHECK-NOT: read ; CHECK-NOT: read
; CHECK-SAME: noinline ; CHECK-SAME: noinline
; BEFORE-LABEL: define void @test3(i8* %src, i8* %dest, i64 %size) ; BEFORE-LABEL: define void @test3(i8* %src, i8* %dest, i64 %size)
; AFTER-LABEL: define void @test3(i8* nocapture readonly %src, i8* nocapture %dest, i64 %size) ; AFTER-LABEL: define void @test3(i8* nocapture readonly %src, i8* nocapture writeonly %dest, i64 %size)
%fptr = alloca i8* (i8*, i8*, i64)* %fptr = alloca i8* (i8*, i8*, i64)*
store i8* (i8*, i8*, i64)* @memcpy, i8* (i8*, i8*, i64)** %fptr store i8* (i8*, i8*, i64)* @memcpy, i8* (i8*, i8*, i64)** %fptr
%f = load i8* (i8*, i8*, i64)*, i8* (i8*, i8*, i64)** %fptr %f = load i8* (i8*, i8*, i64)*, i8* (i8*, i8*, i64)** %fptr
call i8* %f(i8* %dest, i8* %src, i64 %size) call i8* %f(i8* %dest, i8* %src, i64 %size)
; CHECK: call void @llvm.memcpy ; CHECK: call void @llvm.memcpy
ret void ret void
} }
Show All 11 Lines

llvm/test/Transforms/FunctionAttrs/nocapture.ll

Show All 9 Lines
; FNATTR: define void @c2(i32* writeonly %q) ; FNATTR: define void @c2(i32* writeonly %q)
; It would also be acceptable to mark %q as readnone. Update @c3 too. ; It would also be acceptable to mark %q as readnone. Update @c3 too.
define void @c2(i32* %q) { define void @c2(i32* %q) {
store i32* %q, i32** @g store i32* %q, i32** @g
ret void ret void
} }
; FNATTR: define void @c3(i32* %q) ; FNATTR: define void @c3(i32* writeonly %q)
define void @c3(i32* %q) { define void @c3(i32* %q) {
call void @c2(i32* %q) call void @c2(i32* %q)
ret void ret void
} }
; FNATTR: define i1 @c4(i32* %q, i32 %bitno) ; FNATTR: define i1 @c4(i32* %q, i32 %bitno)
define i1 @c4(i32* %q, i32 %bitno) { define i1 @c4(i32* %q, i32 %bitno) {
%tmp = ptrtoint i32* %q to i32 %tmp = ptrtoint i32* %q to i32
▲ Show 20 Lines • Show All 124 Lines • ▼ Show 20 Lines
; FNATTR: define void @test1_1(i8* nocapture readnone %x1_1, i8* %y1_1, i1 %c) ; FNATTR: define void @test1_1(i8* nocapture readnone %x1_1, i8* %y1_1, i1 %c)
; It would be acceptable to add readnone to %y1_1 and %y1_2. ; It would be acceptable to add readnone to %y1_1 and %y1_2.
define void @test1_1(i8* %x1_1, i8* %y1_1, i1 %c) { define void @test1_1(i8* %x1_1, i8* %y1_1, i1 %c) {
call i8* @test1_2(i8* %x1_1, i8* %y1_1, i1 %c) call i8* @test1_2(i8* %x1_1, i8* %y1_1, i1 %c)
store i32* null, i32** @g store i32* null, i32** @g
ret void ret void
} }
; FNATTR: define i8* @test1_2(i8* nocapture readnone %x1_2, i8* returned %y1_2, i1 %c) ; FNATTR: define i8* @test1_2(i8* nocapture readnone %x1_2, i8* returned writeonly %y1_2, i1 %c)
define i8* @test1_2(i8* %x1_2, i8* %y1_2, i1 %c) { define i8* @test1_2(i8* %x1_2, i8* %y1_2, i1 %c) {
br i1 %c, label %t, label %f br i1 %c, label %t, label %f
t: t:
call void @test1_1(i8* %x1_2, i8* %y1_2, i1 %c) call void @test1_1(i8* %x1_2, i8* %y1_2, i1 %c)
store i32* null, i32** @g store i32* null, i32** @g
br label %f br label %f
f: f:
ret i8* %y1_2 ret i8* %y1_2
▲ Show 20 Lines • Show All 154 Lines • Show Last 20 Lines

llvm/test/Transforms/FunctionAttrs/norecurse.ll

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines
; CHECK: Function Attrs ; CHECK: Function Attrs
; CHECK-NEXT: declare i32 @k() ; CHECK-NEXT: declare i32 @k()
declare i32 @k() readnone declare i32 @k() readnone
; CHECK: Function Attrs ; CHECK: Function Attrs
; CHECK-SAME: nounwind ; CHECK-SAME: nounwind
; CHECK-NOT: norecurse ; CHECK-NOT: norecurse
; CHECK-NEXT: define void @intrinsic(i8* nocapture %dest, i8* nocapture readonly %src, i32 %len) ; CHECK-NEXT: define void @intrinsic(i8* nocapture writeonly %dest, i8* nocapture readonly %src, i32 %len)
define void @intrinsic(i8* %dest, i8* %src, i32 %len) { define void @intrinsic(i8* %dest, i8* %src, i32 %len) {
call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %src, i32 %len, i1 false) call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %src, i32 %len, i1 false)
ret void ret void
} }
; CHECK: Function Attrs ; CHECK: Function Attrs
; CHECK-NEXT: declare void @llvm.memcpy.p0i8.p0i8.i32 ; CHECK-NEXT: declare void @llvm.memcpy.p0i8.p0i8.i32
declare void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) declare void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1)
Show All 32 Lines

llvm/test/Transforms/FunctionAttrs/writeonly.ll

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Lines
; CHECK: define void @direct1(i8* %p) ; CHECK: define void @direct1(i8* %p)
define void @direct1(i8* %p) { define void @direct1(i8* %p) {
call void @direct1_callee(i8* %p) call void @direct1_callee(i8* %p)
ret void ret void
} }
declare void @direct2_callee(i8* %p) writeonly declare void @direct2_callee(i8* %p) writeonly
; CHECK: define void @direct2(i8* %p) ; CHECK: define void @direct2(i8* writeonly %p)
define void @direct2(i8* %p) { define void @direct2(i8* %p) {
call void @direct2_callee(i8* %p) call void @direct2_callee(i8* %p)
ret void ret void
} }
declare void @direct3_callee(i8* writeonly %p) declare void @direct3_callee(i8* writeonly %p)
; CHECK: define void @direct3(i8* %p) ; CHECK: define void @direct3(i8* writeonly %p)
define void @direct3(i8* %p) { define void @direct3(i8* %p) {
call void @direct3_callee(i8* %p) call void @direct3_callee(i8* %p)
ret void ret void
} }
; CHECK: define void @fptr_test1(i8* %p, void (i8*)* nocapture %f) ; CHECK: define void @fptr_test1(i8* %p, void (i8*)* nocapture %f)
define void @fptr_test1(i8* %p, void (i8*)* %f) { define void @fptr_test1(i8* %p, void (i8*)* %f) {
call void %f(i8* %p) call void %f(i8* %p)
ret void ret void
} }
; CHECK: define void @fptr_test2(i8* %p, void (i8*)* nocapture %f) ; CHECK: define void @fptr_test2(i8* %p, void (i8*)* nocapture %f)
define void @fptr_test2(i8* %p, void (i8*)* %f) { define void @fptr_test2(i8* %p, void (i8*)* %f) {
call void %f(i8* writeonly %p) call void %f(i8* writeonly %p)
ret void ret void
} }
; CHECK: define void @fptr_test3(i8* %p, void (i8*)* nocapture %f) ; CHECK: define void @fptr_test3(i8* writeonly %p, void (i8*)* nocapture %f)
define void @fptr_test3(i8* %p, void (i8*)* %f) { define void @fptr_test3(i8* %p, void (i8*)* %f) {
call void %f(i8* %p) writeonly call void %f(i8* %p) writeonly
ret void ret void
} }
; CHECK: attributes #0 = { {{.*}}readnone{{.*}} } ; CHECK: attributes #0 = { {{.*}}readnone{{.*}} }
; CHECK: attributes #1 = { {{.*}}readonly{{.*}} } ; CHECK: attributes #1 = { {{.*}}readonly{{.*}} }
; CHECK: attributes #2 = { {{.*}}writeonly{{.*}} } ; CHECK: attributes #2 = { {{.*}}writeonly{{.*}} }