Update TailCallElim to avoid making redundant changes

[kmod]

Summary

While experimenting with an iterated optimization pipeline, I noticed that
the standard optimization pipeline would always change (most) functions.
I tracked it down to TailCallElim always calling setTailCall(), even if the call
is already a tail call; with this change the pipeline does convege after a few
iterations.

[dexonsmith]

Code is obviously correct, but can you add a testcase?

I think you can observe this misbehaviour in opt by setting
-debug-pass=Executions, which should print a "Made Modifications"
line to dbgs() when a pass reports change things. You’ll also need
a "REQUIRES: asserts" line.

[kmod]

Looks like this feature got included in some recent broader work on TailCallElim.

lib/Transforms/Scalar/TailRecursionElimination.cpp

bool TailCallElim::runOnFunction(Function &F) {
   // implies ensuring that there does not exist any path from a call that takes
   // in an alloca but does not capture it and the call which we wish to mark
   // with "tail".
   if (!F.callsFunctionThatReturnsTwice()) {
     for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) {
       for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) {
         if (CallInst *CI = dyn_cast<CallInst>(I)) {
           if (!ACT.UsesAlloca.count(CI)) {
+            if (!CI->isTailCall()) {
               CI->setTailCall();
               MadeChange = true;
             }
           }
         }
       }
     }
+  }
 
   return MadeChange;
 }
 
 
 /// CanMoveAboveCall - Return true if it is safe to move the specified
 /// instruction from after the call to before the call, assuming that all
 /// instructions between the call and this instruction are movable.