llvm-project/clang-tools-extra/docs/ReleaseNotes.rst

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

220 lines
7.1 KiB
ReStructuredText
Raw Normal View History

====================================================
Extra Clang Tools 12.0.0 (In-Progress) Release Notes
====================================================
.. contents::
:local:
:depth: 3
Written by the `LLVM Team <https://llvm.org/>`_
.. warning::
These are in-progress notes for the upcoming Extra Clang Tools 12 release.
Release notes for previous releases can be found on
`the Download Page <https://releases.llvm.org/download.html>`_.
Introduction
============
This document contains the release notes for the Extra Clang Tools, part of the
Clang release 12.0.0. Here we describe the status of the Extra Clang Tools in
some detail, including major improvements from the previous release and new
feature work. All LLVM releases may be downloaded from the `LLVM releases web
site <https://llvm.org/releases/>`_.
For more information about Clang or LLVM, including information about
the latest release, please see the `Clang Web Site <https://clang.llvm.org>`_ or
the `LLVM Web Site <https://llvm.org>`_.
Note that if you are reading this file from a Git checkout or the
main Clang web page, this document applies to the *next* release, not
the current one. To see the release notes for a specific release, please
see the `releases page <https://llvm.org/releases/>`_.
What's New in Extra Clang Tools 12.0.0?
=======================================
Some of the major new features and improvements to Extra Clang Tools are listed
here. Generic improvements to Extra Clang Tools as a whole or to its underlying
infrastructure are described first, followed by tool-specific sections.
Major New Features
------------------
...
Improvements to clangd
----------------------
- clangd's memory usage is significantly reduced on most Linux systems.
In particular, memory usage should not increase dramatically over time.
The standard allocator on most systems is glibc's ptmalloc2, and it creates
disproportionately large heaps when handling clangd's allocation patterns.
By default, clangd will now periodically call ``malloc_trim`` to release free
pages on glibc systems.
Users of other allocators (such as ``jemalloc`` or ``tcmalloc``) on glibc
systems can disable this using ``--malloc_trim=0`` or the CMake flag
``-DCLANGD_MALLOC_TRIM=0``.
Improvements to clang-doc
-------------------------
The improvements are...
Improvements to clang-query
---------------------------
- The IgnoreImplicitCastsAndParentheses traversal mode has been removed.
Improvements to clang-rename
----------------------------
The improvements are...
Improvements to clang-tidy
--------------------------
- Checks that allow configuring names of headers to include now support wrapping
the include in angle brackets to create a system include. For example,
:doc:`cppcoreguidelines-init-variables
<clang-tidy/checks/cppcoreguidelines-init-variables>` and
:doc:`modernize-make-unique <clang-tidy/checks/modernize-make-unique>`.
- CheckOptions that take boolean values now support all spellings supported in
the `YAML format <https://yaml.org/type/bool.html>`_.
New modules
^^^^^^^^^^^
2020-09-10 23:35:10 +08:00
- New ``altera`` module.
Includes checks related to OpenCL for FPGA coding guidelines, based on the
`Altera SDK for OpenCL: Best Practices Guide
<https://www.altera.com/en_US/pdfs/literature/hb/opencl-sdk/aocl_optimization_guide.pdf>`_.
- New ``concurrency`` module.
Includes checks related to concurrent programming (e.g. threads, fibers,
coroutines, etc.).
New checks
^^^^^^^^^^
- New :doc:`altera-kernel-name-restriction
<clang-tidy/checks/altera-kernel-name-restriction>` check.
Finds kernel files and include directives whose filename is `kernel.cl`,
`Verilog.cl`, or `VHDL.cl`.
- New :doc:`altera-single-work-item-barrier
<clang-tidy/checks/altera-single-work-item-barrier>` check.
Finds OpenCL kernel functions that call a barrier function but do not call
an ID function.
- New :doc:`altera-struct-pack-align
<clang-tidy/checks/altera-struct-pack-align>` check.
Finds structs that are inefficiently packed or aligned, and recommends
packing and/or aligning of said structs as needed.
- New :doc:`cppcoreguidelines-prefer-member-initializer
<clang-tidy/checks/cppcoreguidelines-prefer-member-initializer>` check.
Finds member initializations in the constructor body which can be placed into
the initialization list instead.
- New :doc:`bugprone-misplaced-pointer-arithmetic-in-alloc
<clang-tidy/checks/bugprone-misplaced-pointer-arithmetic-in-alloc>` check.
- New :doc:`bugprone-redundant-branch-condition
<clang-tidy/checks/bugprone-redundant-branch-condition>` check.
Finds condition variables in nested ``if`` statements that were also checked
in the outer ``if`` statement and were not changed.
- New :doc:`concurrency-mt-unsafe <clang-tidy/checks/concurrency-mt-unsafe>`
check.
Finds thread-unsafe functions usage. Currently knows about POSIX and
Glibc function sets.
- New :doc:`bugprone-signal-handler
<clang-tidy/checks/bugprone-signal-handler>` check.
Finds functions registered as signal handlers that call non asynchronous-safe
functions.
- New :doc:`cert-sig30-c
<clang-tidy/checks/cert-sig30-c>` check.
Alias to the :doc:`bugprone-signal-handler
<clang-tidy/checks/bugprone-signal-handler>` check.
[clang-tidy] Introduce misc No Integer To Pointer Cast check While casting an (integral) pointer to an integer is obvious - you just get the integral value of the pointer, casting an integer to an (integral) pointer is deceivingly different. While you will get a pointer with that integral value, if you got that integral value via a pointer-to-integer cast originally, the new pointer will lack the provenance information from the original pointer. So while (integral) pointer to integer casts are effectively no-ops, and are transparent to the optimizer, integer to (integral) pointer casts are *NOT* transparent, and may conceal information from optimizer. While that may be the intention, it is not always so. For example, let's take a look at a routine to align the pointer up to the multiple of 16: The obvious, naive implementation for that is: ``` char* src(char* maybe_underbiased_ptr) { uintptr_t maybe_underbiased_intptr = (uintptr_t)maybe_underbiased_ptr; uintptr_t aligned_biased_intptr = maybe_underbiased_intptr + 15; uintptr_t aligned_intptr = aligned_biased_intptr & (~15); return (char*)aligned_intptr; // warning: avoid integer to pointer casts [misc-no-inttoptr] } ``` The check will rightfully diagnose that cast. But when provenance concealment is not the goal of the code, but an accident, this example can be rewritten as follows, without using integer to pointer cast: ``` char* tgt(char* maybe_underbiased_ptr) { uintptr_t maybe_underbiased_intptr = (uintptr_t)maybe_underbiased_ptr; uintptr_t aligned_biased_intptr = maybe_underbiased_intptr + 15; uintptr_t aligned_intptr = aligned_biased_intptr & (~15); uintptr_t bias = aligned_intptr - maybe_underbiased_intptr; return maybe_underbiased_ptr + bias; } ``` See also: * D71499 * [[ https://www.cs.utah.edu/~regehr/oopsla18.pdf | Juneyoung Lee, Chung-Kil Hur, Ralf Jung, Zhengyang Liu, John Regehr, and Nuno P. Lopes. 2018. Reconciling High-Level Optimizations and Low-Level Code in LLVM. Proc. ACM Program. Lang. 2, OOPSLA, Article 125 (November 2018), 28 pages. ]] Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D91055
2020-12-09 03:54:56 +08:00
- New :doc:`performance-no-int-to-ptr
<clang-tidy/checks/performance-no-int-to-ptr>` check.
Diagnoses every integer to pointer cast.
[clang-tidy] Implement readability-function-cognitive-complexity check Currently, there is basically just one clang-tidy check to impose some sanity limits on functions - `clang-tidy-readability-function-size`. It is nice, allows to limit line count, total number of statements, number of branches, number of function parameters (not counting implicit `this`), nesting level. However, those are simple generic metrics. It is still trivially possible to write a function, which does not violate any of these metrics, yet is still rather unreadable. Thus, some additional, slightly more complicated metric is needed. There is a well-known [[ https://en.wikipedia.org/wiki/Cyclomatic_complexity | Cyclomatic complexity]], but certainly has its downsides. And there is a [[ https://www.sonarsource.com/docs/CognitiveComplexity.pdf | COGNITIVE COMPLEXITY by SonarSource ]], which is available for opensource on https://sonarcloud.io/. This check checks function Cognitive Complexity metric, and flags the functions with Cognitive Complexity exceeding the configured limit. The default limit is `25`, same as in 'upstream'. The metric is implemented as per [[ https://www.sonarsource.com/docs/CognitiveComplexity.pdf | COGNITIVE COMPLEXITY by SonarSource ]] specification version 1.2 (19 April 2017), with two notable exceptions: * `preprocessor conditionals` (`#ifdef`, `#if`, `#elif`, `#else`, `#endif`) are not accounted for. Could be done. Currently, upstream does not account for them either. * `each method in a recursion cycle` is not accounted for. It can't be fully implemented, because cross-translational-unit analysis would be needed, which is not possible in clang-tidy. Thus, at least right now, i completely avoided implementing it. There are some further possible improvements: * Are GNU statement expressions (`BinaryConditionalOperator`) really free? They should probably cause nesting level increase, and complexity level increase when they are nested within eachother. * Microsoft SEH support * ??? Reviewed By: aaron.ballman, JonasToth, lattner Differential Revision: https://reviews.llvm.org/D36836
2017-08-17 23:57:00 +08:00
- New :doc:`readability-function-cognitive-complexity
<clang-tidy/checks/readability-function-cognitive-complexity>` check.
Flags functions with Cognitive Complexity metric exceeding the configured limit.
Changes in existing checks
^^^^^^^^^^^^^^^^^^^^^^^^^^
- Improved :doc:`modernize-loop-convert
<clang-tidy/checks/modernize-loop-convert>` check.
Now able to transform iterator loops using ``rbegin`` and ``rend`` methods.
- Improved :doc:`readability-identifier-naming
<clang-tidy/checks/readability-identifier-naming>` check.
Added an option `GetConfigPerFile` to support including files which use
different naming styles.
Now renames overridden virtual methods if the method they override has a
style violation.
Added support for specifying the style of scoped ``enum`` constants. If
unspecified, will fall back to the style for regular ``enum`` constants.
Added an option `IgnoredRegexp` per identifier type to suppress identifier
naming checks for names matching a regular expression.
- Removed `google-runtime-references` check because the rule it checks does
not exist in the Google Style Guide anymore.
- Improved :doc:`readability-redundant-string-init
<clang-tidy/checks/readability-redundant-string-init>` check.
Added `std::basic_string_view` to default list of ``string``-like types.
Improvements to include-fixer
-----------------------------
The improvements are...
Improvements to clang-include-fixer
-----------------------------------
The improvements are...
Improvements to modularize
--------------------------
The improvements are...
Improvements to pp-trace
------------------------
The improvements are...
Clang-tidy visual studio plugin
-------------------------------