adding DisassembledInstruction unit tests

Author: eronnen

lldb/tools/lldb-dap/Handler/DisassembleRequestHandler.cpp

@@ -82,7 +82,7 @@ DisassembleRequestHandler::Run(const DisassembleArguments &args) const {
     }
 
     DisassembledInstruction disassembled_inst;
-    disassembled_inst.address = "0x" + llvm::utohexstr(inst_addr);
+    disassembled_inst.address = inst_addr;
     disassembled_inst.instructionBytes =
         bytes.size() > 0 ? bytes.substr(0, bytes.size() - 1) : "";
 

lldb/tools/lldb-dap/Protocol/ProtocolTypes.cpp

@@ -7,6 +7,9 @@
 //===----------------------------------------------------------------------===//
 
 #include "Protocol/ProtocolTypes.h"
+#include "JSONUtils.h"
+#include "lldb/lldb-types.h"
+#include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/JSON.h"
@@ -782,18 +785,69 @@ bool fromJSON(const llvm::json::Value &Params, InstructionBreakpoint &IB,
          O.mapOptional("mode", IB.mode);
 }
 
+bool fromJSON(const llvm::json::Value &Params,
+              DisassembledInstruction::PresentationHint &PH,
+              llvm::json::Path P) {
+  auto rawHint = Params.getAsString();
+  if (!rawHint) {
+    P.report("expected a string");
+    return false;
+  }
+  std::optional<DisassembledInstruction::PresentationHint> hint =
+      StringSwitch<std::optional<DisassembledInstruction::PresentationHint>>(
+          *rawHint)
+          .Case("normal", DisassembledInstruction::
+                              eDisassembledInstructionPresentationHintNormal)
+          .Case("invalid", DisassembledInstruction::
+                               eDisassembledInstructionPresentationHintInvalid)
+          .Default(std::nullopt);
+  if (!hint) {
+    P.report("unexpected value");
+    return false;
+  }
+  PH = *hint;
+  return true;
+}
+
 llvm::json::Value toJSON(const DisassembledInstruction::PresentationHint &PH) {
   switch (PH) {
-  case DisassembledInstruction::eSourcePresentationHintNormal:
+  case DisassembledInstruction::eDisassembledInstructionPresentationHintNormal:
     return "normal";
-  case DisassembledInstruction::eSourcePresentationHintInvalid:
+  case DisassembledInstruction::eDisassembledInstructionPresentationHintInvalid:
     return "invalid";
   }
   llvm_unreachable("unhandled presentation hint.");
 }
 
