[PPC] Handling CallInst in PPCBoolRetToInt

[Carrot]

Summary

This patch fixes pr25548.

Current implementation of PPCBoolRetToInt doesn't handle CallInst correctly, so it failed to do the intended optimization when there is a CallInst with parameters. This patch fixed that.

[tjablin]

I believe the code is correct, but I have a few quibbles.

1. Could you add comments on lines 70 and 232 explaining why CallInsts are skipped?
2. On line 226, "There were set" => "They were set" Sorry. This was originally my typo.
3. I think most reviewers like full context for patches on phabricator. Please use one of the diff commands found here: http://llvm.org/docs/Phabricator.html#requesting-a-review-via-the-web-interface

Thanks!

[Carrot]

Add comments for CallInst handling.

[tjablin]

LGTM

[kbarton]

LTGM

[tjablin]

Did this ever land upstream? PR25548 is still open and I can't find a matching commit.

[Eugene.Zelenko]

Committed in r277655. Please specify Differential revision in commit message.

lib/Target/PowerPC/PPCBoolRetToInt.cpp

           "Total number of times a bool was promoted to an int");
 
 class PPCBoolRetToInt : public FunctionPass {
 
   static SmallPtrSet<Value *, 8> findAllDefs(Value *V) {
     SmallPtrSet<Value *, 8> Defs;
     SmallVector<Value *, 8> WorkList;
     WorkList.push_back(V);
     Defs.insert(V);
     while (!WorkList.empty()) {
       Value *Curr = WorkList.back();
       WorkList.pop_back();
-      if (User *CurrUser = dyn_cast<User>(Curr))
+      User *CurrUser = dyn_cast<User>(Curr);
+      if (CurrUser && !isa<CallInst>(Curr))
         for (auto &Op : CurrUser->operands())
           if (Defs.insert(Op).second)
             WorkList.push_back(Op);
     }
     return Defs;
   }
 
   // Translate a i1 value to an equivalent i32 value:
   static Value *translate(Value *V) {
     Type *Int32Ty = Type::getInt32Ty(V->getContext());
     if (Constant *C = dyn_cast<Constant>(V))
       return ConstantExpr::getZExt(C, Int32Ty);

 
     return Changed;
   }
 
   static bool runOnUse(Use &U, const PHINodeSet &PromotablePHINodes,
                        B2IMap &BoolToIntMap) {
     auto Defs = findAllDefs(U);
 
     // If the values are all Constants or Arguments, don't bother
     if (!std::any_of(Defs.begin(), Defs.end(), isa<Instruction, Value *>))
       return false;
 
-    // Presently, we only know how to handle PHINode, Constant, and Arguments.
-    // Potentially, bitwise operations (AND, OR, XOR, NOT) and sign extension
-    // could also be handled in the future.
+    // Presently, we only know how to handle PHINode, Constant, Arguments and
+    // CallInst. Potentially, bitwise operations (AND, OR, XOR, NOT) and sign
+    // extension could also be handled in the future.
     for (Value *V : Defs)
-      if (!isa<PHINode>(V) && !isa<Constant>(V) && !isa<Argument>(V))
+      if (!isa<PHINode>(V) && !isa<Constant>(V) &&
+          !isa<Argument>(V) && !isa<CallInst>(V))
         return false;
 
     for (Value *V : Defs)
       if (const PHINode *P = dyn_cast<PHINode>(V))
         if (!PromotablePHINodes.count(P))
           return false;
 
     if (isa<ReturnInst>(U.getUser()))
       ++NumBoolRetPromotion;
     if (isa<CallInst>(U.getUser()))
       ++NumBoolCallPromotion;
     ++NumBoolToIntPromotion;
 
     for (Value *V : Defs)
       if (!BoolToIntMap.count(V))
         BoolToIntMap[V] = translate(V);
 
     // Replace the operands of the translated instructions. There were set to
     // zero in the translate function.
     for (auto &Pair : BoolToIntMap) {
       User *First = dyn_cast<User>(Pair.first);
       User *Second = dyn_cast<User>(Pair.second);
       assert((!First || Second) && "translated from user to non-user!?");
-      if (First)
+      if (First && !isa<CallInst>(First))
         for (unsigned i = 0; i < First->getNumOperands(); ++i)
           Second->setOperand(i, BoolToIntMap[First->getOperand(i)]);
     }
 
     Value *IntRetVal = BoolToIntMap[U];
     Type *Int1Ty = Type::getInt1Ty(U->getContext());
     Instruction *I = cast<Instruction>(U.getUser());
     Value *BackToBool = new TruncInst(IntRetVal, Int1Ty, "backToBool", I);
     U.set(BackToBool);
 
     return true;
   }

test/CodeGen/PowerPC/BoolRetToIntTest.ll

 ; CHECK: [[REG:%.+]] = trunc i32 {{%.+}} to i1
 ; CHECK: ret i1 [[REG]]
   %result = phi i1 [ %bar, %foo], [ %operand, %entry ]
   ret i1 %result
 }
 
 declare zeroext i1 @return_i1()
 
 ; CHECK-LABEL: call_test
 define zeroext i1 @call_test() {
 ; CHECK: [[REG:%.+]] = call i1
   %result = call i1 @return_i1()
+; CHECK: [[REG:%.+]] = zext i1 {{%.+}} to i32
+; CHECK: [[REG:%.+]] = trunc i32 {{%.+}} to i1
 ; CHECK: ret i1 [[REG]]
   ret i1 %result
-}
+}