[InstCombine] Look through invariant group intrinsics when removing malloc

[aeubanks]

Summary

Fixes some regressions with -fstrict-vtable-pointers in llvm-test-suite.

[lebedev.ri]

LG

llvm/test/Transforms/InstCombine/malloc-free-delete.ll

441

Please precommit

[aeubanks]

precommit test

[Prazek]

Sorry for late reply. Although I don't have experience in this pass, it looks good!

llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

for (User *U : PI->users()) {
           case Intrinsic::assume:
           case Intrinsic::invariant_start:
           case Intrinsic::invariant_end:
           case Intrinsic::lifetime_start:
           case Intrinsic::lifetime_end:
           case Intrinsic::objectsize:
             Users.emplace_back(I);
             continue;
+          case Intrinsic::launder_invariant_group:
+          case Intrinsic::strip_invariant_group:
+            Users.emplace_back(I);
+            Worklist.push_back(I);
+            continue;
           }
         }
 
         if (isFreeCall(I, TLI)) {
           Users.emplace_back(I);
           continue;
         }
         return false;

llvm/test/Transforms/InstCombine/malloc-free-delete.ll

 ; incorrect in general.
 ; 'if (p) delete p;' cannot result in a call to 'operator delete(0)'.
 define void @test6a(i8* %foo) minsize {
 ; CHECK-LABEL: @test6a(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp eq i8* [[FOO:%.*]], null
 ; CHECK-NEXT:    br i1 [[TOBOOL]], label [[IF_END:%.*]], label [[IF_THEN:%.*]]
 ; CHECK:       if.then:
-; CHECK-NEXT:    tail call void @_ZdlPv(i8* [[FOO]]) #[[ATTR8:[0-9]+]]
+; CHECK-NEXT:    tail call void @_ZdlPv(i8* [[FOO]]) #[[ATTR10:[0-9]+]]
 ; CHECK-NEXT:    br label [[IF_END]]
 ; CHECK:       if.end:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %tobool = icmp eq i8* %foo, null
   br i1 %tobool, label %if.end, label %if.then
 

 ; CHECK-NEXT:    ret void
 ;
   call void @_ZdlPv(i8* null)
   ret void
 }
 
 define void @test11() {
 ; CHECK-LABEL: @test11(
-; CHECK-NEXT:    [[CALL:%.*]] = call dereferenceable(8) i8* @_Znwm(i64 8) #[[ATTR8]]
+; CHECK-NEXT:    [[CALL:%.*]] = call dereferenceable(8) i8* @_Znwm(i64 8) #[[ATTR10]]
 ; CHECK-NEXT:    call void @_ZdlPv(i8* nonnull [[CALL]])
 ; CHECK-NEXT:    ret void
 ;
   %call = call i8* @_Znwm(i64 8) builtin
   call void @_ZdlPv(i8* %call)
   ret void
 }
 

 ;
   call void @free(i8* %foo)
   ret void
 }
 
 ; TODO: free call marked no-free ->  %foo must be null
 define void @test15(i8* %foo) {
 ; CHECK-LABEL: @test15(
-; CHECK-NEXT:    call void @free(i8* [[FOO:%.*]]) #[[ATTR6:[0-9]+]]
+; CHECK-NEXT:    call void @free(i8* [[FOO:%.*]]) #[[ATTR7:[0-9]+]]
 ; CHECK-NEXT:    ret void
 ;
   call void @free(i8* %foo) nofree
   ret void
 }
 
 ; TODO: freeing a nonnull nofree pointer -> full UB
 define void @test16(i8* nonnull nofree %foo) {
 ; CHECK-LABEL: @test16(
 ; CHECK-NEXT:    call void @free(i8* [[FOO:%.*]])
 ; CHECK-NEXT:    ret void
 ;
   call void @free(i8* %foo)
   ret void
 }
+
+declare i8* @llvm.launder.invariant.group(i8*)
+declare i8* @llvm.strip.invariant.group(i8*)
+
+define void @test17() {
+; CHECK-LABEL: @test17(
+; CHECK-NEXT:    ret void
+;
+  %nw1 = call i8* @_Znwm(i64 32) builtin
+  %nw2 = call i8* @llvm.launder.invariant.group(i8* %nw1)
+  %nw3 = call i8* @llvm.strip.invariant.group(i8* %nw2)
+  store i8 1, i8* %nw3
+  call void @_ZdlPv(i8* %nw2) builtin
+  ret void
+}