Product News

PVS-Studio for JetBrains CLion: ad astra per aspera

The PVS-Studio analyzer already has plugins for such IDEs from JetBrains as Rider, IntelliJ IDEA and Android Studio. Somehow we missed another IDE - CLion. The time has come to make amends!

PVS-Studio for JetBrains CLion: ad astra per aspera

by Evgeniy Ovsyannikov, Sergey Vasiliev

From the article:

Here's an answer to the question that we are discussing - PVS-Studio and CLion collaboration will let us detect more errors at the writing code stage. CLion highlights the errors on the fly, but at the same time is limited in the analysis capabilities. PVS-Studio doesn't highlight errors immediately, but it can perform deeper analysis. Note that PVS-Studio has an incremental analysis – the mode that checks only the changed files.

Intermodular analysis of C++ projects in PVS-Studio

Recently PVS-Studio has implemented a major feature—we supported intermodular analysis of C++ projects. This article covers our and other tools' implementations. You'll also find out how to try this feature and what we managed to detect using it.

Intermodular analysis of C++ projects in PVS-Studio

by Oleg Lisiy, Sergey Larin

From the article:

We can't apply the approach above to the PVS-Studio tool. Our analyzer's main difference from compilers is that it doesn't form intermediate representation that is abstracted from the language context. Therefore, to read a symbol from another module, the tool has to translate it again and represent a program as in-memory data structures (parse tree, control flow graph, etc). Data flow analysis may also require parsing the entire dependency graph by symbols in different modules. Such a task may take a long time. So, we collect information about symbols (in particular in data flow analysis) using semantic analysis. We need to somehow save this data separately beforehand. Such information is a set of facts for a particular symbol. We developed the below approach based on this idea.

Integrating PVS-Studio into uVision Keil

I've been using this scenario until one day I spent 3 days debugging a very unpleasant bug. The bug kept savagely appearing from time to time. It turned out to be a banal null pointer dereference. I quickly realized that PVS-Studio detects this bug. That was the final nail in the coffin of my patience! – and started integrating PVS-Studio into Keil.

Integrating PVS-Studio into uVision Keil

by Amomum

From the article:

Keil provides a weird feature – creating a project batch file. I still don't know the purpose of this feature. This batch file contains all the necessary information for PVS-Studio, and it's enabled with a single check mark! Unfortunately, this check mark also breaks the incremental build. That is, any compilation becomes a complete recompilation. It affects the build time, so, unfortunately, it's not an option for us.

Visual Studio Code C++ July 2021 Update: Disassembly View, Macro Expansion and...--Julia Reid

Are you going to use it?

Visual Studio Code C++ July 2021 Update: Disassembly View, Macro Expansion and Windows ARM64 Debugging

by Julia Reid

From the article:

The July 2021 update of the C++ extension for Visual Studio Code is here, bringing you brand new features— such as a Disassembly View while debugging, inline macro expansions, and debug support for Windows ARM64 architecture—along with a bunch of enhancements and bug fixes. To find out more about all the enhancements, check out our release notes on GitHub...

Using C++ Modules in MSVC from the Command Line Part 1--Cameron DaCamara

Time to get familiar!

Using C++ Modules in MSVC from the Command Line Part 1

by Cameron DaCamara

From the article:

In this three-part series we will explore how to build modules and header units from the command line as well as how to use/reference them.

The goal of this post is to serve as a brief tour of compiling and using primary module interfaces from the command line and the options we use...

CLion 2021.2: CMake Presets, GNU Autotools Projects, Debugger Updates, Lifetimes Analysis

CLion 2021.2 is here, helping you keep up with the changing C++ ecosystem!

CLion 2021.2: CMake Presets, GNU Autotools Projects, Debugger Updates, New Static Analysis, and More

by Anastasia Kazakova

From the article:

The C++ ecosystem is evolving, and so too is our cross-platform C/C++ IDE. CLion 2021.2 can help you by protecting your code from typical C++ memory safety issues, simplifying your build configurations, and making debugging easier and more effective.

  • Project models
    • Initial support for CMake Presets
    • CMake New Project templates
    • Support for GNU Autotools projects and Make preconfiguration steps
  • Debugger
    • Relaxed breakpoints, and breakpoints in disassembly view
    • Preview tab for the debugger
    • Remote LLDB and bundled LLDB 12
    • Better Natvis support and support for minidumps on Windows
    • FreeRTOS thread view
  • Lifetimes analysis, for catching common issues like dangling pointers and escaping from a local scope
  • Integration with Cling, an interactive C++ interpreter
  • Profiling in remote mode and on WSL
  • Easier Docker and WSL configuration
  • Text search in Local History and many VCS updates
  • Localized CLion UI in Chinese, Korean, and Japanese

HPX V1.7.0 released -- STE||AR Group

The STE||AR Group has released V1.7.0 of HPX -- A C++ Standard library for parallelism and concurrency.

HPX V1.7.0 Released

The newest version of HPX (V1.7.0) is now available for download! This release continues the focus on C++20 conformance with multiple new algorithms adapted to be C++20 conformant and becoming customization point objects (CPOs). We’ve also added experimental support for using GCC’s SIMD data types with our parallel algorithms. Finally, we've implemented a large subset of sender/receiver functionality based on current proposals (mainly P0443, P1897, and P2300). HPX futures fulfill the sender concept, and senders can explicitly be turned into futures, which means that codebases can gradually adopt senders where appropriate. The full list of improvements, fixes, and breaking changes can be found in the release notes.

    HPX is a general purpose parallel C++ runtime system for applications of any scale. It implements all of the related facilities as defined by the C++ Standard. As of this writing, HPX provides one of the only widely available open-source implementation of the new C++17 parallel algorithms. Additionally, HPX implements functionalities proposed as part of the ongoing C++ standardization process, such as large parts of the features related parallelism and concurrency as specified by the upcoming C++20 Standard, the C++ Concurrency TS, Parallelism TS V2, data-parallel algorithms, executors, senders/receivers and many more. It also extends the existing C++ Standard APIs to the distributed case (e.g. compute clusters) and for heterogeneous systems (e.g. GPUs).

    HPX seamlessly enables a new Asynchronous C++ Standard Programming Model that tends to improve the parallel efficiency of our applications and helps reducing complexities usually associated with parallelism and concurrency.


Beta-Testing of PVS-Studio Plugin for JetBrains CLion

To fully test the plugin, you'll need to install both the beta plugin version and the C++ core beta version of the analyzer. There are several ways to install the plugin: from the official repository, from the repository on our site, or using Windows PVS-Studio installer. Below we'll tell you in detail how to do this.

Beta-Testing of PVS-Studio Plugin for JetBrains CLion

by Evgeniy Ovsyannikov, Paul Eremeev

From the article:

We usually recommend running full analysis regularly, such as once a day, at night. In addition to nightly analysis, we highly recommend checking new code immediately after writing it. This way you'll get the best advantage of using the analyzer. To do this, use incremental analysis, which works as follows. A project was changed, a developer runs a build. After successful compilation only modified files will be analyzed. Modified files are the ones that have been changed since the previous analysis.