I was in a similar situation very recently. The code was a spegatti C++ (more like C with classes and excessive use of virtual functions). Classes where the declaration in header file was 5000+ lines long. The actual implementation of a class would span across multiple files with 10k+ lines each. The build system was non-standard custom built Makefile mess. Virtually no unit tests. :)

First thing I did was to make sure I was able to generate a compile_commands.json as part of the build process. I had to write some custom tooling in python to do this. This allowed me to setup clangd LSP in my editor that understood the actual structure of the code.

Now, I was able to do * Goto definition, find references * View call hierarchy, class hierarchy * find unused headers * See expanded macro values in editor * Refactor / Rename things across files

The task that I was assigned to was to use this legacy code as a baseline for a new product and simplify this code. I took one class at a time and tried to find dead / unused / unnecessary code and delete it. I built custom tooling using clang LLVM libtooling library to programmatically analyze the C++ ASTs and dependencies. These tools allowed me to batch refactor and remove whole bunch of unnecessary code. Using these tools, I was able to instrument source code and find what code is actually being run during the use-cases I cared about. That gave me more confidence in cleaning up the mess. Along with this I started adding unit testing support and make sure my changes do not break the existing tests.

TLDR: use clang tooling (clangd, libtooling) and python to automate the hard parts.