Commit Graph
514 Commits
Author SHA1 Message Date
Yao Qi 4ffcfdfac1 [lldb] Reject NULL key in PythonDictionary::GetItem (#205753)
A `breakpoint set -P <class>` with an invalid-UTF-8 class name crashes
lldb with `EXC_BAD_ACCESS`.  The class name is passed through
unmodified, so the byte sequence `\xd0p` (an incomplete two-byte UTF-8
sequence) reaches the Python layer:

```
 ./bin/lldb -b -o $'breakpoint set -P \xd0p -f main.cpp' ./bin/lldb
...
PLEASE submit a bug report to https://github.com/llvm/llvm-project/issues/
Stack dump:
 #4 PythonDictionary::GetItem(PythonObject const&) const
 #6 PythonDictionary::GetItemForKey(PythonObject const&) const
 #7 PythonObject::ResolveNameWithDictionary(StringRef, PythonDictionary const&)
 #9 ScriptedPythonInterface::CreatePluginObject<...>(...)
```

`ResolveNameWithDictionary` builds a `PythonString` from the class name
and looks it up in the module dictionary.  When the name is not valid
UTF-8, `PyUnicode_FromStringAndSize` returns `NULL`, so the
`PythonString` is left with `m_py_obj == NULL`. `GetItemForKey` forwards
that object to `GetItem`, which passed the `NULL` `PyObject *` straight
to `PyDict_GetItemWithError`.

Debugging the crashing lldb under lldb shows the `NULL` key arriving in
`GetItem`:

```
(lldb) break set -n lldb_private::python::PythonDictionary::GetItem
(lldb) run --no-use-colors -b -s /tmp/bp_cmds.txt
* stop reason = breakpoint 1.1
(lldb) up
(lldb) frame variable key.m_py_obj
(PyObject *) key.m_py_obj = nullptr
```

Continuing lands on the dereference of that `NULL` inside CPython:

```
(lldb) continue
* stop reason = EXC_BAD_ACCESS (code=1, address=0x8)
    frame #0: PyDict_GetItemWithError + 40
->  ldr    x8, [x1, #0x8]
```

`x1` holds the key argument, which is `NULL`, so reading the type field
at offset `0x8` faults at address `0x8`.

`GetItem` already guards against an invalid dictionary (`!IsValid()`);
extend that guard to reject an invalid key as well and return
`nullDeref()`.  `GetItemForKey` consumes the error and returns an empty
`PythonObject`, so existing callers such as `ResolveNameWithDictionary`
keep working and the breakpoint command now fails cleanly instead of
crashing.

This was found by `lldb-commandinterpreter-fuzzer`.

Adds `PythonDataObjectsTest.TestPythonDictionaryGetItemWithInvalidKey`,
which feeds an invalid-UTF-8 key to `GetItem`.  Without the fix the test
dereferences the `NULL` key and crashes (`SIGSEGV`).
2026-07-06 10:51:36 +01:00
Alex Langford f9b5264523 [lldb] Remove ConstString getters from FileSpec (#206802)
This finishes the removal of ConstString from FileSpec's interface. Note
that FileSpec is still _backed_ by ConstStrings, that will be changed in
a follow-up.

A non-goal for this change is to rewrite business logic, so I kept the
type of some variables as ConstString where a refactor would necessary
to change that. I converted printf-style formatting to formatv-style
formatting where required, and otherwise tried to leave callsites alone
to the extent that was possible.
2026-06-30 14:44:20 -07:00
Nerixyz 45829d78f3 [lldb] Treat synthetic variables as locals (#204431)
From the discussion in #204177: Synthetic variables were, if they
weren't variables already, created with their original type plus a flag
that they're synthetic (`ValueTypeSyntheticMask`). This could lead to
unexpected results. For example, when a synthetic frame would return a
value derived from a global variable in `GetVariables`, the created
variable would be treated as a synthetic global variable.

With this PR, synthetic frames can overwrite the value type of the
variables they return.
2026-06-29 18:36:44 +02:00
Jonas Devlieghere d76dd878dd [lldb] Fix LLDB_BUILD_FRAMEWORK with the dynamic script interpreters (#204265)
When using LLDB_ENABLE_DYNAMIC_SCRIPTINTERPRETERS (the default on Darwin
as of #204015), the PluginManager loads at runtime by scanning the
directory that holds liblldb. A framework build moves liblldb into
LLDB.framework, but the plugins were only emitted into lib/ and never
copied into the bundle, so they were never found.

Add lldb_add_scriptinterpreter_plugin_to_framework(), called from the
Python and Lua plugin CMakeLists, which copies the plugin next to the
framework binary and appends an rpath so it can resolve liblldb from
inside the bundle. The copy uses the plugin's unversioned name because
PluginManager derives the initializer symbol from it (a versioned copy
would load but never register). Non-framework builds are unaffected.
2026-06-17 08:54:43 -07:00
Charles Zablit 4bf77a4abb [lldb][windows] Fix Python library link for LLDB_ENABLE_PYTHON_LIMITED_API (#201407)
When `LLDB_ENABLE_PYTHON_LIMITED_API` is `ON`, `liblldb` should link
against `python3.dll` (stable ABI) rather than the `python310.dll`.

Previously, two issues prevented this on Windows:

1. The `ScriptInterpreter` plugin explicitly linked
`${Python3_LIBRARIES}` regardless of whether the limited API was
enabled.

2. Python's `pyconfig.h` emits a `#pragma` to select the import library
at link time, choosing `python3.lib` or `python310.lib` depending on
whether `Py_LIMITED_API` is defined. However,
`LLDB_ENABLE_PYTHON_LIMITED_API` was only surfaced through Config.h,
which is not included early enough in the compilation chain to affect
pyconfig.h in all translation units.

This patch fixes both issues.

This is needed for https://github.com/llvm/llvm-project/pull/200533.
2026-06-05 20:35:39 +01:00
Jonas Devlieghere 119e576302 [lldb] Build liblldb exports from script-interpreter imports (#201392)
With LLDB_ENABLE_DYNAMIC_SCRIPTINTERPRETERS, the script interpreter
plugins are built as standalone shared libraries that resolve their
lldb_private/llvm references through liblldb's re-exports. liblldb was
falling back to liblldb-private.exports, which allowlists the
lldb_private/llvm namespaces wholesale.

Generate the export list per build instead. For each plugin, run llvm-nm
on its compiled objects, keep undefined references in namespaces liblldb
owns, subtract the plugin's own definitions, and concatenate the
per-plugin lists with liblldb.exports.

The plugin's SHARED target LINK_LIBS liblldb, which makes the plugin's
compile order depend on liblldb. Wiring the exports file in via
add_llvm_symbol_exports' built-in target dependency would form a cycle
through that order-only edge. Add NO_TARGET_DEPENDENCY to
add_llvm_symbol_exports so we can apply the file via LINK_DEPENDS alone;
that still triggers a relink when the symbol set changes, without
participating in compile-order tracking.

Windows is unchanged: msvc_extract_private_symbols.py was already doing
per-symbol extraction at namespace granularity.

Assisted-by: Claude
2026-06-04 16:59:18 +00:00
Jonas Devlieghere 3eb13f8db3 [lldb] Stop hard-linking libpython into the dynamic Python plugin (#200530)
Drops ${Python3_LIBRARIES} from the SHARED build of
lldbPluginScriptInterpreterPython and lets undefined Python symbols
through at link time (`-undefined dynamic_lookup` on Darwin,
`--allow-shlib-undefined` on Linux; Windows keeps its existing
delay-load + import lib).

SystemInitializerFull::Initialize resolves the Python runtime loader
via ScriptInterpreterRuntimeLoader::Get(eScriptLanguagePython) and
calls Load() before initializing any plugin, so libpython is mapped
into the process before either entry point that references it: the
static script interpreter's Initialize() (which invokes Python via
the LLDB_PLUGIN_INITIALIZE loop) and the dynamic plugin's dlopen
(whose undefined references resolve against the in-process
libpython). This covers both LLDB_ENABLE_DYNAMIC_SCRIPTINTERPRETERS
=ON and =OFF, and keeps Windows working in static builds where the
delay-load thunks live in liblldb itself. The loader is
once_flag-cached, and errors propagate out via the existing Expected
return.

`import lldb` from a running Python works because libpython is
already mapped into the process. The Python runtime loader probes
for stable-ABI symbols (Py_IsInitialized, Py_InitializeFromConfig)
via dlsym(RTLD_DEFAULT) / GetProcAddress and, finding them, returns
success without dlopen'ing a second libpython on top.

The dynamic plugins are added as test-suite dependencies so
check-lldb-shell and check-lldb-api wait for them; they can't be
build-order deps of liblldb itself because the plugins link against
liblldb (CMake SHARED cycle).

The unit-test static variant lldbStaticScriptInterpreterPython keeps
hard-linking libpython so link-time symbol checking is preserved.
2026-06-02 16:47:54 -07:00
Med Ismail Bennani b75f5d7113 [lldb] Consolidate ScriptedThreadPlan state into ScriptedMetadata (#199064)
This is a follow-up to 1b4a578a9f.

Replace ScriptedThreadPlan's separate `m_class_name` and `m_args_data`
members with a single `m_scripted_metadata`, and update its constructor,
Thread::QueueThreadPlanForStepScripted and the SB/CLI callers to take a
`const ScriptedMetadata &` directly. Drop the now-redundant `args_sp`
parameter from ScriptedThreadPlanInterface::CreatePluginObject; the
Python override constructs a StructuredDataImpl from the metadata's args
dict for the dispatched call.

ScriptedThreadPlan keeps its own `m_scripted_metadata` member because
the interface's metadata is only set when `DidPush()` calls
`CreatePluginObject`, so the plan needs to hold the metadata between
construction and `DidPush()`.

Signed-off-by: Med Ismail Bennani <ismail@bennani.ma>
2026-05-21 16:32:00 -07:00
Med Ismail Bennani 691d540948 [lldb] Consolidate Target Hook/StopHook scripted state into ScriptedMetadata (#199088)
This is a follow-up to 1b4a578a9f.

Replace `Target::HookScripted`'s and `Target::StopHookScripted`'s
separate `m_class_name` and `m_extra_args` members with a single
`m_scripted_metadata`, and update `SetScriptCallback to take a `const
ScriptedMetadata &` directly. Drop the now-redundant `args_sp` parameter
from ScriptedHookInterface::CreatePluginObject and
ScriptedStopHookInterface::CreatePluginObject; the Python overrides
construct a StructuredDataImpl from the metadata's args dict for the
dispatched call.

Each hook subclass keeps its own `m_scripted_metadata` member because
the interface's metadata is only set when SetScriptCallback runs the
Python override of CreatePluginObject; the hook needs to hold the
metadata between construction and that callback. Read-side description
printing goes through the new GetScriptClassName() helper which
delegates to m_interface_sp->GetScriptedMetadata(). The two
s.Printf("%s\n", class_name.data()) sites are also converted to
s.Format("{0}\n", class_name).

Signed-off-by: Med Ismail Bennani <ismail@bennani.ma>
2026-05-21 16:16:45 -07:00
Ebuka Ezike e453259960 [lldb] Add missing includes. (#198996)
Failed to build in CI because,
ScriptedPythonInterface::CreatePlugingObject is a template function and
the arguments are of incomplete types gotten from `lldb-forward.h`
(typedef of lldb_private::XXXX = XXXXSP).

Introduced in commit 1b4a578a9f
2026-05-21 12:21:32 +01:00
Med Ismail Bennani 1b4a578a9f [lldb/Interpreter] Plumb ScriptedMetadata through scripted plugin CreatePluginObject (NFC) (#198425)
Replace the (class_name, args_sp) parameter pair on CreatePluginObject
across the scripted plugin interfaces (ScriptedThread, OperatingSystem,
ScriptedBreakpoint, ScriptedFrameProvider, ScriptedProcess, and the
underlying ScriptedPythonInterface template) with a single `const
ScriptedMetadata &`. Callers (OperatingSystemPython, ScriptedThread,
ScriptedProcess, BreakpointResolverScripted, ScriptedFrameProvider) pass
their existing ScriptedMetadata directly, removing the need to re-bundle
class_name and args at every call site.

ScriptedBreakpoint, ScriptedFrameProvider and ScriptedProcess no longer
carry a redundant `args_sp` parameter; their callers fold those args
into the metadata, and the Python overrides reconstruct a
StructuredDataImpl from the metadata's args dict for the dispatched
call.

ScriptedInterface gains an `m_scripted_metadata` member and a
`GetScriptedMetadata()` accessor; ScriptedPythonInterface populates it
when CreatePluginObject is invoked so subclasses can later report which
script class is in play.

Hook/StopHook/ThreadPlan public interfaces keep their existing `args_sp`
parameter for now; subsequent commits consolidate that.

Signed-off-by: Med Ismail Bennani <ismail@bennani.ma>
2026-05-20 13:07:31 -07:00
Nerixyz fecfdfdf64 [lldb][Python] Include limited API library directory (#197185)
On Windows, when compiling with the limited API in non-debug mode,
Python will instruct the linker to link `python3.lib`
[here](https://github.com/python/cpython/blob/f5fb491341e566bbaf17d9bf3e4ec3af4a56bb3f/PC/pyconfig.h#L344-L345).

Currently, we don't directly specify the library in CMake. We specify
`python3xx.lib`. When the linker encounters the `python3.lib`
requirement, it errors out, because it doesn't know where that is. With
this PR, we add the directory of `python3xx.lib`. This is the same one
as `python3.lib`. So the linker can find the library.

This is more of a temporary fix. As commented in the code, we should use
`Python3_SABI_LIBRARY_DIRS` once we require CMake 3.26. Furthermore, I'm
not fully sure why we link to `python3xx.lib` when the limited API is
requested (presumably because of #167001?).
2026-05-13 16:20:10 +02:00
Charles Zablit 2384d2872b [lldb][windows] remove mandatory ordering of the lldb-python.h header (#197298)
`PosixApi.h` typedef'd `pid_t` as `uint32_t`, while Python's
`pyconfig.h` on Windows typedef's it as `int`. C++ forbids redeclaring a
typedef with a different type, so the two headers cannot coexist. The
`NO_PID_T` macro in `lldb-python.h` suppressed LLDB's typedef, but only
if `lldb-python.h` got included before `PosixApi.h`.

`pid_t` on Windows was originally defined in d87fc157d2. At this time,
there was no Python support for LLDB on Windows and `uint32_t` matches
the `DWORD` type used by the Win32 API for process IDs.

This patch matches the Python type in `PosixApi.h`, removing the need
for the include ordering.

This is a follow up to https://github.com/llvm/llvm-project/pull/197048.
2026-05-13 11:18:28 +02:00
jimingham 457380cee1 Add a breakpoint override resolver feature to lldb (#195392)
This is a general mechanism that allows a custom breakpoint resolver to
"override" the resolver lldb would have used. It is implemented by
making a scripted breakpoint resolver class, implementing an extra
"overrides_resolver" method. When lldb has decided what resolver it is
going to use for the breakpoint, if there are any override resolvers
registered, it will pass the serialized form of the resolver to the
`overrides_resolver` method of the registered resolvers. If any of the
override resolvers return true from the overrides_resolver method, that
resolver will be used in place of the one lldb would have used.

The original motivation for this feature is to make the support of
"debugging a scripting language from the implementation side". We added
the notion of "facade breakpoints" so that a location given in the
context of the scripting language can be handled by the emulation code.
But when you are using lldb in some IDE, when "stopped" in the scripting
language, the IDE will show the scripting language source. It is natural
in that case for the user to expect the UI gesture to set a file and
line breakpoint should work the same way.

To implement that, the implementor would make their facade breakpoint
resolver also an override resolver that checks to see if the incoming
resolver was a file and line breakpoint for a source file of the
scripting language type. If it is, it returns true, and lldb will use
that resolver instead. Note, this will also work when breakpoints are
set on the command line, so you can transparently support "scripting
language" breakpoints from the command line as well.
2026-05-11 15:55:34 -07:00
jimingham abf90bf9ae Move lldb-python.h to be the first included as its comment demands. (#197048)
The comment was preserved even though the header was almost never
actually placed first. For the most part that didn't matter, but you can
through bad luck uncover the conflict between Python typedefs (in this
case of pid_t) and ones from include/lldb/Host/windows/PosixAPI.h.

So this patch just moves this header to the front in all its
appearances.
2026-05-11 15:41:01 -07:00
Jonas Devlieghere c1c557b1a5 [lldb] Support dynamically loading ScriptInterpreter plugins (#189718)
Add support for building the script interpreter plugins as shared
libraries, controlled by the `LLDB_ENABLE_DYNAMIC_SCRIPTINTERPRETERS`
CMake variable. This allows the plugins, rather than `liblldb`, to link
against their respective dependencies such as Python and Lua, which has
several benefits:

1. It makes it possible to gracefully handle the Python or Lua
dependencies not being present, instead of crashing.
2. It enables programmatically deciding which Python or Lua library to
load.
3. Combined with (2), this opens up a path towards not statically
linking with Python at all, which is required in order to load the LLDB
module in a different Python interpreter (at least this is a hard
requirement on Darwin due to two-level namespaces and install names).

This PR completes #183791
2026-05-06 16:44:06 -07:00
Dave Lee 9f968a8e57 [lldb] Fix misconstructed log/formatv calls (#196129)
Fixes `LLDB_LOG` and `formatv` source errors found using
https://github.com/llvm/llvm-project/pull/195974
2026-05-06 21:33:03 +00:00
Jonas Devlieghere 28a4ad535f [lldb] Fix help/pydoc output when the statusline is enabled (#169101)
Using Python's built-in help shows an empty screen when the statusline
is enabled. The issue is the pydoc pager (e.g. less) which doesn't play
nice with the statusline. Use the "plain" pager instead.

I considered making this conditional on the statusline, but to do that
right you would need to register a callback that toggles it every time
the setting changes and that doesn't seem worth the complexity.

Fixes #166610
2026-04-30 13:59:15 -07:00
Bar SoloveychikandBar Soloveychik b1c027b3aa [LLDB] Add module hook implementation (#185465)
Introduce a unified target hook command system for LLDB that handles
multiple target lifecycle events (module load, module unload, process
stop) through a single Hook class.

The existing target stop-hook commands remain unchanged for now, meaning
stop-hooks can now be created through either target stop-hook add or
target hook add -S.
A future follow-up can alias target stop-hook to the unified system to
consolidate the two paths.

 New commands:
- target hook add [-o cmd] [-P class] [-u] [-S] - create a hook (fires
on module load by default, optionally on unload/stop)
- target hook add-filter [filter-opts] <hook-id> - attach stop-event
filters (shlib, function, file/line, thread) to an existing hook
- target hook list / delete / enable / disable - manage hooks
- target hook {enable,disable} {module-loaded|module-unloaded|stop-hook}
<id> - per-event toggling

top-event filter options live on a separate add-filter command rather
than on target hook add, keeping the add command clean and making the
system safe for filters on other event types.

Ran the tests + Made sure stop tests are passing as well.

---------

Co-authored-by: Bar Soloveychik <barsolo@fb.com>
2026-04-28 14:07:44 -07:00
David Spickett 1bf0787a16 [lldb] Remove trailing newlines from AppendErrorWithFormat calls (part 3) (#193527)
Follow up to #193168.

This call adds a newline if there isn't one. Changing these will
eventually let us always add a newline, which is in line with
the other methods on CommandReturnObject.

This is a small part of calls found with:
* VSCode search for
`(\.AppendErrorWithFormat\(([\s\r\n]+)?"(?:(?:\\.|[^"\\])*))\\n"` and
replace with `$1"`.
* Asserting that the last character of the format string is not a
newline.
* Manual inspection.
2026-04-23 09:37:59 +01:00
Charles Zablit a47551f220 [lldb][windows] fix script interpreter file parsing (#193006) 2026-04-21 12:18:41 +02:00
Jonas Devlieghere f866ef202c [lldb] Bring more diagnostics in compliance with our coding standards (#190410)
The LLVM Coding Standards [1] specify that:

> [T]o match error message styles commonly produced by other tools,
> start the first sentence with a lowercase letter, and finish the last
> sentence without a period, if it would end in one otherwise.

Historically, that hasn't been something we've enforced in LLDB, but in
the past year or so I've started to pay more attention to this in code
reviews. This PR brings more error messages in compliance, further
increasing consistency.

I also adopted `createStringErrorV` where it improved the code as a
drive-by for lines I was already touching.

[1] https://llvm.org/docs/CodingStandards.html#error-and-warning-messages

Assisted-by: Claude Code
2026-04-05 10:41:47 -07:00
Jason Molenda fb36a54ef6 [lldb] Rename formatv verbose log call, misc log cleanups [NFC] (#186951)
lldb had three preprocessor defines for logging,

LLDB_LOG  - formatv style argument
LLDB_LOGF - printf style argument
LLDB_LOGV - formatv style argument, only when verbose enabled

If you weren't looking at Log.h and the definition of these three, and
wanted to log something with formatv, it was easy to use LLDB_LOGV by
accident. We just had a situation where an important log statement
wasn't logging and it turned out to be this. This is fragile if you
aren't looking at the header directly, so I'd like to make this more
explicit. My proposal:

LLDB_LOG  - formatv style argument
LLDB_LOG_VERBOSE - formatv style argument, only when verbose enabled 
LLDB_LOGF - printf style argument
LLDB_LOGF_VERBOSE - printf style argument, only when verbose enabled

The new fouth one is to remove several places where we do `if (log &&
log->GetVerbose()) LLDB_LOGF (...)` in the sources today, and make both
styles consistent.

This PR implements that change, mechanically changing all LLDB_LOGV's to
LLDB_LOG_VERBOSE.

It also updates many of the `if (log && log->GetVerbose()) LLDB_LOGF`'s.
Some uses of this conditional expression do extra calculations in
addition to logging, and so those were left as-is so we're not doing
throwaway work when running without verbose logging.

There were many instances throughout lldb where callers are still doing
`if (log) LLDB_LOG*(...)`, a remnant of when all calls were to the `Log`
object's `Printf()` method, and you had to check if your local Log*
pointer was non-nullptr before calling the method. I removed those,
again keeping ones where work for logging is done in the block of code.

The code changes are all mechanical and uninteresting, but the question
of whether this naming change is widely agreed on is maybe worth
discussing.
2026-03-18 16:31:33 -07:00
Jonas Devlieghere c5e5d5b282 [lldb] When LLDB_ENABLE_MTE is ON always run the driver with MTE (#186322)
When LLDB_ENABLE_MTE is set to ON, we should always run the driver with
MTE by signing with the checked-allocations entitlement.
2026-03-16 18:11:58 +00:00
Dave Lee e10833d845 [lldb] Replace make_error<StringError> with createStringError* (NFC) (#185748)
This makes the constructions of string errors more concise and more
consistent, mainly by removing the `inconvertibleErrorCode()`.
Additional changes replace `createStringError(formatv(...), ...)` with
`createStringErrorV(...)`.

Assisted-by: Claude
2026-03-11 10:46:55 -07:00
Jonas Devlieghere c182ca3e3a [lldb] Assert & fix missing calls to UnregisterPlugin (#185162)
Fix missing calls to UnregisterPlugin and add an assert in the
PluginManager that ensures all plugins have been unregistered by the
time the plugin manager is destroyed.
2026-03-09 13:04:08 -07:00
Jonas Devlieghere c4ea6cc3f7 [lldb] Remove call_once wrappers around PluginManager::RegisterPlugin (#184273)
Remove call_once wrappers around PluginManager::RegisterPlugin. Plugins
can be registered and unregistered in Initialize and Terminate
respectively. In its current state, after having called Terminate, a
plugin can never be re-initialized.
2026-03-03 13:17:21 -08:00
Jonas Devlieghere 329c52c100 [lldb] Change the way the shlib directory helper is set (#183637)
This PR changes the way we set the shlib directory helper. Instead of
setting it while initializing the Host plugin, we register it when
initializing the Python plugin. The motivation is that the current
approach is incompatible with the dynamically linked script
interpreters, as they will not have been loaded at the time the Host
plugin is initialized.

The downside of the new approach is that we set the helper after having
initialized the Host plugin, which theoretically introduces a small
window where someone could query the helper before it has been set.
Fortunately the window is pretty small and limited to when we're
initializing plugins, but it's less "pure" than what we had previously.
That said, I think it balances out with removing the plugin include.
2026-02-27 15:27:02 -08:00
Jonas Devlieghere 8d625621eb [lldb] Fix spurious indentation in CMakeLists.txt (NFC) (#183368)
Fix spurious indentation in ScriptInterpreter/*/CMakeLists.txt.
2026-02-25 19:44:22 +00:00
Jonas Devlieghere 138805ed84 [lldb] Limit Python include dir to ScriptInterpreterPython (NFC) (#183236)
Limit Python include dir to ScriptInterpreterPython and any library that
depends on it (i.e. liblldb), making it consistent with what we do for
Lua.
2026-02-25 05:00:51 +00:00
Jonas Devlieghere 863813cace [lldb] Merge interfaces into lldbPluginScriptInterpreterPython (NFC) (#182962)
Make the interfaces part of lldbPluginScriptInterpreterPython instead of
putting them into their own static library. This avoids the need for an
extra static archive and more importantly a bunch of code duplication
between the two CMakeLists.txt.
2026-02-23 21:33:38 -08:00
Jonas Devlieghere 11af80c3ec [lldb] Go through the plugin interface to obtain the scripting path (#182400)
Avoid directly including `ScriptInterpreterPython.h` in `SBHostOS`, and
instead go through the plugin interface to obtain the scripting path.
This also deprecates the ``SBHostOS::GetLLDBPythonPath`` method in favor
of the more generic GetScriptPath variant.
2026-02-19 16:41:00 -08:00
Jonas Devlieghere fece61b281 [lldb] Remove check for LLDB_ENABLE_PYTHON in SWIGPythonBridge.h (#182326)
The header guard is redundant because
`source/Plugins/ScriptInterpreter/CMakeLists.txt` already gates the
entire `Python/` subdirectory behind `LLDB_ENABLE_PYTHON`.
2026-02-19 11:05:45 -08:00
Med Ismail Bennani 15cf81b13f [lldb] Fix wrong log formatting for script callbacks (NFC)
Signed-off-by: Med Ismail Bennani <ismail@bennani.ma>
2026-02-17 20:43:51 -08:00
Jonas Devlieghere 091296f3e3 [lldb] Revert scripted symbol locator (#181945)
This revert #181334 and its follow-up PRs (including #181488, #181492,
#181493, #181494 and #181498) as well as Ismail's documentation changes
(#181594, #181717). The original commit causes a test failure in CI
(https://github.com/llvm/llvm-project/issues/181938) but the more I look
at the patch, the more I'm convinced it was not ready to land. It will
be easier to iterate on the feedback by re-landing this than by using
post-commit review.
2026-02-17 16:52:21 -08:00
rchamalaandRahul Reddy Chamala 846e022a5d [lldb] NFC: Use standard comment for lldb-python.h include (#181498)
## Summary
Use the standard `// LLDB Python header must be included first.` comment
to match every other Python interface `.cpp` file in this directory, as
suggested by @JDevlieghere.

## Test plan
NFC - comment only change.

Co-authored-by: Rahul Reddy Chamala <rachamal@meta.com>
2026-02-14 10:56:10 -08:00
rchamalaandRahul Reddy Chamala de4f473f88 [lldb] Fix Windows linker error for MakeSBModuleSpec in lldb-server (#181494)
## Summary
Move the definition of `ScriptInterpreter::MakeSBModuleSpec` from
`ScriptInterpreter.cpp` to `ScriptedPythonInterface.cpp`.

`MakeSBModuleSpec` constructs an `SBModuleSpec`, whose symbols live in
the API library (`liblldb`). `ScriptInterpreter.cpp` is part of
`lldbInterpreter`, which is also linked into `lldb-server` — and
`lldb-server` does not link the API library. On Windows, this causes
`LNK2019: unresolved external symbol` for `SBModuleSpec`'s constructor
and destructor.

`ScriptedPythonInterface.cpp` is part of the Python plugin library,
which only links into `liblldb` where the API symbols are available. The
method retains friend access to `SBModuleSpec` since it is still a
member of `ScriptInterpreter` regardless of which `.cpp` file defines
it.

Fixes Windows linker failure from #181334.

## Test plan
- [ ] Existing ScriptedSymbolLocator tests pass

Co-authored-by: Rahul Reddy Chamala <rachamal@meta.com>
2026-02-14 10:12:44 -08:00
rchamalaandRahul Reddy Chamala 0773c83e66 [lldb] Fix pid_t redefinition on Windows in ScriptInterpreterPythonInterfaces (#181493)
## Summary
Include `lldb-python.h` as the first include inside the
`LLDB_ENABLE_PYTHON` block in `ScriptInterpreterPythonInterfaces.cpp`,
matching the pattern used by every other Python interface `.cpp` file in
this directory.

On Windows, `lldb-python.h` defines `NO_PID_T` before including
`Python.h`. This prevents `PosixApi.h` (transitively included via
`lldb-private.h`) from redefining `pid_t` with a conflicting type
(`uint32_t` vs `int`).

The issue was introduced by #181334 (ScriptedSymbolLocator plugin),
which added a new header whose include chain transitively reaches
`PosixApi.h`.

Fixes Windows build failures on lldb-aarch64-windows, lldb-x86_64-win,
and lldb-remote-linux-win.

## Test plan
- [ ] lldb-aarch64-windows build passes
- [ ] lldb-x86_64-win build passes
- [ ] lldb-remote-linux-win build passes

Co-authored-by: Rahul Reddy Chamala <rachamal@meta.com>
2026-02-14 09:44:46 -08:00
rchamalaandRahul Reddy Chamala 02aa032f6f [lldb] Fix pid_t redefinition on Windows in ScriptInterpreterPythonInterfaces (#181492)
## Summary
- Move `#include "lldb/Core/PluginManager.h"` after `#include
"ScriptInterpreterPythonInterfaces.h"` so Python's `pyconfig.h` defines
`pid_t` before `PosixApi.h` gets included. This fixes the `C2371:
'pid_t': redefinition; different basic types` error on all Windows
builders.

Fixes CI failures from #181334 / #181488.

Co-authored-by: Rahul Reddy Chamala <rachamal@meta.com>
2026-02-14 09:24:28 -08:00
rchamalaandRahul Reddy Chamala 1ee03d1e09 [lldb] Add ScriptedSymbolLocator plugin for source file resolution (#181334)
## Summary                                                        
                                                                    
Based on discussion from
[RFC](https://discourse.llvm.org/t/rfc-python-callback-for-source-file-resolution/83545),
this PR adds a new `SymbolLocatorScripted` plugin that allows Python
scripts to implement custom symbol and source file resolution logic.
This enables downstream users to build custom symbol servers, source
file remapping, and build artifact resolution entirely in Python.
                                                                    
  ### Changes

- Adds `LocateSourceFile()` to the SymbolLocator plugin interface,
called during source path resolution with a fully loaded `ModuleSP`, so
the plugin has access to the module's UUID, file paths, and symbols.
- Adds `SymbolLocatorScripted` plugin that delegates all four
SymbolLocator methods (`LocateExecutableObjectFile`,
`LocateExecutableSymbolFile`, `DownloadObjectAndSymbolFile`,
`LocateSourceFile`) to a user-provided Python class.
- Adds `ScriptedSymbolLocatorPythonInterface` to bridge C++ calls to
Python, with proper GIL management and error handling.
- Results for `LocateSourceFile` are cached per (module UUID, source
file) pair.
- The Python class is configured via: `settings set
plugin.symbol-locator.scripted.script-class module.ClassName`

  ### Python class interface

  ```python
  class MyLocator:
      def __init__(self, exe_ctx, args): ...
      def locate_source_file(self, module, original_source_file):
  ...
      def locate_executable_object_file(self, module_spec): ...
      def locate_executable_symbol_file(self, module_spec,
  default_search_paths): ...
      def download_object_and_symbol_file(self, module_spec,
  force_lookup, copy_executable): ...
```

  ### Test plan
```
  Added TestScriptedSymbolLocator.py with 3 test cases:
  - test_locate_source_file — verifies the locator resolves source
  files, receives a valid SBModule with UUID, and remaps paths correctly
  - test_locate_source_file_none_fallthrough — verifies returning
None falls through to default LLDB resolution, and that having no script
  class set works normally
  - test_invalid_script_class — verifies graceful handling of
  invalid class names without crashing
```

Co-authored-by: Rahul Reddy Chamala <rachamal@fb.com>
2026-02-14 07:39:00 -08:00
Jonas Devlieghere 655b6fbd5c [lldb] Fix LLDB header guards (NFC) (#181312)
Fix LLDB header guards using clang-tidy's llvm-header-guard check. A
bunch of headers have been moved or renamed and we often forget to
update the header guard.
2026-02-12 22:21:27 -08:00
Aman LaChapelle 10f2611c21 [lldb] Add support for ScriptedFrame to provide values/variables. (#178575)
This patch adds plumbing to support the implementations of StackFrame::Get{*}Variable{*} on ScriptedFrame. The major pieces required are:
- A modification to ScriptedFrameInterface, so that we can actually call the python methods.
- A corresponding update to the python implementation to call the python methods.
- An implementation in ScriptedFrame that can get the variable list on construction inside ScriptedFrame::Create, and pass that list into the ScriptedFrame so it can get those values on request.

There is a major caveat, which is that if the values from the python side don't have variables attached, right now, they won't be passed into the scripted frame to be stored in the variable list. Future discussions around adding support for 'extended variables' when printing frame variables may create a reason to change the VariableListSP into a ValueObjectListSP, and generate the VariableListSP on the fly, but that should be addressed at a later time.

This patch also adds tests to the frame provider test suite to prove these changes all plumb together correctly.

Related radar: rdar://165708771
2026-01-29 21:24:17 -08:00
Aman LaChapelle 8122d0e4bc [lldb] Add conversions for SBValueList and SBValue to the python bridge. (#178574)
This patch adds support for:
- PyObject -> SBValueList (which was surprisingly not there before!)
- PyObject -> SBValue
- SBValue -> ValueObjectSP using the ScriptInterpreter

These three are the main remaining plumbing changes necessary before we can get to the meat of actually using ScriptedFrame to provide values to the printer/etc. Future patches build off this change in order to allow ScriptedFrames to provide variables and get values for variable expressions.
2026-01-29 11:38:50 -08:00
Victor Chernyakin c438773432 [LLVM][ADT] Migrate users of make_scope_exit to CTAD (#174030)
This is a followup to #173131, which introduced the CTAD functionality.
2026-01-02 20:42:56 -08:00
Med Ismail Bennani d6a73d08d5 [lldb] Add priority support to synthetic frame providers (#172848)
This patch adds `get_priority()` support to synthetic frame providers to
enable priority-based selection when multiple providers match a thread.
This is the first step toward supporting frame provider chaining for
visualizing coroutines, Swift async tasks, and et al.

Priority ordering follows Unix nice convention where lower numbers
indicate higher priority (0 = highest). Providers without explicit
priority return `std::nullopt`, which maps to UINT32_MAX (lowest
priority), ensuring backward compatibility with existing providers.

The implementation adds `GetPriority()` as a virtual method to
`SyntheticFrameProvider` base class, implements it through the scripting
interface hierarchy (`ScriptedFrameProviderInterface` and
`ScriptedFrameProviderPythonInterface`), and updates
`Thread::GetStackFrameList()` to sort applicable providers by priority
before attempting to load them.

Python frame providers can now specify priority:

```python
@staticmethod
def get_priority():
   return 10  # Or return None for default priority.
```

Signed-off-by: Med Ismail Bennani <ismail@bennani.ma>
2025-12-18 23:20:38 +01:00
Med Ismail Bennani 0e0c0b7651 [lldb/ScriptInterpreter] Fix typo in GetScriptedModulePath (NFC)
This fixes a typo in `ScriptedPythonInterface::GetScriptedModulePath`.

Signed-off-by: Med Ismail Bennani <ismail@bennani.ma>
2025-12-04 14:01:45 -08:00
Med Ismail Bennani c50802cbee Reland "[lldb] Introduce ScriptedFrameProvider for real threads (#161870)" (#170236)
This patch re-lands #161870 with fixes to the previous test failures.

rdar://161834688

Signed-off-by: Med Ismail Bennani <ismail@bennani.ma>
2025-12-02 18:59:40 +00:00
Med Ismail Bennani b7c358c44a [lldb/ScriptInterpreter] Add a way to retrieve script module file path (#170202)
This adds a new virtual method `GetScriptedModulePath()` to
`ScriptedInterface` that allows retrieving the file path of the Python
module containing the scripted object implementation.

The Python implementation acquires the GIL and walks through the
object's `__class__.__module__` to find the module's `__file__`
attribute. This will be used by ScriptedFrame to populate the module and
compile unit for frames pointing to Python source files.

Signed-off-by: Med Ismail Bennani <ismail@bennani.ma>
2025-12-01 14:45:54 -08:00
Med Ismail Bennani 3ca85e74a1 [lldb] Handle staticmethod/classmethod descriptors in ScriptedPythonInterface (#170188)
Extract `__func__` attribute from staticmethod/classmethod descriptors
before treating them as callables. Python's `@staticmethod` and
`@classmethod` decorators wrap methods in descriptor objects that are
not directly usable as PythonCallable, when calling PyCallable_Check.

The actual callable function is stored in the `__func__` attribute of
these descriptors, so we need to unwrap them to properly validate and
invoke the decorated methods in scripted interfaces.

Signed-off-by: Med Ismail Bennani <ismail@bennani.ma>
2025-12-01 13:12:42 -08:00
Med Ismail Bennani fd8bf3c69a [lldb/ScriptInterpreter] Fix typo in AbstractMethodCheckerPayload (NFC) (#170187)
This fixes a typo in ScriptedPythonInterface and changes
`AbstrackMethodCheckerPayload` to `AbstractMethodCheckerPayload`.

Signed-off-by: Med Ismail Bennani <ismail@bennani.ma>
2025-12-01 11:24:50 -08:00