[BOLT][NFC] Change signature of MCPlusBuilder::isUnsupportedBranch()

[maksfb]

Summary

Make MCPlusBuilder::isUnsupportedBranch() take MCInst, not opcode.

bolt/include/bolt/Core/MCPlusBuilder.h

public:
 
   /// Returns true if the instruction is register indirect call or jump
   virtual bool isBranchOnReg(const MCInst &Inst) const {
     llvm_unreachable("not implemented");
     return false;
   }
 
   /// Check whether we support inverting this branch
-  virtual bool isUnsupportedBranch(unsigned Opcode) const { return false; }
+  virtual bool isUnsupportedBranch(const MCInst &Inst) const { return false; }
 
   /// Return true of the instruction is of pseudo kind.
   bool isPseudo(const MCInst &Inst) const {
     return Info->get(Inst.getOpcode()).isPseudo();
   }
 
   /// Return true if the relocation type needs to be registered in the function.
   /// These code relocations are used in disassembly to better understand code.

bolt/lib/Core/BinaryFunction.cpp

if (MIB->isBranch(Instruction) || MIB->isCall(Instruction)) {
         // a call, possibly a tail call.
         //
         // If the target *is* the function address it could be either a branch
         // or a recursive call.
         bool IsCall = MIB->isCall(Instruction);
         const bool IsCondBranch = MIB->isConditionalBranch(Instruction);
         MCSymbol *TargetSymbol = nullptr;
 
-        if (BC.MIB->isUnsupportedBranch(Instruction.getOpcode())) {
+        if (BC.MIB->isUnsupportedBranch(Instruction)) {
           setIgnored();
           if (BinaryFunction *TargetFunc =
                   BC.getBinaryFunctionContainingAddress(TargetAddress))
             TargetFunc->setIgnored();
         }
 
         if (IsCall && containsAddress(TargetAddress)) {
           if (TargetAddress == getAddress()) {
if (BB->succ_size() == 1) {
       if (BB->getSuccessor() == NextBB)
         continue;
       BB->addBranchInstruction(BB->getSuccessor());
     } else if (BB->succ_size() == 2) {
       assert(CondBranch && "conditional branch expected");
       const BinaryBasicBlock *TSuccessor = BB->getConditionalSuccessor(true);
       const BinaryBasicBlock *FSuccessor = BB->getConditionalSuccessor(false);
       // Check whether we support reversing this branch direction
-      const bool IsSupported =
-          !MIB->isUnsupportedBranch(CondBranch->getOpcode());
+      const bool IsSupported = !MIB->isUnsupportedBranch(*CondBranch);
       if (NextBB && NextBB == TSuccessor && IsSupported) {
         std::swap(TSuccessor, FSuccessor);
         {
           auto L = BC.scopeLock();
           MIB->reverseBranchCondition(*CondBranch, TSuccessor->getLabel(), Ctx);
         }
         BB->swapConditionalSuccessors();
       } else {

bolt/lib/Passes/Instrumentation.cpp

for (auto I = BB.begin(); I != BB.end(); ++I) {
         continue;
 
       const bool IsJumpTable = Function.getJumpTable(Inst);
       if (IsJumpTable)
         HasJumpTable = true;
       else if (BC.MIB->isUnconditionalBranch(Inst))
         HasUnconditionalBranch = true;
       else if ((!BC.MIB->isCall(Inst) && !BC.MIB->isConditionalBranch(Inst)) ||
-               BC.MIB->isUnsupportedBranch(Inst.getOpcode()))
+               BC.MIB->isUnsupportedBranch(Inst))
         continue;
 
       const uint32_t FromOffset = *BC.MIB->getOffset(Inst);
       const MCSymbol *Target = BC.MIB->getTargetSymbol(Inst);
       BinaryBasicBlock *TargetBB = Function.getBasicBlockForLabel(Target);
       uint32_t ToOffset = TargetBB ? TargetBB->getInputOffset() : 0;
       BinaryFunction *TargetFunc =
           TargetBB ? &Function : BC.getFunctionForSymbol(Target);

bolt/lib/Target/X86/X86MCPlusBuilder.cpp

bool isMoveMem2Reg(const MCInst &Inst) const override {
     case X86::MOV16rm:
     case X86::MOV32rm:
     case X86::MOV64rm:
       return true;
     }
     return false;
   }
 
-  bool isUnsupportedBranch(unsigned Opcode) const override {
-    switch (Opcode) {
+  bool isUnsupportedBranch(const MCInst &Inst) const override {
+    switch (Inst.getOpcode()) {
     default:
       return false;
     case X86::LOOP:
     case X86::LOOPE:
     case X86::LOOPNE:
     case X86::JECXZ:
     case X86::JRCXZ:
       return true;
while (I != Begin) {
         const MCSymbol *Sym = getTargetSymbol(*I);
         assert(Sym != nullptr &&
                "Couldn't extract BB symbol from jump operand");
         TBB = Sym;
         continue;
       }
 
       // Handle conditional branches and ignore indirect branches
-      if (!isUnsupportedBranch(I->getOpcode()) &&
-          getCondCode(*I) == X86::COND_INVALID) {
+      if (!isUnsupportedBranch(*I) && getCondCode(*I) == X86::COND_INVALID) {
         // Indirect branch
         return false;
       }
 
       if (CondBranch == nullptr) {
         const MCSymbol *TargetBB = getTargetSymbol(*I);
         if (TargetBB == nullptr) {
           // Unrecognized branch target