+bool fromJSON(const llvm::json::Value &Params, DisassembledInstruction &DI,
+              llvm::json::Path P) {
+  std::optional<llvm::StringRef> raw_address =
+      Params.getAsObject()->getString("address");
+  if (!raw_address) {
+    P.report("missing `address` field");
+    return false;
+  }
+
+  std::optional<lldb::addr_t> address = DecodeMemoryReference(*raw_address);
+  if (!address) {
+    P.report("invalid `address`");
+    return false;
+  }
+
+  DI.address = *address;
+  llvm::json::ObjectMapper O(Params, P);
+  return O && O.map("instruction", DI.instruction) &&
+         O.mapOptional("instructionBytes", DI.instructionBytes) &&
+         O.mapOptional("symbol", DI.symbol) &&
+         O.mapOptional("location", DI.location) &&
+         O.mapOptional("line", DI.line) && O.mapOptional("column", DI.column) &&
+         O.mapOptional("endLine", DI.endLine) &&
+         O.mapOptional("endColumn", DI.endColumn) &&
+         O.mapOptional("presentationHint", DI.presentationHint);
+}
+
 llvm::json::Value toJSON(const DisassembledInstruction &DI) {
-  llvm::json::Object result{{"address", DI.address},
+  llvm::json::Object result{{"address", "0x" + llvm::utohexstr(DI.address)},
                             {"instruction", DI.instruction}};
 
   if (DI.instructionBytes)

lldb/tools/lldb-dap/Protocol/ProtocolTypes.h

@@ -631,13 +631,13 @@ bool fromJSON(const llvm::json::Value &, InstructionBreakpoint &,
 /// request.
 struct DisassembledInstruction {
   enum PresentationHint : unsigned {
-    eSourcePresentationHintNormal,
-    eSourcePresentationHintInvalid,
+    eDisassembledInstructionPresentationHintNormal,
+    eDisassembledInstructionPresentationHintInvalid,
   };
 
   /// The address of the instruction. Treated as a hex value if prefixed with
   /// `0x`, or as a decimal value otherwise.
-  std::string address;
+  lldb::addr_t address;
 
   /// Raw bytes representing the instruction and its operands, in an
   /// implementation-defined format.
@@ -678,7 +678,11 @@ struct DisassembledInstruction {
   /// Values: 'normal', 'invalid'
   std::optional<PresentationHint> presentationHint;
 };
+bool fromJSON(const llvm::json::Value &,
+              DisassembledInstruction::PresentationHint &, llvm::json::Path);
 llvm::json::Value toJSON(const DisassembledInstruction::PresentationHint &);
+bool fromJSON(const llvm::json::Value &, DisassembledInstruction &,
+              llvm::json::Path);
 llvm::json::Value toJSON(const DisassembledInstruction &);
 
 } // namespace lldb_dap::protocol

lldb/unittests/DAP/ProtocolTypesTest.cpp

@@ -530,3 +530,75 @@ TEST(ProtocolTypesTest, ChecksumAlgorithm) {
   llvm::json::Path::Root root;
   EXPECT_FALSE(fromJSON(invalid_value, deserialized_invalid, root));
 }
+
+TEST(ProtocolTypesTest, DisassembledInstructionPresentationHint) {
+  // Test all PresentationHint values.
+  std::vector<
+      std::pair<DisassembledInstruction::PresentationHint, llvm::StringRef>>
+      test_cases = {{DisassembledInstruction::
+                         eDisassembledInstructionPresentationHintNormal,
+                     "normal"},
+                    {DisassembledInstruction::
+                         eDisassembledInstructionPresentationHintInvalid,
+                     "invalid"}};
+
+  for (const auto &test_case : test_cases) {
+    // Serialize the PresentationHint to JSON.
+    llvm::json::Value serialized = toJSON(test_case.first);
+    ASSERT_EQ(serialized.kind(), llvm::json::Value::Kind::String);
+    EXPECT_EQ(serialized.getAsString(), test_case.second);
+
+    // Deserialize the JSON back to PresentationHint.
+    DisassembledInstruction::PresentationHint deserialized;
+    llvm::json::Path::Root root;
+    ASSERT_TRUE(fromJSON(serialized, deserialized, root))
+        << llvm::toString(root.getError());
+    EXPECT_EQ(deserialized, test_case.first);
+  }
+
+  // Test invalid value.
+  llvm::json::Value invalid_value = "invalid_hint";
+  DisassembledInstruction::PresentationHint deserialized_invalid;
+  llvm::json::Path::Root root;
+  EXPECT_FALSE(fromJSON(invalid_value, deserialized_invalid, root));
+}
+
+TEST(ProtocolTypesTest, DisassembledInstruction) {
+  DisassembledInstruction instruction;
+  instruction.address = 0x12345678;
+  instruction.instructionBytes = "0F 1F 00";
+  instruction.instruction = "mov eax, ebx";
+  instruction.symbol = "main";
+  instruction.location = Source{"test.cpp", "/path/to/test.cpp", 123,
+                                Source::eSourcePresentationHintNormal};
+  instruction.line = 10;
+  instruction.column = 5;
+  instruction.endLine = 15;
+  instruction.endColumn = 10;
+  instruction.presentationHint =
+      DisassembledInstruction::eDisassembledInstructionPresentationHintNormal;
+
+  llvm::Expected<DisassembledInstruction> deserialized_instruction =
+      roundtrip(instruction);
+  ASSERT_THAT_EXPECTED(deserialized_instruction, llvm::Succeeded());
+
+  EXPECT_EQ(instruction.address, deserialized_instruction->address);
+  EXPECT_EQ(instruction.instructionBytes,
+            deserialized_instruction->instructionBytes);
+  EXPECT_EQ(instruction.instruction, deserialized_instruction->instruction);
+  EXPECT_EQ(instruction.symbol, deserialized_instruction->symbol);
+  EXPECT_EQ(instruction.location->name,
+            deserialized_instruction->location->name);
+  EXPECT_EQ(instruction.location->path,
+            deserialized_instruction->location->path);
+  EXPECT_EQ(instruction.location->sourceReference,
+            deserialized_instruction->location->sourceReference);
+  EXPECT_EQ(instruction.location->presentationHint,
+            deserialized_instruction->location->presentationHint);
+  EXPECT_EQ(instruction.line, deserialized_instruction->line);
+  EXPECT_EQ(instruction.column, deserialized_instruction->column);
+  EXPECT_EQ(instruction.endLine, deserialized_instruction->endLine);
+  EXPECT_EQ(instruction.endColumn, deserialized_instruction->endColumn);
+  EXPECT_EQ(instruction.presentationHint,
+            deserialized_instruction->presentationHint);
+}