[Reassociate][NFC] Use an appropriate `dyn_cast` for `BinaryOperator`

[wristow]

Summary

In D129523, it was noted by @spatel that there is are some questionable naked
casts from Instruction to BinaryOperator. Specifically, Sanjay noted
regarding isReassociableOp:

Existing issue: this is awkward - we're dyn_casting to Instruction, but then we nakedly
cast to BinaryOperator on the return. Could this cast to BO directly? There might be
some subtlety with binop constant expressions that needs to be addressed.

Looking into this, it seems to me it's a guaranteed-safe change, and a small
improvement. The result of the dyn_cast is checked for non-null, and when that
passes more elaborate aspects are checked before returning the desired
BinaryOperator on success (and nullptr is returned if any of the checks
fail). Changing the cast directly to BO results in the dyn_cast returning
null in more cases, and so we skip the more elaborate checking which is
guaranteed to have either been pointless, or exposing a bug. (The bug would
only manifest if an inappropriate Opcode were passed (which presumably doesn't
happen). So I'd say the existing code isn't a problem, but this way is better.)

[nikic]

LG. This should not affect constexpr behavior, because BinaryOperator is, despite its wonderful name, not an Operator (unlike OverflowingBinaryOperator -- go figure!)

[RKSimon]

llvm/lib/Transforms/Scalar/Reassociate.cpp

157–160

(style) use auto *

166–170

(style) use auto *

[spatel]

In D130448#3675592, @nikic wrote:

LG. This should not affect constexpr behavior, because BinaryOperator is, despite its wonderful name, not an Operator (unlike OverflowingBinaryOperator -- go figure!)

Wow...I didn't notice that in all my time working on LLVM. :)

[wristow]

Thanks for the quick reviews!

llvm/lib/Transforms/Scalar/Reassociate.cpp

 static bool hasFPAssociativeFlags(Instruction *I) {
   assert(I && isa<FPMathOperator>(I) && "Should only check FP ops");
   return I->hasAllowReassoc() && I->hasNoSignedZeros();
 }
 
 /// Return true if V is an instruction of the specified opcode and if it
 /// only has one use.
 static BinaryOperator *isReassociableOp(Value *V, unsigned Opcode) {
-  auto *I = dyn_cast<Instruction>(V);
-  if (I && I->hasOneUse() && I->getOpcode() == Opcode)
-    if (!isa<FPMathOperator>(I) || hasFPAssociativeFlags(I))
-      return cast<BinaryOperator>(I);
+  auto *BO = dyn_cast<BinaryOperator>(V);
+  if (BO && BO->hasOneUse() && BO->getOpcode() == Opcode)
+    if (!isa<FPMathOperator>(BO) || hasFPAssociativeFlags(BO))
+      return BO;
   return nullptr;
 }
 
 static BinaryOperator *isReassociableOp(Value *V, unsigned Opcode1,
                                         unsigned Opcode2) {
-  auto *I = dyn_cast<Instruction>(V);
-  if (I && I->hasOneUse() &&
-      (I->getOpcode() == Opcode1 || I->getOpcode() == Opcode2))
-    if (!isa<FPMathOperator>(I) || hasFPAssociativeFlags(I))
-      return cast<BinaryOperator>(I);
+  auto *BO = dyn_cast<BinaryOperator>(V);
+  if (BO && BO->hasOneUse() &&
+      (BO->getOpcode() == Opcode1 || BO->getOpcode() == Opcode2))
+    if (!isa<FPMathOperator>(BO) || hasFPAssociativeFlags(BO))
+      return BO;
   return nullptr;
 }
 
 void ReassociatePass::BuildRankMap(Function &F,
                                    ReversePostOrderTraversal<Function*> &RPOT) {
   unsigned Rank = 2;
 
   // Assign distinct ranks to function arguments.