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 details on the format, see 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 (see 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 (see 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 MS Visual Studio solutions.

Working with compilation database in CLion

Load a project

Once you have created a compilation database for your project, you can load it in CLion. Navigate to File | Open on the main menu, choose the compile_commands.json file or a directory that contains it, and click Open as Project.

As a result, the project files are detected and the status of all commands in compile_commands.json is shown in the Build tool window:

Now CLion's code insight, refactoring, analysis, and navigation are fully available for your project.

CLion natively supports JSON file format, so you can edit the compile_database.json file right in the IDE, with highlighting and code completion for help. Also, CLion checks the compliance of your compile_database.json file with the compilation database JSON schema. For example, it notices when a property is missing in a command entry, or when you use a wrong type:

Check the toolchain

In Settings / Preferences | Build, Execution, Deployment | Compilation Database, you can select the toolchain to be used for resolving the project files:

CLion suggests all the available toolchains from Settings / Preferences | 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 of the directory with compile_commands.json (i.e., out of 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 provide a different location for the project root.

Configure auto-reload

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

Go to Settings / Preferences | Build, Execution, Deployment | Build Tools.
Select one of the auto-reload options:
- Any changes- project reload will be triggered on any change in compile_command.json.
- External changes (default) - your project will be reloaded only upon external events like VCS update. In case of other changes in compile_command.json, you need to reload your project manually. Use one of the following options:
  - Press Ctrl+Shift+O
  - Click on 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.

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, choose Build | Recompile from the main menu (or press Ctrl+Shift+F9). For a file in the project tree, use the Recompile option from the right-click 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 right-click 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 Tool Window, 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 Control source, library, and exclude directories.

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: 07 April 2021