https://github.com/Michael137 updated
https://github.com/llvm/llvm-project/pull/143686
>From 94a2cae4dfee6d943eaa93bd089e1c0e61b54356 Mon Sep 17 00:00:00 2001
From: Michael Buch <michaelbuc...@gmail.com>
Date: Wed, 11 Jun 2025 12:02:44 +0100
Subject: [PATCH 1/2] [lldb][Commands][NFC] Extract memory find expression
evaluation into helpers
This patch factors out the `-e` option logic into two helper functions.
The `EvaluateExpression` helper might seem redundant but I'll be adding
to it in a follow-up patch to fix and issue when running `memory find
-e` for Swift targets.
Also adds test coverage for the error cases that were previously
untested.
rdar://152113525
---
lldb/source/Commands/CommandObjectMemory.cpp | 104 ++++++++++--------
.../memory/find/TestMemoryFind.py | 31 ++++++
.../API/functionalities/memory/find/main.cpp | 16 +++
3 files changed, 108 insertions(+), 43 deletions(-)
diff --git a/lldb/source/Commands/CommandObjectMemory.cpp
b/lldb/source/Commands/CommandObjectMemory.cpp
index 7140333bb3cde..34230df9b2727 100644
--- a/lldb/source/Commands/CommandObjectMemory.cpp
+++ b/lldb/source/Commands/CommandObjectMemory.cpp
@@ -885,6 +885,55 @@ class CommandObjectMemoryRead : public CommandObjectParsed
{
#define LLDB_OPTIONS_memory_find
#include "CommandOptions.inc"
+static llvm::Error CopyExpressionResult(ValueObject &result,
+ DataBufferHeap &buffer) {
+ uint64_t value = result.GetValueAsUnsigned(0);
+ auto size_or_err = result.GetCompilerType().GetByteSize(nullptr);
+ if (!size_or_err)
+ return size_or_err.takeError();
+
+ switch (*size_or_err) {
+ case 1: {
+ uint8_t byte = (uint8_t)value;
+ buffer.CopyData(&byte, 1);
+ } break;
+ case 2: {
+ uint16_t word = (uint16_t)value;
+ buffer.CopyData(&word, 2);
+ } break;
+ case 4: {
+ uint32_t lword = (uint32_t)value;
+ buffer.CopyData(&lword, 4);
+ } break;
+ case 8: {
+ buffer.CopyData(&value, 8);
+ } break;
+ case 3:
+ case 5:
+ case 6:
+ case 7:
+ return llvm::createStringError("unknown type. pass a string instead");
+ default:
+ return llvm::createStringError(
+ "result size larger than 8 bytes. pass a string instead");
+ }
+
+ return llvm::Error::success();
+}
+
+static llvm::Expected<ValueObjectSP>
+EvaluateExpression(llvm::StringRef expression, StackFrame &frame,
+ Process &process) {
+ ValueObjectSP result_sp;
+ auto status =
+ process.GetTarget().EvaluateExpression(expression, &frame, result_sp);
+ if (status != eExpressionCompleted || !result_sp)
+ return llvm::createStringError(
+ "expression evaluation failed. pass a string instead");
+
+ return result_sp;
+}
+
// Find the specified data in memory
class CommandObjectMemoryFind : public CommandObjectParsed {
public:
@@ -1026,49 +1075,18 @@ class CommandObjectMemoryFind : public
CommandObjectParsed {
}
buffer.CopyData(str);
} else if (m_memory_options.m_expr.OptionWasSet()) {
- StackFrame *frame = m_exe_ctx.GetFramePtr();
- ValueObjectSP result_sp;
- if ((eExpressionCompleted ==
- process->GetTarget().EvaluateExpression(
- m_memory_options.m_expr.GetValueAs<llvm::StringRef>().value_or(
- ""),
- frame, result_sp)) &&
- result_sp) {
- uint64_t value = result_sp->GetValueAsUnsigned(0);
- std::optional<uint64_t> size = llvm::expectedToOptional(
- result_sp->GetCompilerType().GetByteSize(nullptr));
- if (!size)
- return;
- switch (*size) {
- case 1: {
- uint8_t byte = (uint8_t)value;
- buffer.CopyData(&byte, 1);
- } break;
- case 2: {
- uint16_t word = (uint16_t)value;
- buffer.CopyData(&word, 2);
- } break;
- case 4: {
- uint32_t lword = (uint32_t)value;
- buffer.CopyData(&lword, 4);
- } break;
- case 8: {
- buffer.CopyData(&value, 8);
- } break;
- case 3:
- case 5:
- case 6:
- case 7:
- result.AppendError("unknown type. pass a string instead");
- return;
- default:
- result.AppendError(
- "result size larger than 8 bytes. pass a string instead");
- return;
- }
- } else {
- result.AppendError(
- "expression evaluation failed. pass a string instead");
+ auto result_or_err = EvaluateExpression(
+ m_memory_options.m_expr.GetValueAs<llvm::StringRef>().value_or(""),
+ m_exe_ctx.GetFrameRef(), *process);
+ if (!result_or_err) {
+ result.AppendError(llvm::toString(result_or_err.takeError()));
+ return;
+ }
+
+ ValueObjectSP result_sp = *result_or_err;
+
+ if (auto err = CopyExpressionResult(*result_sp, buffer)) {
+ result.AppendError(llvm::toString(std::move(err)));
return;
}
} else {
diff --git a/lldb/test/API/functionalities/memory/find/TestMemoryFind.py
b/lldb/test/API/functionalities/memory/find/TestMemoryFind.py
index 09611cc808777..1b9acb8d3090e 100644
--- a/lldb/test/API/functionalities/memory/find/TestMemoryFind.py
+++ b/lldb/test/API/functionalities/memory/find/TestMemoryFind.py
@@ -79,3 +79,34 @@ def test_memory_find(self):
'memory find -s "nothere" `stringdata` `stringdata+10`',
substrs=["data not found within the range."],
)
+
+ # Expression results with unsupported result types.
+ self.expect(
+ 'memory find -e "ThreeBytes{}" `&bytedata[0]` `&bytedata[2]`',
+ substrs=["unknown type."],
+ error=True,
+ )
+
+ self.expect(
+ 'memory find -e "FiveBytes{}" `&bytedata[0]` `&bytedata[2]`',
+ substrs=["unknown type."],
+ error=True,
+ )
+
+ self.expect(
+ 'memory find -e "SixBytes{}" `&bytedata[0]` `&bytedata[2]`',
+ substrs=["unknown type."],
+ error=True,
+ )
+
+ self.expect(
+ 'memory find -e "SevenBytes{}" `&bytedata[0]` `&bytedata[2]`',
+ substrs=["unknown type."],
+ error=True,
+ )
+
+ self.expect(
+ 'memory find -e "NineBytes{}" `&bytedata[0]` `&bytedata[2]`',
+ substrs=["result size larger than 8 bytes."],
+ error=True,
+ )
diff --git a/lldb/test/API/functionalities/memory/find/main.cpp
b/lldb/test/API/functionalities/memory/find/main.cpp
index e3dcfc762ee0f..a5ee27c5c487d 100644
--- a/lldb/test/API/functionalities/memory/find/main.cpp
+++ b/lldb/test/API/functionalities/memory/find/main.cpp
@@ -1,9 +1,25 @@
#include <stdio.h>
#include <stdint.h>
+template<size_t T>
+struct [[gnu::packed]] Payload {
+ uint8_t data[T];
+};
+
+using ThreeBytes = Payload<3>;
+using FiveBytes = Payload<5>;
+using SixBytes = Payload<5>;
+using SevenBytes = Payload<7>;
+using NineBytes = Payload<9>;
+
int main (int argc, char const *argv[])
{
const char* stringdata = "hello world; I like to write text in const char
pointers";
uint8_t bytedata[] =
{0xAA,0xBB,0xCC,0xDD,0xEE,0xFF,0x00,0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88,0x99};
+ ThreeBytes b1;
+ FiveBytes b2;
+ SixBytes b3;
+ SevenBytes b4;
+ NineBytes b5;
return 0; // break here
}
>From e6622bd9fcfa4e70baa92c2fd5950d08084b8fb5 Mon Sep 17 00:00:00 2001
From: Michael Buch <michaelbuc...@gmail.com>
Date: Wed, 11 Jun 2025 12:27:33 +0100
Subject: [PATCH 2/2] fixup! clang-format
---
lldb/test/API/functionalities/memory/find/main.cpp | 3 +--
1 file changed, 1 insertion(+), 2 deletions(-)
diff --git a/lldb/test/API/functionalities/memory/find/main.cpp
b/lldb/test/API/functionalities/memory/find/main.cpp
index a5ee27c5c487d..15c8df1a9fcf1 100644
--- a/lldb/test/API/functionalities/memory/find/main.cpp
+++ b/lldb/test/API/functionalities/memory/find/main.cpp
@@ -1,8 +1,7 @@
#include <stdio.h>
#include <stdint.h>
-template<size_t T>
-struct [[gnu::packed]] Payload {
+template <size_t T> struct [[gnu::packed]] Payload {
uint8_t data[T];
};
_______________________________________________
lldb-commits mailing list
lldb-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
