Cleaned up some of the "frame diagnose" code to use Operands as currency.

Also added some utility functions around Operands to make code easier and more
compact to write.

llvm-svn: 281398

1 files changed, 113 insertions, 0 deletions

diff --git a/lldb/source/Core/Disassembler.cpp b/lldb/source/Core/Disassembler.cpp
index 84665c0ebb8..fa55c8a64fd 100644
--- a/lldb/source/Core/Disassembler.cpp
+++ b/lldb/source/Core/Disassembler.cpp
@@ -1320,3 +1320,116 @@ void PseudoInstruction::SetDescription(const char *description) {
   if (description && strlen(description) > 0)
     m_description = description;
 }
+
+Instruction::Operand Instruction::Operand::BuildRegister(ConstString &r) {
+  Operand ret;
+  ret.m_type = Type::Register;
+  ret.m_register = r;
+  return ret;
+}
+
+Instruction::Operand Instruction::Operand::BuildImmediate(lldb::addr_t imm,
+                                                          bool neg) {
+  Operand ret;
+  ret.m_type = Type::Immediate;
+  ret.m_immediate = imm;
+  ret.m_negative = neg;
+  return ret;
+}
+
+Instruction::Operand Instruction::Operand::BuildImmediate(int64_t imm) {
+  Operand ret;
+  ret.m_type = Type::Immediate;
+  if (imm < 0) {
+    ret.m_immediate = -imm;
+    ret.m_negative = true;
+  } else {
+    ret.m_immediate = imm;
+    ret.m_negative = false;
+  }
+  return ret;
+}
+
+Instruction::Operand
+Instruction::Operand::BuildDereference(const Operand &ref) {
+  Operand ret;
+  ret.m_type = Type::Dereference;
+  ret.m_children = {ref};
+  return ret;
+}
+
+Instruction::Operand Instruction::Operand::BuildSum(const Operand &lhs,
+                                                    const Operand &rhs) {
+  Operand ret;
+  ret.m_type = Type::Sum;
+  ret.m_children = {lhs, rhs};
+  return ret;
+}
+
+Instruction::Operand Instruction::Operand::BuildProduct(const Operand &lhs,
+                                                        const Operand &rhs) {
+  Operand ret;
+  ret.m_type = Type::Product;
+  ret.m_children = {lhs, rhs};
+  return ret;
+}
+
+std::function<bool(const Instruction::Operand &)>
+lldb_private::OperandMatchers::MatchBinaryOp(
+    std::function<bool(const Instruction::Operand &)> base,
+    std::function<bool(const Instruction::Operand &)> left,
+    std::function<bool(const Instruction::Operand &)> right) {
+  return [base, left, right](const Instruction::Operand &op) -> bool {
+    return (base(op) && op.m_children.size() == 2 &&
+            ((left(op.m_children[0]) && right(op.m_children[1])) ||
+             (left(op.m_children[1]) && right(op.m_children[0]))));
+  };
+}
+
+std::function<bool(const Instruction::Operand &)>
+lldb_private::OperandMatchers::MatchUnaryOp(
+    std::function<bool(const Instruction::Operand &)> base,
+    std::function<bool(const Instruction::Operand &)> child) {
+  return [base, child](const Instruction::Operand &op) -> bool {
+    return (base(op) && op.m_children.size() == 1 && child(op.m_children[0]));
+  };
+}
+
+std::function<bool(const Instruction::Operand &)>
+lldb_private::OperandMatchers::MatchRegOp(const RegisterInfo &info) {
+  return [&info](const Instruction::Operand &op) {
+    return (op.m_type == Instruction::Operand::Type::Register &&
+            (op.m_register == ConstString(info.name) ||
+             op.m_register == ConstString(info.alt_name)));
+  };
+}
+
+std::function<bool(const Instruction::Operand &)>
+lldb_private::OperandMatchers::MatchImmOp(int64_t imm) {
+  return [imm](const Instruction::Operand &op) {
+    return (op.m_type == Instruction::Operand::Type::Immediate &&
+            ((op.m_negative && op.m_immediate == (uint64_t)-imm) ||
+             (!op.m_negative && op.m_immediate == (uint64_t)imm)));
+  };
+}
+
+std::function<bool(const Instruction::Operand &)>
+lldb_private::OperandMatchers::FetchImmOp(int64_t &imm) {
+  return [&imm](const Instruction::Operand &op) {
+    if (op.m_type != Instruction::Operand::Type::Immediate) {
+      return false;
+    }
+    if (op.m_negative) {
+      imm = -((int64_t)op.m_immediate);
+    } else {
+      imm = ((int64_t)op.m_immediate);
+    }
+    return true;
+  };
+}
+
+std::function<bool(const Instruction::Operand &)>
+lldb_private::OperandMatchers::MatchOpType(Instruction::Operand::Type type) {
+  return [type](const Instruction::Operand &op) { return op.m_type == type; };
+}
+