Add a test for "nofree" function attribute

[uenoku]

Summary

This patches adds a test for nofree function attributes.

[uenoku]

Fix test 4.

[jdoerfert]

I like the tests. One comment and one change request was inlined.

llvm/test/Transforms/FunctionAttrs/nofree.ll

99

I guess one could argue realloc/free/... are just like regular, unknown functions wrt. no-free. I'd keep the tests though. And it opens the question if we should derive "is-freed" at some point ;)

146

So Chandler raised concerns over this kind of checking in D59903. While I have to admit I haven't fixed all test cases yet, I can see his point. Could you check for the attributes in the printed IR version just before the definition?

It would look similar to this one:

; CHECK:       Function Attrs: noinline norecurse nounwind readnone uwtable
; CHECK-NEXT:     define double* @ret_undef_arg_undef(i32* readnone %b)

[jdoerfert]

Could you also check if there is anything in https://reviews.llvm.org/D49165#change-hksiHW8RDcbA that is missing here?

[uenoku]

Fix checking way.

[uenoku]

Could you also check if there is anything in https://reviews.llvm.org/D49165#change-hksiHW8RDcbA that is missing here?

Apparently, I cover all of them.

[jdoerfert]

Assuming this passes right now it looks-good-to-me.
I would have moved it into the Attributor test folder (which doesn't exist yet), but that can be done later.

[jdoerfert]

We should (in a later patch probably) think about other attributes that would imply nofree.
I guess one can argue readnone should do the trick. There are other things we could pull if
we make nofree also a parameter attribute. Finally we could think about a selective nofree
annotation at a call site to list arguments that are not freed. We could know that because
of dereferenceability after the call.

[jdoerfert]

As mentioned in D62766, we should make nofree an enum attribute. See D62766 for some pointer on how to do so.

[uenoku]

In D62313#1540817, @jdoerfert wrote:

As mentioned in D62766, we should make nofree an enum attribute. See D62766 for some pointer on how to do so.

As I see it, D49165 is rebased.
Which is better to wait for D49165 or to make nofree enum attribute in this patch?

[jdoerfert]

In D62313#1540967, @uenoku wrote:

In D62313#1540817, @jdoerfert wrote:

As mentioned in D62766, we should make nofree an enum attribute. See D62766 for some pointer on how to do so.

As I see it, D49165 is rebased.
Which is better to wait for D49165 or to make nofree enum attribute in this patch?

Good point. If @homerdin adds the attribute in that patch you do not have to.

[uenoku]

Rename test file.

[jdoerfert]

Make sure ninja check-all works with the test (we got support to derive nofree!) and then commit it please.

[uenoku]

Rebase and ninja check-all passed.

[uenoku]

But even if I run with --disable-nofree-inference=false, I couldn't get any nofree (even only_return).

[uenoku]

Add --disable-nofree-inference=false.

llvm/test/Transforms/FunctionAttrs/nofree.ll

+; RUN: opt -functionattrs -S < %s | FileCheck %s
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
+; Test cases specifically designed for the "nofree" function attribute.
+; We use FIXME's to indicate problems and missing attributes.
+
+; Free functions
+declare void @free(i8* nocapture) local_unnamed_addr #1
+declare noalias i8* @realloc(i8* nocapture, i64) local_unnamed_addr #0
+declare void @_ZdaPv(i8*) local_unnamed_addr #2
+
+
+; TEST 1 (positive case)
+; CHECK: define void @only_return() [[NoInlineNoRecurseNoUnwindReadNoneUwtableNoFree:#[0-9]*]]
+define void @only_return() #0 {
+    ret void
+}
+
+
+; TEST 2 (nagative case)
+; Only free
+; void only_free(char* p) {
+;    free(p);
+; }
+; CHECK: define void @only_free(i8* nocapture) local_unnamed_addr [[NoInlineNoUnwindUwtable:#[0-9]*]]
+define void @only_free(i8* nocapture) local_unnamed_addr #0 {
+    tail call void @free(i8* %0) #1
+    ret void
+}
+
+
+; TEST 3 (nagative case)
+; Free occurs in same scc.
+; void free_in_scc1(char*p){
+;    free_in_scc2(p);
+; }
+; void free_in_scc2(char*p){
+;    free_in_scc1(p);
+;    free(p);
+; }
+
+; CHECK: define void @free_in_scc1(i8* nocapture) local_unnamed_addr [[NoInlineNoUnwindUwtable]]
+define void @free_in_scc1(i8* nocapture) local_unnamed_addr #0 {
+  tail call void @free_in_scc1(i8* %0) #1
+  tail call void @free(i8* %0) #1
+  ret void
+}
+
+; CHECK: define void @free_in_scc2(i8* nocapture) local_unnamed_addr [[NoInlineNoUnwindUwtable]]
+define void @free_in_scc2(i8*) local_unnamed_addr #0 {
+  tail call void @free_in_scc1(i8* %0)
+  tail call void @free(i8* %0) #1
+  ret void
+}
+
+
+; TEST 4 (positive case)
+; Free doesn't occur.
+; void mutual_recursion1(){
+;    mutual_recursion2();
+; }
+; void mutual_recursion2(){
+;     mutual_recursion1();
+; }
+
+; CHECK: define void @mutual_recursion1() [[NoInlineNoUnwindReadNoneUwtableNoFree:#[0-9]*]]
+define void @mutual_recursion1() #0 {
+  call void @mutual_recursion2()
+  ret void
+}
+
+; CHECK: define void @mutual_recursion2() [[NoInlineNoUnwindReadNoneUwtableNoFree]]
+define void @mutual_recursion2() #0 {
+  call void @mutual_recursion1()
+  ret void
+}
+
+
+; TEST 5
+; C++ delete operation (nagative case)
+; void delete_op (char p[]){
+;     delete [] p;
+; }
+; CHECK: define void @_Z9delete_opPc(i8*) local_unnamed_addr [[NoInlineNoUnwindUwtable]]
+define void @_Z9delete_opPc(i8*) local_unnamed_addr #0 {
+  %2 = icmp eq i8* %0, null
+  br i1 %2, label %4, label %3
+
+; <label>:3:                                      ; preds = %1
+  tail call void @_ZdaPv(i8* nonnull %0) #2
+  br label %4
+
+; <label>:4:                                      ; preds = %3, %1
+  ret void
+}
+
+
+; TEST 6 (negative case)
+; Call realloc
+; CHECK: define noalias i8* @call_realloc(i8* nocapture, i64) local_unnamed_addr [[NoInlineNoUnwindUwtable]]
+define noalias i8* @call_realloc(i8*nocapture, i64) local_unnamed_addr #0 {
+    %ret = tail call i8* @realloc(i8* %0, i64 %1) #2
+    ret i8* %ret
+}
+
+
+; TEST 7 (positive case)
+; Call function declaration with "nofree"
+
+declare void @nofree_function() "nofree" readnone #0
+
+; CHECK: define void @call_nofree_function() [[NoInlineNoUnwindReadNoneUwtableNoFree]]
+define void @call_nofree_function() #0 {
+    tail call void @nofree_function()
+    ret void
+}
+
+; TEST 8 (nagative case)
+; Call function declaration without "nofree"
+
+declare void @maybe_free() #0
+
+; CHECK: define void @call_maybe_free() [[NoInlineNoUnwindUwtable]]
+define void @call_maybe_free() #0 {
+    tail call void @maybe_free()
+    ret void
+}
+
+
+; TEST 9 (nagative case)
+; Call both of above functions
+
+; CHECK: define void @call_both() [[NoInlineNoUnwindUwtable]]
+define void @call_both() #0 {
+    tail call void @maybe_free()
+    tail call void @nofree_function()
+    ret void
+}
+
+
+attributes #0 = { nounwind uwtable noinline }
+attributes #1 = { nounwind }
+attributes #2 = { nobuiltin nounwind }
+
+; FIXME : "nofree" missing
+; CHECK-DAG: attributes [[NoInlineNoRecurseNoUnwindReadNoneUwtableNoFree]] = { noinline norecurse nounwind readnone uwtable }
+; CHECK-DAG: attributes [[NoInlineNoUnwindUwtable]] = { noinline nounwind uwtable }
+; FIXME : "nofree" missing
+; CHECK-DAG: attributes [[NoInlineNoUnwindReadNoneUwtableNoFree]] = { noinline nounwind readnone uwtable }