Split compiler integration to avoid duplicating Cthulhu when loading the compiler extension #677

serenity4 · 2025-11-04T14:24:43Z

This PR splits the compiler integration functionality, such that we only need to re-include the corresponding few compiler-related files when we load the Compiler extension, instead of re-loading most of Cthulhu. These files live under src/compiler/*.jl and essentially hold the interpreter and default provider bits (see src/CthulhuCompiler.jl which includes these).

A major benefit of this approach is that we now have a single API regardless of whether to use the compiler extension: most user-facing data structures live in Cthulhu, and only the parts related to the interfacing with the compiler are either in Cthulhu or CthulhuCompilerExt. No more Cthulhu.AbstractProvider !== CthulhuCompilerExt.AbstractProvider. However, Cthulhu.DefaultProvider !== CthulhuCompilerExt.DefaultProvider may still be true. When we load the Compiler extension, we fall in one of two situations:

The compiler stdlib is just a reexport of Base.Compiler, in which case we don't need to do anything (Base.Compiler.AbstractInterpreter === Compiler.AbstractInterpreter).
The compiler stdlib defines data structures that are different than those from Base.Compiler, so we re-include src/CthulhuCompiler.jl which defines new structs and functions, and adds methods to Cthulhu functions.

Another benefit that comes from this is that we won't pay the cost of recompilation in the most common case, i.e. Compiler may be loaded but simply aliases Base.Compiler, as the Cthulhu extension is virtually a no-op in this situation.

…o low-level-interface

… into low-level-interface

This way, commands merely register shortcuts to execute callbacks, so they get simplified, and at the same time we no longer have to worry about keeping command "values" and configuration values in sync.

…nnotations The renaming was done to improve consistency with similar settings, `remarks` and `exception_type`.

`IRCode` is now used primarily for callsite detection and display. `CodeInfo` may also be used for that purpose, if no `IRCode` is available. The main requirement is that they are consistent with the provided call infos. `CodeInfo` is mainly used to extract slotnames, get more accurate sources via TypedSyntax, and for module dumping for LLVM/native views.

integrations

…vel-interface

To match the plural used for `remarks`, `effects`, etc

To improve consistency with `remarks`, `effects`, `exception_type`

Now that we have backspace to ascend, we can have 'q' quit unconditionally and remove this option. Furthermore, we now exit without having to handle an interrupt.

…vel-interface

… into split-compiler-integration

…tegration

codecov-commenter · 2025-11-04T14:27:46Z

Codecov Report

❌ Patch coverage is 0% with 428 lines in your changes missing coverage. Please review.
✅ Project coverage is 0.00%. Comparing base (2c33b9a) to head (7b5ec0d).
⚠️ Report is 86 commits behind head on master.

Files with missing lines	Patch %	Lines
src/compiler/callsite.jl	0.00%	288 Missing ⚠️
src/compiler/interface.jl	0.00%	58 Missing ⚠️
src/compiler/lookup.jl	0.00%	24 Missing ⚠️
src/callsite.jl	0.00%	12 Missing ⚠️
src/Cthulhu.jl	0.00%	11 Missing ⚠️
src/compiler/provider.jl	0.00%	8 Missing ⚠️
src/interface.jl	0.00%	7 Missing ⚠️
src/bookmark.jl	0.00%	5 Missing ⚠️
ext/CthulhuCompilerExt.jl	0.00%	4 Missing ⚠️
src/descend.jl	0.00%	4 Missing ⚠️
... and 5 more

Additional details and impacted files

@@           Coverage Diff           @@
##           master    #677    +/-   ##
=======================================
  Coverage    0.00%   0.00%            
=======================================
  Files           9      22    +13     
  Lines        1556    1807   +251     
=======================================
- Misses       1556    1807   +251

☔ View full report in Codecov by Sentry.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:

❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.

aviatesk · 2025-11-13T17:07:30Z

Sorry for the delay in reviewing this. After reading the PR description, I think it's a great change overall.

There are a few things I can't understand just by reading the code, so I'd like to clarify them:

If I load a custom Compiler.jl and want to use Cthulhu with it, how should I do that? With the previous CthulhuCompilerExt implementation, I believe that when a custom Compiler.jl was loaded, the descend implementation would automatically switch, and descend would then work with that new compiler. From what I can tell by following the current implementation, this doesn't seem to happen, but am I missing something? I don't necessarily think it should happen automatically, but I'd like to confirm the steps needed to use descend with a new compiler.
If an external AbstractInterpreter package wants to use Cthulhu's AbstractProvider interface, my understanding is that it should primarily use Cthulhu.get_module_for_compiler_integration(; use_compiler_stdlib = true) to get the Cthulhu module to overload. Is that correct? And my understanding is that this Cthulhu module will be correctly switched depending on the Compiler.jl implementation.

aviatesk · 2025-11-13T17:13:46Z

If I load a custom Compiler.jl and want to use Cthulhu with it, how should I do that?

Looks like I can just do

julia> using Cthulhu

julia> using Compiler # load custom Compiler impl

julia> descend(sin, (Int,); interp=Compiler.NativeInterpreter())

and it's using the new Compiler implementation. That's impressive.

aviatesk · 2025-11-13T17:20:36Z

I see, so AbstractProvider(::[Base.Compiler|Compiler].NativeInterpreter) in src/compiler/interface.jl provides a DefaultProvider based on the interpreter that's passed to it. I think that's a good design.

And I guess the external abstract interpreter package XXX.jl is supposed to overload Cthulhu.AbstractProvider, and then also can opt in with its XXXCompilerExt to overload CthulhuExt.AbstractProvider (where CthulhuExt is retrieved by Cthulhu.get_module_for_compiler_integration(; use_compiler_stdlib=true)).intended design?

serenity4 · 2025-11-13T17:29:50Z

Thanks for the review!

And I guess the external abstract interpreter package XXX.jl is supposed to overload Cthulhu.AbstractProvider, and then also can opt in with its XXXCompilerExt to overload CthulhuExt.AbstractProvider (where CthulhuExt is retrieved by Cthulhu.get_module_for_compiler_integration(; use_compiler_stdlib=true))

More accurately, there is now always a single AbstractProvider, so CthulhuExt.AbstractProvider === Cthulhu.AbstractProvider. Usually, XXX.jl will simply choose to use Base.Compiler or Compiler and provide a single interpreter, and they will integrate with most of Cthulhu's interface. Only for the Compiler-related parts will they have to use Cthulhu.get_module_for_compiler_integration(; use_compiler_stdlib), e.g. to pull in the LookupResult symbol to construct an instance of that type to return in the lookup interface function. If they choose to integrate with both (e.g. by registering a new abstract interpreter type in XXXCompilerExt to provide a similar functionality as their abstract interpreter using Base.Compiler), they will simply satisfy the interface for their other XXXInterp <: Compiler.AbstractInterpreter type, and descend will dispatch on the relevant code just like you observed for NativeInterpreter.

I'll add a few more docs to provide guidelines and explanations about how to do all that integration before merging, hopefully this PR simplifies the whole process.

aviatesk

I'll add a few more docs to provide guidelines and explanations about how to do all that integration before merging, hopefully this PR simplifies the whole process.

That's great.

I haven't completed the JET integration with AbstractProvider on my side yet, but I'll try it again on this branch. Last time I tried, I remember running into an error related to this Compiler extension complexity, but looking at the changes in this PR, it seems that's been fixed entirely. (the challenge of integrating with JET is actually the other thing, specifically, I need to properly manage CodeInfo in JET.AbstractAnalyzer for passing them to AbstractProvider. But after this PR, once that's done, Cthulhu should be usable with JET.)

aviatesk · 2025-11-13T17:38:16Z

Feel free to merge this whenever you are satisfied.

serenity4 · 2025-11-18T23:29:01Z

Feel free to merge this whenever you are satisfied.

That should be good now, I'll proceed with the merge and tagging of the breaking release 3.0.0 with adequate release notes.

serenity4 and others added 30 commits July 22, 2025 14:59

Initial implementation

e07c6a5

WIP: Overhaul internal architecture & user-facing API

ffad20f

Bump major version

c6f97a9

Merge branch 'master' of https://github.com/JuliaDebug/Cthulhu.jl int…

0470ed3

…o low-level-interface

Fix highlighter command naming

4bc563e

Merge branch 'low-level-interface' of github.com:serenity4/Cthulhu.jl…

ca0f87a

… into low-level-interface

Implement initial external AbstractInterpreter support

0f95942

Separate commands and their values

ff7f047

This way, commands merely register shortcuts to execute callbacks, so they get simplified, and at the same time we no longer have to worry about keeping command "values" and configuration values in sync.

Properly implement way to conditionally disable commands

58a85de

Move quit/bookmark commands to beginning of action list

30604b1

Fix a few tests

e52eefa

Adjust conditional Command printing

44effa5

with_effects -> effects, re-enable remark/effect/exception type a…

566f1fe

…nnotations The renaming was done to improve consistency with similar settings, `remarks` and `exception_type`.

Re-enable VSCode diagnostics & inlay types

79ce64d

Add backspace shortcut to go back (ascend)

644bd69

Refactor bookmark functionality

f1195f8

Remove disabled AbstractCursor interface

a5c7412

Minor interface refactors

1eaf064

Move terminal utility functions to a separate file

fc25117

Start testing various AbstractProvider implementations

0bbb892

Start adding docs

e0ffb6c

Re-enable Compiler extension, test DefaultProvider with both

9ffeb95

integrations

Prevent terminal tests from hanging

311c6e5

Fix test_terminal.jl

a45e47a

FakeTerminal -> VirtualTerminal

ef4b8b2

Revert minor printing changes

54f56b0

Fix AbstractInterpreter tests

1928271

Merge branch 'master' of github.com:JuliaDebug/Cthulhu.jl into low-le…

2e746cf

…vel-interface

Fix test_codeview

6b0c795

serenity4 added 16 commits September 5, 2025 15:58

More fixes, add a few more tests

b3d7325

Reimplement descend_code_typed/warntype

a99d1a9

Attempt to fix tests for 1.13

7e0f4fe

Remove dead code

358f4cc

Add ExternalProvider example

3be6ceb

Improve interface documentation

c905499

exception_type -> exception_types

9b0cd54

To match the plural used for `remarks`, `effects`, etc

inline_cost -> inlining_costs

282ea51

To improve consistency with `remarks`, `effects`, `exception_type`

Update example descend usage in README

8261cca

Test fixes, avoid corrupting the global method table

b521524

Remove interruptexc, add a few more docs

c7508de

Now that we have backspace to ascend, we can have 'q' quit unconditionally and remove this option. Furthermore, we now exit without having to handle an interrupt.

Only reevaluate compiler-related functionality in CthulhuCompilerExt

fa6b865

Merge branch 'master' of github.com:JuliaDebug/Cthulhu.jl into low-le…

f3b18a4

…vel-interface

Merge branch 'low-level-interface' of github.com:serenity4/Cthulhu.jl…

6014e04

… into split-compiler-integration

Merge remote-tracking branch 'upstream/master' into split-compiler-in…

33ade0f

…tegration

Fix tests

69c8315

serenity4 requested a review from aviatesk November 4, 2025 14:24

serenity4 self-assigned this Nov 4, 2025

aviatesk approved these changes Nov 13, 2025

View reviewed changes

serenity4 added 3 commits November 18, 2025 16:09

Add more comments, make ir_to_src common

48ee35a

Mention docstring of AbstractProvider in changelog

b37420b

Allow returning nothing after lookup to log an error

7b5ec0d

serenity4 merged commit 8274a67 into JuliaDebug:master Nov 18, 2025
7 checks passed

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Split compiler integration to avoid duplicating Cthulhu when loading the compiler extension #677

Split compiler integration to avoid duplicating Cthulhu when loading the compiler extension #677

Uh oh!

serenity4 commented Nov 4, 2025

Uh oh!

codecov-commenter commented Nov 4, 2025 •

edited

Loading

Uh oh!

aviatesk commented Nov 13, 2025

Uh oh!

aviatesk commented Nov 13, 2025

Uh oh!

aviatesk commented Nov 13, 2025

Uh oh!

serenity4 commented Nov 13, 2025 •

edited

Loading

Uh oh!

aviatesk left a comment •

edited

Loading

Uh oh!

aviatesk commented Nov 13, 2025

Uh oh!

serenity4 commented Nov 18, 2025

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

Split compiler integration to avoid duplicating Cthulhu when loading the compiler extension #677

Split compiler integration to avoid duplicating Cthulhu when loading the compiler extension #677

Uh oh!

Conversation

serenity4 commented Nov 4, 2025

Uh oh!

codecov-commenter commented Nov 4, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Codecov Report

Uh oh!

aviatesk commented Nov 13, 2025

Uh oh!

aviatesk commented Nov 13, 2025

Uh oh!

aviatesk commented Nov 13, 2025

Uh oh!

serenity4 commented Nov 13, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

aviatesk left a comment • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

aviatesk commented Nov 13, 2025

Uh oh!

serenity4 commented Nov 18, 2025

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

codecov-commenter commented Nov 4, 2025 •

edited

Loading

serenity4 commented Nov 13, 2025 •

edited

Loading

aviatesk left a comment •

edited

Loading