[Lldb-commits] [lldb] [lldb] Add SBValue::GetValueAsAddress API (PR #90144)
Jason Molenda via lldb-commits
lldb-commits at lists.llvm.org
Thu Apr 25 16:42:27 PDT 2024
https://github.com/jasonmolenda updated https://github.com/llvm/llvm-project/pull/90144
>From 3b66943d9c49fd5e71c2eb136b5bb3311e932bbc Mon Sep 17 00:00:00 2001
From: Jason Molenda <jmolenda at apple.com>
Date: Thu, 25 Apr 2024 15:51:44 -0700
Subject: [PATCH 1/2] [lldb] Add SBValue::GetValueAsAddress API
I previously added this API via https://reviews.llvm.org/D142792
in 2023, along with changes to the ValueObject class to treat
pointer types as addresses, and to annotate those ValueObjects
with the original uint64_t byte sequence AND the name of the
symbol once stripped, if that points to a symbol.
I did this unconditionally for all pointer type ValueObjects, and
it caused several regressions in the Objective-C data formatters
which have a ValueObject of an object, it has the address of its
class -- but with ObjC, sometimes it is a "tagged pointer" which
is metadata, not an actual pointer. (e.g. a small NSInteger value
is stored entirely in the tagged pointer, instead of a separate
object) Treating these not-addresses as addresses -- clearing the
non-addressable-bits -- is invalid.
The original version of this patch we're using downstream only
does this bits clearing for pointer types that are specifically
decorated with the pointerauth typequal, but not all of those
clang changes are upstreamed to github main yet, so I tried this
simpler approach and hit the tagged pointer issue and bailed on
the whole patch.
This patch, however, is simply adding SBValue::GetValueAsAddress
so script writers who know that an SBValue has an address in
memory, can strip off any metadata. It's an important API to have
for script writers when AArch64 ptrauth is in use, so I'm
going to put this part of the patch back on github main now until
we can get the rest of that original patch upstreamed.
---
lldb/bindings/interface/SBValueDocstrings.i | 20 +++++++
lldb/include/lldb/API/SBValue.h | 2 +
lldb/source/API/SBValue.cpp | 20 +++++++
.../Makefile | 3 +
.../TestClearSBValueNonAddressableBits.py | 60 +++++++++++++++++++
.../clear-sbvalue-nonaddressable-bits/main.c | 27 +++++++++
6 files changed, 132 insertions(+)
create mode 100644 lldb/test/API/clear-sbvalue-nonaddressable-bits/Makefile
create mode 100644 lldb/test/API/clear-sbvalue-nonaddressable-bits/TestClearSBValueNonAddressableBits.py
create mode 100644 lldb/test/API/clear-sbvalue-nonaddressable-bits/main.c
diff --git a/lldb/bindings/interface/SBValueDocstrings.i b/lldb/bindings/interface/SBValueDocstrings.i
index 6bab923e8b35a6..59fa807f5ec95c 100644
--- a/lldb/bindings/interface/SBValueDocstrings.i
+++ b/lldb/bindings/interface/SBValueDocstrings.i
@@ -135,6 +135,26 @@ linked list."
%feature("docstring", "Expands nested expressions like .a->b[0].c[1]->d."
) lldb::SBValue::GetValueForExpressionPath;
+%feature("docstring", "
+ Return the value as an address. On failure, LLDB_INVALID_ADDRESS
+ will be returned. On architectures like AArch64, where the
+ top (unaddressable) bits can be used for authentication,
+ memory tagging, or top byte ignore, this method will return
+ the value with those top bits cleared.
+
+ GetValueAsUnsigned returns the actual value, with the
+ authentication/Top Byte Ignore/Memory Tagging Extension bits.
+
+ Calling this on a random value which is not a pointer is
+ incorrect. Call GetType().IsPointerType() if in doubt.
+
+ An SB API program may want to show both the literal byte value
+ and the address it refers to in memory. These two SBValue
+ methods allow SB API writers to behave appropriately for their
+ interface."
+) lldb::SBValue::GetValueAsAddress;
+
+
%feature("doctstring", "
Returns the number for children.
diff --git a/lldb/include/lldb/API/SBValue.h b/lldb/include/lldb/API/SBValue.h
index bbcccaab51aaee..6fac0961910540 100644
--- a/lldb/include/lldb/API/SBValue.h
+++ b/lldb/include/lldb/API/SBValue.h
@@ -68,6 +68,8 @@ class LLDB_API SBValue {
uint64_t GetValueAsUnsigned(uint64_t fail_value = 0);
+ lldb::addr_t GetValueAsAddress();
+
ValueType GetValueType();
// If you call this on a newly created ValueObject, it will always return
diff --git a/lldb/source/API/SBValue.cpp b/lldb/source/API/SBValue.cpp
index 94a8f3ea319e89..c8b664c86ec2d9 100644
--- a/lldb/source/API/SBValue.cpp
+++ b/lldb/source/API/SBValue.cpp
@@ -909,6 +909,26 @@ uint64_t SBValue::GetValueAsUnsigned(uint64_t fail_value) {
return fail_value;
}
+lldb::addr_t SBValue::GetValueAsAddress() {
+ addr_t fail_value = LLDB_INVALID_ADDRESS;
+ ValueLocker locker;
+ lldb::ValueObjectSP value_sp(GetSP(locker));
+ if (value_sp) {
+ bool success = true;
+ uint64_t ret_val = fail_value;
+ ret_val = value_sp->GetValueAsUnsigned(fail_value, &success);
+ if (!success) {
+ return fail_value;
+ }
+ ProcessSP process_sp = m_opaque_sp->GetProcessSP();
+ if (!process_sp)
+ return ret_val;
+ return process_sp->FixDataAddress(ret_val);
+ }
+
+ return fail_value;
+}
+
bool SBValue::MightHaveChildren() {
LLDB_INSTRUMENT_VA(this);
diff --git a/lldb/test/API/clear-sbvalue-nonaddressable-bits/Makefile b/lldb/test/API/clear-sbvalue-nonaddressable-bits/Makefile
new file mode 100644
index 00000000000000..10495940055b63
--- /dev/null
+++ b/lldb/test/API/clear-sbvalue-nonaddressable-bits/Makefile
@@ -0,0 +1,3 @@
+C_SOURCES := main.c
+
+include Makefile.rules
diff --git a/lldb/test/API/clear-sbvalue-nonaddressable-bits/TestClearSBValueNonAddressableBits.py b/lldb/test/API/clear-sbvalue-nonaddressable-bits/TestClearSBValueNonAddressableBits.py
new file mode 100644
index 00000000000000..c91059358844ee
--- /dev/null
+++ b/lldb/test/API/clear-sbvalue-nonaddressable-bits/TestClearSBValueNonAddressableBits.py
@@ -0,0 +1,60 @@
+"""Test that SBValue clears non-addressable bits"""
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class TestClearSBValueNonAddressableBits(TestBase):
+
+ NO_DEBUG_INFO_TESTCASE = True
+
+ # On AArch64 systems, the top bits that are not used for
+ # addressing may be used for TBI, MTE, and/or pointer
+ # authentication.
+ @skipIf(archs=no_match(["aarch64", "arm64", "arm64e"]))
+
+ # Only run this test on systems where TBI is known to be
+ # enabled, so the address mask will clear the TBI bits.
+ @skipUnlessPlatform(["linux"] + lldbplatformutil.getDarwinOSTriples())
+ def test(self):
+ self.source = "main.c"
+ self.build()
+ (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(
+ self, "break here", lldb.SBFileSpec(self.source, False)
+ )
+
+ if self.TraceOn():
+ self.runCmd("frame variable")
+ self.runCmd("frame variable &count &global")
+
+ frame = thread.GetFrameAtIndex(0)
+
+ count_p = frame.FindVariable("count_p")
+ count_invalid_p = frame.FindVariable("count_invalid_p")
+ self.assertEqual(
+ count_p.GetValueAsUnsigned(), count_invalid_p.GetValueAsAddress()
+ )
+ self.assertNotEqual(
+ count_invalid_p.GetValueAsUnsigned(), count_invalid_p.GetValueAsAddress()
+ )
+ self.assertEqual(5, count_p.Dereference().GetValueAsUnsigned())
+ self.assertEqual(5, count_invalid_p.Dereference().GetValueAsUnsigned())
+
+ global_p = frame.FindVariable("global_p")
+ global_invalid_p = frame.FindVariable("global_invalid_p")
+ self.assertEqual(
+ global_p.GetValueAsUnsigned(), global_invalid_p.GetValueAsAddress()
+ )
+ self.assertNotEqual(
+ global_invalid_p.GetValueAsUnsigned(), global_invalid_p.GetValueAsAddress()
+ )
+ self.assertEqual(10, global_p.Dereference().GetValueAsUnsigned())
+ self.assertEqual(10, global_invalid_p.Dereference().GetValueAsUnsigned())
+
+ main_p = frame.FindVariable("main_p")
+ main_invalid_p = frame.FindVariable("main_invalid_p")
+ self.assertEqual(
+ main_p.GetValueAsUnsigned(), main_invalid_p.GetValueAsAddress()
+ )
diff --git a/lldb/test/API/clear-sbvalue-nonaddressable-bits/main.c b/lldb/test/API/clear-sbvalue-nonaddressable-bits/main.c
new file mode 100644
index 00000000000000..1b0e42c50dd678
--- /dev/null
+++ b/lldb/test/API/clear-sbvalue-nonaddressable-bits/main.c
@@ -0,0 +1,27 @@
+#include <stdint.h>
+
+int global = 10;
+
+int main() {
+ int count = 5;
+ int *count_p = &count;
+
+ // Add some metadata in the top byte (this will crash unless the
+ // test is running with TBI enabled, but we won't dereference it)
+
+ intptr_t scratch = (intptr_t)count_p;
+ scratch |= (3ULL << 60);
+ int *count_invalid_p = (int *)scratch;
+
+ int (*main_p)() = main;
+ scratch = (intptr_t)main_p;
+ scratch |= (3ULL << 60);
+ int (*main_invalid_p)() = (int (*)())scratch;
+
+ int *global_p = &global;
+ scratch = (intptr_t)global_p;
+ scratch |= (3ULL << 60);
+ int *global_invalid_p = (int *)scratch;
+
+ return count; // break here
+}
>From da341f883471681d6f8345f8e67db0405b05775c Mon Sep 17 00:00:00 2001
From: Jason Molenda <jmolenda at apple.com>
Date: Thu, 25 Apr 2024 16:42:09 -0700
Subject: [PATCH 2/2] fix jonas' notes.
---
lldb/source/API/SBValue.cpp | 3 +--
.../TestClearSBValueNonAddressableBits.py | 1 -
2 files changed, 1 insertion(+), 3 deletions(-)
diff --git a/lldb/source/API/SBValue.cpp b/lldb/source/API/SBValue.cpp
index c8b664c86ec2d9..c53ec5a7464829 100644
--- a/lldb/source/API/SBValue.cpp
+++ b/lldb/source/API/SBValue.cpp
@@ -917,9 +917,8 @@ lldb::addr_t SBValue::GetValueAsAddress() {
bool success = true;
uint64_t ret_val = fail_value;
ret_val = value_sp->GetValueAsUnsigned(fail_value, &success);
- if (!success) {
+ if (!success)
return fail_value;
- }
ProcessSP process_sp = m_opaque_sp->GetProcessSP();
if (!process_sp)
return ret_val;
diff --git a/lldb/test/API/clear-sbvalue-nonaddressable-bits/TestClearSBValueNonAddressableBits.py b/lldb/test/API/clear-sbvalue-nonaddressable-bits/TestClearSBValueNonAddressableBits.py
index c91059358844ee..382b0e7a81d231 100644
--- a/lldb/test/API/clear-sbvalue-nonaddressable-bits/TestClearSBValueNonAddressableBits.py
+++ b/lldb/test/API/clear-sbvalue-nonaddressable-bits/TestClearSBValueNonAddressableBits.py
@@ -7,7 +7,6 @@
class TestClearSBValueNonAddressableBits(TestBase):
-
NO_DEBUG_INFO_TESTCASE = True
# On AArch64 systems, the top bits that are not used for
More information about the lldb-commits
mailing list