[LLDB] Add SBInstruction::GetControlFlowKind()

[jj10306]

Summary

D128477 adds the control flow kind for Instruction and displays this
in the thread trace dump instruction -k command.

This diff exposes the control flow kind via the new
SBInstruction::GetControlFlowKind method.

I've expanded TestDisassembleRawData to test this method, but please
let me know if there are any other unittests that should also be updated.

Test Plan:
./bin/lldb-dotest -p TestDisassembleRawData

[wallace]

great!

lldb/source/API/SBInstruction.cpp

176

this might be potentially expensive. If this slows traversals down, eventually we can create an unsafe version of this method that avoids mutexes but is faster.

lldb/bindings/interface/SBInstruction.i

public:
     GetMnemonic (lldb::SBTarget target);
 
     const char *
     GetOperands (lldb::SBTarget target);
 
     const char *
     GetComment (lldb::SBTarget target);
 
+    lldb::InstructionControlFlowKind
+    GetControlFlowKind(lldb::SBTarget target);
+
     lldb::SBData
     GetData (lldb::SBTarget target);
 
     size_t
     GetByteSize ();
 
     bool
     DoesBranch ();

lldb/include/lldb/API/SBInstruction.h

public:
   SBAddress GetAddress();
 
   const char *GetMnemonic(lldb::SBTarget target);
 
   const char *GetOperands(lldb::SBTarget target);
 
   const char *GetComment(lldb::SBTarget target);
 
+  lldb::InstructionControlFlowKind GetControlFlowKind(lldb::SBTarget target);
+
   lldb::SBData GetData(lldb::SBTarget target);
 
   size_t GetByteSize();
 
   bool DoesBranch();
 
   bool HasDelaySlot();
 

lldb/source/API/SBInstruction.cpp

if (target_sp) {
       target_sp->CalculateExecutionContext(exe_ctx);
       exe_ctx.SetProcessSP(target_sp->GetProcessSP());
     }
     return inst_sp->GetComment(&exe_ctx);
   }
   return nullptr;
 }
 
+lldb::InstructionControlFlowKind SBInstruction::GetControlFlowKind(lldb::SBTarget target) {
+  LLDB_INSTRUMENT_VA(this, target);
+
+  lldb::InstructionSP inst_sp(GetOpaque());
+  if (inst_sp) {
+    ExecutionContext exe_ctx;
+    TargetSP target_sp(target.GetSP());
+    std::unique_lock<std::recursive_mutex> lock;
+    if (target_sp) {
+      lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
+
+      target_sp->CalculateExecutionContext(exe_ctx);
+      exe_ctx.SetProcessSP(target_sp->GetProcessSP());
+    }
+    return inst_sp->GetControlFlowKind(&exe_ctx);
+  }
+  return lldb::eInstructionControlFlowKindUnknown;
+}
+
 size_t SBInstruction::GetByteSize() {
   LLDB_INSTRUMENT_VA(this);
 
   lldb::InstructionSP inst_sp(GetOpaque());
   if (inst_sp)
     return inst_sp->GetOpcode().GetByteSize();
   return 0;
 }

lldb/test/API/python_api/disassemble-raw-data/TestDisassembleRawData.py

def test_disassemble_raw_data(self):
         if self.TraceOn():
             print()
             print("Raw bytes:    ", [hex(x) for x in raw_bytes])
             print("Disassembled%s" % str(inst))
         if re.match("mips", arch):
             self.assertEqual(inst.GetMnemonic(target), "move")
             self.assertEqual(inst.GetOperands(target),
                             '$' + "fp, " + '$' + "sp")
+            self.assertEqual(inst.GetControlFlowKind(target),
+                            lldb.eInstructionControlFlowKindUnknown)
         elif re.match("powerpc64le", arch):
             self.assertEqual(inst.GetMnemonic(target), "li")
             self.assertEqual(inst.GetOperands(target), "4, 0")
+            self.assertEqual(inst.GetControlFlowKind(target),
+                            lldb.eInstructionControlFlowKindUnknown)
         elif arch in ("aarch64", "arm64"):
             self.assertEqual(inst.GetMnemonic(target), "mov")
             self.assertEqual(inst.GetOperands(target), "w0, #0x63")
+            self.assertEqual(inst.GetControlFlowKind(target),
+                            lldb.eInstructionControlFlowKindUnknown)
         elif arch == "arm":
             self.assertEqual(inst.GetMnemonic(target), "mov")
             self.assertEqual(inst.GetOperands(target), "r3, #99")
+            self.assertEqual(inst.GetControlFlowKind(target),
+                            lldb.eInstructionControlFlowKindUnknown)
         else:
             self.assertEqual(inst.GetMnemonic(target), "movq")
             self.assertEqual(inst.GetOperands(target),
                             '%' + "rsp, " + '%' + "rbp")
+            self.assertEqual(inst.GetControlFlowKind(target),
+                            lldb.eInstructionControlFlowKindOther)