Compilation database

If you are working with a project which is not based on CMake, Gradle, or Makefiles, you can still benefit from the advanced IDE features that CLion provides. One way is to import a non-CMake project and let CLion convert it into a simple CMake structure. Another option is to open a project by loading its compilation database.

A compilation database lets CLion detect project files and extract all the necessary compiler information, such as include paths and compilation flags. This approach enables you to operate in the IDE and get the full experience of its capabilities while keeping your project independent from CMake, Makefile, or Gradle.

A compilation database is a JSON-formatted file named compile_commands.json that contains structured data about every compilation unit in your project.

The following snippet shows an example of a JSON compilation database:

                        {
                        "directory": "/Users/me/prj/Calendar/",
                        "command": "/usr/local/bin/g++-7 -I/Users/me/prj/Calendar/calendars -g -std=c++11 -o calendar_run.dir/main.cpp.o -c /Users/me/prj/Calendar/main.cpp",
                        "file": "/Users/me/prj/Calendar/main.cpp"
                        },
                        {
                        "directory": "/Users/me/prj/Calendar/calendars",
                        "command": "/usr/local/bin/g++-7 -I/Users/me/prj/Calendar/calendars -g -std=c++11 -o calendars.dir/calendar_defs.cpp.o -c /Users/me/prj/Calendar/calendars/calendar_defs.cpp",
                        "file": "/Users/me/prj/Calendar/calendars/calendar_defs.cpp"
                        }
                

You can see an array of entries called command objects. Each command object represents the translation unit’s main file, the working directory, the actual compile command (or the list of arguments), and optionally the name of the output created by the compilation step. For more information about the format, refer to the official documentation.

Generating a compilation database

To get a compilation database for your project, you have a wide variety of options: it can be generated by compilers, build systems, and specialized tools (see the expanded list of variants). Some examples are given below:

CMake:

Use the CMAKE_EXPORT_COMPILE_COMMANDS flag. You can run
cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=ON .
or add the following line to your CMakeLists.txt script:
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
The compile_commands.json file will be put into the build directory.

Clang (version 5.0 and later):

The -Mj option writes a compilation entry per input file. You can use it for each file in the project, and then merge the outputs into a JSON-formatted compilation database (refer to the procedure example).

Ninja (version 1.2 and later):

To get a compilation database, use the -t compdb option. Note that it requires rule names as arguments: -t compdb rule1 rule2... The list of rules is provided in the Ninja build file (default name build.ninja), for example:
rule cc command = gcc -c -o $out $in description = CC $out rule link command = gcc -o $out $in description = LINK $out
To generate a compilation database in case of only one rule named cc, specify:
-t compdb cc > compile_commands.json
But for multiple rules, you need to get their exact names from the build file and pass them to compdb (refer to one of the possible solutions).

Make-based projects:

The compiledb-generator tool creates compilation databases for make-based build systems.

Bear and intercept-build tools:

Bear and intercept-build from scan-build are the tools to help you get a compilation database by intercepting compiler calls during the build.

SourceTrail Visual Studio extension:

SourceTrail Extension generates a compilation database for Visual Studio solutions.

Working with compilation database in CLion

Once you have created a compilation database for your project, you can start working with it in CLion.

Load a project

Select File | Open from the main menu.
Locate the compile_commands.json file or the directory that contains it, then click Open.
Click Open as Project:
CLion will detect the project files and show the status of all commands in compile_commands.json in the Build tool window:
At this point, CLion's code insight, refactoring, analysis, and navigation are fully available for your project.

Check the toolchain

Go to Settings | Build, Execution, Deployment | Compilation Database
Select the toolchain to be used for resolving the project files:
CLion suggests all the available toolchains from Settings | Build, Execution, Deployment | Toolchain. Note that Remote Host toolchains are not currently supported for compilation database projects.

Change project root

By default, the project root is set to the directory containing the compilation database file. However, this is not always convenient: for example, if some project files are located outside the directory that contains compile_commands.json (which means outside the project root), such files are listed in the tree regardless the actual folder structure. In this case, you need to set the project root to the parent directory containing both compile_commands.json and the project files.

To change the project root, select Tools | Compilation Database | Change Project Root from the main menu, and set the new location for the project root.

Configure auto-reload

By default, CLion doesn't reload your project automatically on changes in compile_commands.json except for the cases of external events like VCS update. You can change this behavior in the Build Tools settings.

Go to Settings | Build, Execution, Deployment | Build Tools.
Select one of the auto-reload options:
- Any changes - project reload will be triggered on any change in compile_commands.json.
- External changes (default) - your project will be reloaded only upon external events like VCS update. In case of other changes in compile_commands.json, you need to reload your project manually. Use one of the following options:
  - Press Ctrl+Shift+O
  - Click the popup that appears in the editor:
  - Click in the Build tool window:
  - Select Tools | Compilation Database | Reload Compilation Database Project from the main menu.

Coding assistance in compile_database.json

CLion natively supports the JSON file format, so you can edit the compile_database.json file right in the IDE, with highlighting and code completion for help:

Code completion in compile_database.json

CLion checks the compliance of your compile_database.json file with the compilation database JSON schema. You can adjust the corresponding inspections in Settings | Editor | Inspections | JSON and JSON5:

JSON inspections for compile_database.json

Compile a single file

Although the build functionality for compilation database projects is not yet implemented in CLion, you may find it useful to check the changes in a single file without building the whole project. For this purpose, CLion provides the Recompile action. It is available for individual source and header files, and also for groups of files selected in the project tree. For headers, CLion uses resolve context to compile one of the source files that include the specified header. Note that Recompile is disabled for directories and non-C/C++ files.

To call Recompile for the currently opened file, select Build | Recompile from the main menu or press Ctrl+Shift+F9.
For a file in the project tree, use the Recompile option in the context menu (or press the same Ctrl+Shift+F9 keys).
To recompile several files, select them in the project tree, and use the Recompile selected files option from the context menu Ctrl+Shift+F9. Note that when used for multiple files, the recompilation stops upon the first compilation failure.

When you Recompile a file, CLion extracts necessary information from the corresponding command object in compile_commands.json: the compilation command line (yet CLion suppresses the output and removes the flags that specify output files), and the compiler to be used.

Mark a directory as..

The Mark Directory as action is also available for your compilation database projects. Select a directory in the Project tree, right-click it, and choose the Mark Directory as action.

For use case descriptions and more details on how CLion treats marked directories, refer to the section External source files.

Build and run

Compilation database itself lacks the data required for building, running and debugging an application. However, you can set up the workflow by adding custom build targets for your compilation database project and creating custom Run/Debug configurations for these targets.

Last modified: 11 October 2024