[InstCombine] Drop reference to callee from an operand of erased call instruction

[evgeny777]

Summary

LLVM inliner gives a huge bonus (15000) to internal functions which have a single call site (hasOneUse is true). However this doesn't happen call uses bitcast expression referencing callee, because reference from that expression to callee is not being dropped by instcombine.

In practice this leads to a funny side effect when those two commands:

opt -instcombine -inline -S file.ll

and

opt -instcombine -S file.ll | opt -inline -S

may produce different results.

lib/Transforms/InstCombine/InstCombineCalls.cpp

else if (Caller->hasValueHandle()) {
     if (OldRetTy == NV->getType())
       ValueHandleBase::ValueIsRAUWd(Caller, NV);
     else
       // We cannot call ValueIsRAUWd with a different type, and the
       // actual tracked value will disappear.
       ValueHandleBase::ValueIsDeleted(Caller);
   }
 
+  // Drop references from bitcast constant expression to the callee.
+  if (auto *Op = dyn_cast<User>(Caller->getOperand(0)))
+    if (Op->hasOneUse())
+      Op->dropAllReferences();
+      
   eraseInstFromFunction(*Caller);
   return true;
 }
 
 /// Turn a call to a function created by init_trampoline / adjust_trampoline
 /// intrinsic pair into a direct call to the underlying function.
 Instruction *
 InstCombiner::transformCallThroughTrampoline(CallSite CS,

test/Transforms/Inline/inline-constexpr-cast-call.ll

+; RUN: opt < %s -instcombine -inline -inline-threshold=0
+
+; CHECK: define i32 @main() {
+; CHECK:   %1 = call i32 @rand()
+; CHECK:   %2 = call i32 @rand()
+; CHECK:   %3 = add nsw i32 %1, %2
+; CHECK:   ret i32 %3
+; CHECK: }
+
+define internal i32 @foo() #0 {
+  %1 = call i32 @rand() #2
+  %2 = call i32 @rand() #2
+  %3 = add nsw i32 %1, %2
+  ret i32 %3
+}
+
+declare i32 @rand() #1
+
+define i32 @main() #0 {
+  %1 = tail call i32 (...) bitcast (i32 ()* @foo to i32 (...)*)() #2
+  ret i32 %1
+}