[clang-tidy] Add portability-non-portable-integer-constant check

[Discookie]

Summary

This check finds integer literals that are being used in a non-portable manner.

Currently, the check detects cases where maximum or minimum values should be used
instead, as well as error-prone integer literals having leading zeroes, or
relying on most significant bits.

[Eugene.Zelenko]

Please add alias entry in Release Notes.

clang-tools-extra/clang-tidy/portability/NonPortableIntegerConstantCheck.cpp

95

Excessive newline.

clang-tools-extra/docs/ReleaseNotes.rst

136

Incorrect entry.

clang-tools-extra/docs/clang-tidy/checks/portability/non-portable-integer-constant.rst

4

Please make is same length as title.

[PiotrZSL]

clang-tools-extra/clang-tidy/portability/NonPortableIntegerConstantCheck.cpp

92

consider excluding system headers, or even exclude things like "equals(0)" to speed up check.

103

use type instead of auto

146

add here some hint to developer what to do, in cpp suggest using std::numeric_limits, in C some other MAX macro.
Same for other.

clang-tools-extra/clang-tidy/portability/NonPortableIntegerConstantCheck.h

20

this check is already in portability group, no need to duplicate "portable".
Maybe just portability-integer-constant

clang-tools-extra/docs/clang-tidy/checks/portability/non-portable-integer-constant.rst

22

well, not, right way would be using std::numeric_limits<std::uint32_t>::max().
And unsigned long can be 4 bytes or 8 bytes or anything compiler decide.
So this example got more issues., and 0XFFF.. is a last of them, and -1 is not valid in such case.

clang-tools-extra/test/clang-tidy/checkers/portability/non-portable-integer-constant.cpp

1

no need to limit this check to c++17 or later.
when it's targeting all versions of C and C++

229

exclude system macros, otherwise it may warn for things like ULONG_MAX

[PiotrZSL]

Additionally, fix build.
Once you finish making changes to this review, switch it back to ready for review.

[whisperity]

Earlier (IIRC in March) we did an internal test of the check and the following results were obtained. The results are kinda weird, to say the least. Numbers are after CodeChecker has done a serverside uniqueing (most likely things such as "if X in H.h is reported in the compilation/analysis of A.cpp and B.cpp then store X only once") of the bugs.

• memcache-d: 43
• tmux: 4
• curl: 283
• twin: 161
• vim: 2 206
• OpenSSL: 23 724
• sqlite: 752
• ffmpeg: 87 121
• postgres: 116 635
• tinyxml2: 6
• libwebm: 34
• xerces: 48 732
• bitcoin: 4 429
• protobuf: 1 405
• codechecker-ldlogger: 0
• ACID: 4 831
• Qt: 34 973
• Contour v2: 14 246
• LLVM: 6 018

No crashes (of the checker) were observed. Most of the large outlier numbers are attributable to heavy mathematics (ffmpeg, Qt), crypto (OpenSSL, PostgreSQL), or character encoding (Xerces, Postgres, Contour) operations in the project.

Unfortunately, this is a very significant amount of false positives to the point where the consumption of results is slowed down not on the mental load side, but also the technical side (such as triggering server hangs in CodeChecker and whatnot...). However, after putting some thoughts into it and trying to hand-clusterise some of the reports I've found a few significant opportunities where this check should be improved.

Note: These improvements might be worthwhile to implement as a follow-up patch which is merged together with this current review. As it stands right now, this check is way too noisy (on maths-based projects) to be merged!

1. Enums

One is when the literal is used to initialise an enum. So far I don't know whether simply just ignoring enums is good, or would it be worth to somehow emit a "unified" warning for the entire enum that follows the pattern as shown below.

2. (u)?int([\d]+)_t

The other are cases when the user explicitly initialises a fixed-width (or *constrained-width*) variable, such as int64_t or uint16_t with a literal. Right now, the implementation hard matches only the IntegerLiteral instances, i.e., lines such as static constexpr std::uint64_t X = 0x07F000000 where the width and characteristics of the literal might just as well *exactly* and *properly* match the variable it is assigned to (granted, we only match and silence Decls for this, and lose expressivity on expressions), and do not report then.

3. Large arrays of magic literals

While this is not the silencing of a "valid" use case where the check, as of the current implementation, it is too verbose for, but I believe we could reasonably cull the noisiness of the check by simply saying that if there are array initialisers or brace-init-lists or whatever that contain multiple non-portable literals, then either we simply suck it up and do not warn for any of the elements... or for the sake of collegiality give one warning for the user. The former option would be the most silencing of all, while the latter would allow the user to do a single // NOLINT for the array instead of having to deal with /* NOLINTBEGIN */ ... /* NOLINTEND */.

Several chunks of noisy warnings come out of places like SHA-256, FFT, and various other "very mathematical" contexts where a large constant array is created with very specific proven values, all of which expressed and reported as "non-portable literals". It is no use to do 500000 warnings for a single array. (This is perhaps after all the same(-ish) family as the "enum" problem.)

clang-tools-extra/clang-tidy/portability/NonPortableIntegerConstantCheck.cpp

87

(Unrealistic nit: This will consume hypothetical additional literals such as 0!ZZZbb= as if they were decimal literals.)

153–154

(Style nit: These lines could be joined and still fit 80-col, I think.)

clang-tools-extra/clang-tidy/portability/NonPortableIntegerConstantCheck.h

16

I am still not entirely convinced whether this one-line summary makes too much sense to a user who does not know the Standard out of heart... As we hunt for bit widths more or less perhaps we could weave this notion into the single sentence summary saying that integers with "non-portable representations because of bit width"... Will need to give this some thought.

clang-tools-extra/test/clang-tidy/checkers/portability/non-portable-integer-constant.cpp

1

Binary literals require C++17 and some version of newer C standard (think C11?). However, technically it could work to use c++11-or-later and then use the __cplusplus macro to only compile the binary literal test when appropriately C++17.

72–74

(Style nit: Did we lose a test here, or is this just an accidental contiguous area of newlines?)

clang-tools-extra/clang-tidy/cert/CERTTidyModule.cpp

 #include "../bugprone/UnusedReturnValueCheck.h"
 #include "../concurrency/ThreadCanceltypeAsynchronousCheck.h"
 #include "../google/UnnamedNamespaceInHeaderCheck.h"
 #include "../misc/NewDeleteOverloadsCheck.h"
 #include "../misc/NonCopyableObjects.h"
 #include "../misc/StaticAssertCheck.h"
 #include "../misc/ThrowByValueCatchByReferenceCheck.h"
 #include "../performance/MoveConstructorInitCheck.h"
+#include "../portability/NonPortableIntegerConstantCheck.h"
 #include "../readability/UppercaseLiteralSuffixCheck.h"
 #include "CommandProcessorCheck.h"
 #include "DefaultOperatorNewAlignmentCheck.h"
 #include "DontModifyStdNamespaceCheck.h"
 #include "FloatLoopCounter.h"
 #include "LimitedRandomnessCheck.h"
 #include "MutatingCopyCheck.h"
 #include "NonTrivialTypesLibcMemoryCallsCheck.h"
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<bugprone::SuspiciousMemoryComparisonCheck>(
         "cert-exp42-c");
     // FLP
     CheckFactories.registerCheck<FloatLoopCounter>("cert-flp30-c");
     CheckFactories.registerCheck<bugprone::SuspiciousMemoryComparisonCheck>(
         "cert-flp37-c");
     // FIO
     CheckFactories.registerCheck<misc::NonCopyableObjectsCheck>("cert-fio38-c");
+    // INT
+    CheckFactories.registerCheck<portability::NonPortableIntegerConstantCheck>(
+        "cert-int17-c");
     // MSC
     CheckFactories.registerCheck<bugprone::UnsafeFunctionsCheck>(
         "cert-msc24-c");
     CheckFactories.registerCheck<LimitedRandomnessCheck>("cert-msc30-c");
     CheckFactories.registerCheck<ProperlySeededRandomGeneratorCheck>(
         "cert-msc32-c");
     CheckFactories.registerCheck<bugprone::UnsafeFunctionsCheck>(
         "cert-msc33-c");

clang-tools-extra/clang-tidy/cert/CMakeLists.txt

add_clang_library(clangTidyCERTModule
 
   LINK_LIBS
   clangTidy
   clangTidyBugproneModule
   clangTidyConcurrencyModule
   clangTidyGoogleModule
   clangTidyMiscModule
   clangTidyPerformanceModule
+  clangTidyPortabilityModule
   clangTidyReadabilityModule
   clangTidyUtils
 
   DEPENDS
   omp_gen
   )
 
 clang_target_link_libraries(clangTidyCERTModule
   PRIVATE
   clangAST
   clangASTMatchers
   clangBasic
   clangLex
   )

clang-tools-extra/clang-tidy/portability/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   FrontendOpenMP
   Support
   TargetParser
   )
 
 add_clang_library(clangTidyPortabilityModule
+  NonPortableIntegerConstantCheck.cpp
   PortabilityTidyModule.cpp
   RestrictSystemIncludesCheck.cpp
   SIMDIntrinsicsCheck.cpp
   StdAllocatorConstCheck.cpp
 
   LINK_LIBS
   clangTidy
   clangTidyUtils

clang-tools-extra/clang-tidy/portability/NonPortableIntegerConstantCheck.h

+//===--- NonPortableIntegerConstantCheck.h - clang-tidy ---------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PORTABILITY_NON_PORTABLE_INTEGER_CONSTANT_CHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PORTABILITY_NON_PORTABLE_INTEGER_CONSTANT_CHECK_H
+
+#include "../ClangTidyCheck.h"
+
+namespace clang::tidy::portability {
+
+/// Finds integer literals that are being used in a non-portable manner.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/portability/non-portable-integer-constant.html
+class NonPortableIntegerConstantCheck : public ClangTidyCheck {
+public:
+  NonPortableIntegerConstantCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+};
+
+} // namespace clang::tidy::portability
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PORTABILITY_NON_PORTABLE_INTEGER_CONSTANT_CHECK_H

clang-tools-extra/clang-tidy/portability/NonPortableIntegerConstantCheck.cpp

+//===--- NonPortableIntegerConstantCheck.cpp - clang-tidy -----------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "NonPortableIntegerConstantCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/Decl.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Lex/Lexer.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang::tidy::portability {
+namespace {
+
+struct SanitizedLiteralType {
+  StringRef StrippedLiteral;
+  // The exact bit value of the MSB.
+  std::size_t MSBBit;
+  // The bit value of MSB rounded up to the nearest byte.
+  std::size_t MSBByte;
+  std::size_t Radix;
+};
+
+} // namespace
+
+// Does not calculate true MSB - only takes the value of the first digit into
+// account alongside the total digit count. Returns MSB zero if radix is 10, and
+// MSBBit zero if first digit is 0.
+static SanitizedLiteralType sanitizeAndCountBits(std::string &IntegerLiteral) {
+  llvm::erase_value(IntegerLiteral, '\''); // Skip digit separators.
+  StringRef StrippedLiteral{IntegerLiteral};
+
+  const auto MSBBit = [&StrippedLiteral](std::size_t RemainingBitCount)
+                        -> std::size_t {
+    char FirstDigit = StrippedLiteral.front();
+
+    if (FirstDigit == '0') {
+      return 0;
+    } else if (FirstDigit <= '1') {
+      return RemainingBitCount + 1;
+    } else if (FirstDigit <= '3') {
+      return RemainingBitCount + 2;
+    } else if (FirstDigit <= '7') {
+      return RemainingBitCount + 3;
+    } else {
+      return RemainingBitCount + 4;
+    }
+  };
+
+  if(StrippedLiteral.consume_front("0b"))
+  {
+    StrippedLiteral = StrippedLiteral.take_while(
+      [](char c){return c == '0' || c == '1'; });
+    assert(!StrippedLiteral.empty());
+
+    return { StrippedLiteral,
+        MSBBit(StrippedLiteral.size() - 1), 
+        StrippedLiteral.size(), 
+        2 };
+  }
+  else if(StrippedLiteral.consume_front("0x"))
+  {
+    StrippedLiteral = StrippedLiteral.take_while(llvm::isHexDigit);
+    assert(!StrippedLiteral.empty());
+
+    return { StrippedLiteral,
+      MSBBit((StrippedLiteral.size() - 1) * 4),
+      StrippedLiteral.size() * 4,
+      16 };
+  }
+  else if(StrippedLiteral != "0" && StrippedLiteral.consume_front("0"))
+  {
+    StrippedLiteral = StrippedLiteral.take_while(
+      [](char c){ return c >= '0' || c <= '7'; });
+    assert(!StrippedLiteral.empty());
+
+    return { StrippedLiteral,
+        MSBBit((StrippedLiteral.size() - 1) * 3),
+        StrippedLiteral.size() * 3,
+        8 };
+  } else {
+    return { StrippedLiteral, 0, 0, 10 };
+  }
+}
+
+void NonPortableIntegerConstantCheck::registerMatchers(MatchFinder *Finder) {
+  Finder->addMatcher(integerLiteral().bind("integer"), this);
+}
+
+
+void NonPortableIntegerConstantCheck::check(
+    const MatchFinder::MatchResult &Result) {
+  const auto *MatchedInt = Result.Nodes.getNodeAs<IntegerLiteral>("integer");
+
+  assert(MatchedInt);
+
+  QualType IntegerLiteralType = MatchedInt->getType();
+  auto LiteralBitWidth = Result.Context->getTypeSize( IntegerLiteralType );
+
+  llvm::APInt LiteralValue = MatchedInt->getValue();
+
+  std::string LiteralStr =
+      Lexer::getSourceText(
+          CharSourceRange::getTokenRange(MatchedInt->getSourceRange()),
+          *Result.SourceManager, Result.Context->getLangOpts(), nullptr)
+          .lower();
+
+  // FIXME: There are two problematic cases where we cannot read the character.
+  // With macros, in some cases (such as when not passing an argument) the
+  // integer literal's token range will be 0 long.
+  if (LiteralStr.empty())
+    return;
+  // A template function with an integer literal template argument will warn in
+  // both the argument, and the function body. In the instantiated body, the
+  // source range will contain the argument name, not the literal.
+  // FIXME: This disables checking macro literals entirely.
+  if (!llvm::isDigit(LiteralStr[0]))
+    return;
+
+  const SanitizedLiteralType SanitizedLiteral = sanitizeAndCountBits(LiteralStr);
+
+  // Only potential edge case is "0", handled by sanitizeAndCountBits.
+  assert(!SanitizedLiteral.StrippedLiteral.empty() &&
+         "integer literal should not be empty");
+
+  assert(SanitizedLiteral.MSBBit <= LiteralBitWidth &&
+         "integer literal has more bits set than its bit width");
+
+  bool IsMax = LiteralValue.isMaxValue() || LiteralValue.isMaxSignedValue();
+  bool IsUnsignedMaxMinusOne = (LiteralValue + 1).isMaxValue();
+  bool IsMin = LiteralValue.isMinValue() || LiteralValue.isMinSignedValue();
+  bool RepresentsZero = LiteralValue.isNullValue();
+
+  bool IsMSBBitUsed = SanitizedLiteral.MSBBit == LiteralBitWidth;
+  // Can be greater, eg. an 8-bit UCHAR_MAX byte value represented by 377 octal
+  bool IsMSBByteUsed = SanitizedLiteral.MSBByte >= LiteralBitWidth;
+  bool HasLeadingZeroes = SanitizedLiteral.StrippedLiteral[0] == '0';
+
+  if (IsMax || IsUnsignedMaxMinusOne) {
+    diag(MatchedInt->getBeginLoc(),
+         "non-portable integer literal: hardcoded platform-specific maximum value");
+  } else if (IsMin && !RepresentsZero) {
+    diag(MatchedInt->getBeginLoc(),
+         "non-portable integer literal: hardcoded platform-specific minimum value");
+  } else if (HasLeadingZeroes && !RepresentsZero) {
+    diag(MatchedInt->getBeginLoc(),
+         "non-portable integer literal: integer literal with leading zeroes");
+  // Matches only the most significant bit,
+  // eg. unsigned value 0x80000000.
+  } else if (IsMSBBitUsed) {
+    diag(MatchedInt->getBeginLoc(),
+         "non-portable integer literal: should not rely on the most significant bit");
+  // Matches the most significant byte,
+  // eg. literals like 0x30000000.
+  } else if (IsMSBByteUsed) {
+    diag(MatchedInt->getBeginLoc(),
+         "non-portable integer literal: should not rely on bits of most significant byte");
+  }
+}
+
+} // namespace clang::tidy::portability

clang-tools-extra/clang-tidy/portability/PortabilityTidyModule.cpp

 //===--- PortabilityTidyModule.cpp - clang-tidy ---------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "../ClangTidy.h"
 #include "../ClangTidyModule.h"
 #include "../ClangTidyModuleRegistry.h"
+#include "NonPortableIntegerConstantCheck.h"
 #include "RestrictSystemIncludesCheck.h"
 #include "SIMDIntrinsicsCheck.h"
 #include "StdAllocatorConstCheck.h"
 
 namespace clang::tidy {
 namespace portability {
 
 class PortabilityModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
+    CheckFactories.registerCheck<NonPortableIntegerConstantCheck>(
+        "portability-non-portable-integer-constant");
     CheckFactories.registerCheck<RestrictSystemIncludesCheck>(
         "portability-restrict-system-includes");
     CheckFactories.registerCheck<SIMDIntrinsicsCheck>(
         "portability-simd-intrinsics");
     CheckFactories.registerCheck<StdAllocatorConstCheck>(
         "portability-std-allocator-const");
   }
 };

clang-tools-extra/docs/ReleaseNotes.rst

- New :doc:`cppcoreguidelines-rvalue-reference-param-not-moved
   the function body.
 
 - New :doc:`llvmlibc-inline-function-decl
   <clang-tidy/checks/llvmlibc/inline-function-decl>` check.
 
   Checks that all implicit and explicit inline functions in header files are
   tagged with the ``LIBC_INLINE`` macro.
 
+- New :doc:`portability-non-portable-integer-constant
+  <clang-tidy/checks/portability-non-portable-integer-constant>` check.
+
+  Finds masks that are being used in a non-portable manner.
+
+- New :doc:`portability-non-portable-integer-constant
+  <clang-tidy/checks/portability/non-portable-integer-constant>` check.
+
+  Finds integer literals that are being used in a non-portable manner.
+
 New check aliases
 ^^^^^^^^^^^^^^^^^
 
 - New alias :doc:`cert-msc24-c
   <clang-tidy/checks/cert/msc24-c>` to :doc:`bugprone-unsafe-functions
   <clang-tidy/checks/bugprone/unsafe-functions>` was added.
 
 - New alias :doc:`cert-msc33-c

clang-tools-extra/docs/clang-tidy/checks/cert/int17-c.rst

+.. title:: clang-tidy - cert-int17-c
+.. meta::
+   :http-equiv=refresh: 5;URL=../portability/non-portable-integer-constant.html
+
+cert-int17-c
+============
+
+The cert-int17-c check is an alias, please see
+`portability-non-portable-integer-constant <../portability/non-portable-integer-constant.html>`_
+for more information.

clang-tools-extra/docs/clang-tidy/checks/list.rst

.. csv-table::
    `cert-dcl58-cpp <cert/dcl58-cpp.html>`_,
    `cert-env33-c <cert/env33-c.html>`_,
    `cert-err33-c <cert/err33-c.html>`_,
    `cert-err34-c <cert/err34-c.html>`_,
    `cert-err52-cpp <cert/err52-cpp.html>`_,
    `cert-err58-cpp <cert/err58-cpp.html>`_,
    `cert-err60-cpp <cert/err60-cpp.html>`_,
    `cert-flp30-c <cert/flp30-c.html>`_,
+   `cert-int17-c <cert/int17-c.html>`_,
    `cert-mem57-cpp <cert/mem57-cpp.html>`_,
    `cert-msc50-cpp <cert/msc50-cpp.html>`_,
    `cert-msc51-cpp <cert/msc51-cpp.html>`_,
    `cert-oop57-cpp <cert/oop57-cpp.html>`_,
    `cert-oop58-cpp <cert/oop58-cpp.html>`_,
    `clang-analyzer-core.DynamicTypePropagation <clang-analyzer/core.DynamicTypePropagation.html>`_,
    `clang-analyzer-core.uninitialized.CapturedBlockVariable <clang-analyzer/core.uninitialized.CapturedBlockVariable.html>`_,
    `clang-analyzer-cplusplus.InnerPointer <clang-analyzer/cplusplus.InnerPointer.html>`_,
.. csv-table::
    `performance-move-constructor-init <performance/move-constructor-init.html>`_,
    `performance-no-automatic-move <performance/no-automatic-move.html>`_,
    `performance-no-int-to-ptr <performance/no-int-to-ptr.html>`_,
    `performance-noexcept-move-constructor <performance/noexcept-move-constructor.html>`_, "Yes"
    `performance-trivially-destructible <performance/trivially-destructible.html>`_, "Yes"
    `performance-type-promotion-in-math-fn <performance/type-promotion-in-math-fn.html>`_, "Yes"
    `performance-unnecessary-copy-initialization <performance/unnecessary-copy-initialization.html>`_, "Yes"
    `performance-unnecessary-value-param <performance/unnecessary-value-param.html>`_, "Yes"
+   `portability-non-portable-integer-constant <portability/non-portable-integer-constant.html>`_,
    `portability-restrict-system-includes <portability/restrict-system-includes.html>`_, "Yes"
    `portability-simd-intrinsics <portability/simd-intrinsics.html>`_,
    `portability-std-allocator-const <portability/std-allocator-const.html>`_,
    `readability-avoid-const-params-in-decls <readability/avoid-const-params-in-decls.html>`_, "Yes"
    `readability-braces-around-statements <readability/braces-around-statements.html>`_, "Yes"
    `readability-const-return-type <readability/const-return-type.html>`_, "Yes"
    `readability-container-contains <readability/container-contains.html>`_, "Yes"
    `readability-container-data-pointer <readability/container-data-pointer.html>`_, "Yes"

clang-tools-extra/docs/clang-tidy/checks/portability/non-portable-integer-constant.rst

+.. title:: clang-tidy - portability-non-portable-integer-constant
+
+portability-non-portable-integer-constant
+======================================
+
+`cert-int17-c` redirects here as an alias for this check.
+
+Finds integer literals that are being used in a non-portable manner.
+
+Currently the check detects cases where maximum or minimum values should be used
+instead, as well as error-prone integer literals having leading zeroes, or
+relying on the most significant bits.
+
+This check corresponds to CERT C Coding Standard rule `INT17-C. Define integer 
+constants in an implementation-independent manner
+<https://wiki.sei.cmu.edu/confluence/display/c/INT17-C.+Define+integer+constants+in+an+implementation-independent+manner>`_.
+
+.. code-block:: c
+    
+    unsigned long flip_bits(unsigned long x) {
+      return x ^ 0xFFFFFFFF;
+      // The right way to write this would be ULONG_MAX, or -1.
+    }
+
+.. code-block:: c++
+
+    const unsigned long mask = 0b1000'0000'0000'0000'0000'0000'0000'0000; // warn
+    // The right way to write this would be ~(ULONG_MAX >> 1).
+    unsigned long x;
+
+    x &= mask;
+
+.. code-block:: c++
+
+    const unsigned long bit_to_set = 0x00010000; // warn
+    // Incorrectly assumes that long is 4 bytes.
+
+    unsigned long set_bit(unsigned long x) {
+      return x | bit_to_set;
+    }

clang-tools-extra/test/clang-tidy/checkers/portability/non-portable-integer-constant.cpp

+// RUN: %check_clang_tidy %s -std=c++17-or-later portability-non-portable-integer-constant %t
+
+using int32_t = decltype(42);
+
+void regular() {
+  // no-warnings
+  0;
+  00;
+  0x0;
+  0x00;
+  0b0;
+  0b00;
+  0b0'0'0;
+
+  -1;
+  -0X1;
+
+  127;
+  0x7'f;
+
+  -128;
+  -0x80;
+
+  256;
+  0X100;
+
+  42;
+  0x2A;
+
+  180079837;
+  0xabbccdd;
+
+  // FIXME: (only 31 bits) False positive, reported as max signed int.
+  0b1111111111111111111111111111111;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: hardcoded platform-specific maximum value [portability-non-portable-integer-constant]
+
+  // FIXME: Large numbers represented as hex are the most common false positive,
+  // eg. the following literal is a 64-bit prime.
+  0xff51afd7ed558ccd;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: should not rely on the most significant bit [portability-non-portable-integer-constant]
+
+  // FIXME: Fixed-size integer literals are a common false positive as well.
+  int32_t literal = 0x40000000;
+  // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: non-portable integer literal: should not rely on bits of most significant byte [portability-non-portable-integer-constant]
+
+  // FIXME: According to the standard, the type of the integer literal is the
+  // smallest type it can fit into. While technically a false positive, it could
+  // signal literal width confusion regardless.
+  long long int long_literal = 0x7fffffff;
+  // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: non-portable integer literal: hardcoded platform-specific maximum value [portability-non-portable-integer-constant]
+}
+
+enum LiteralClamp {
+
+};
+
+// INT_MIN, INT_MAX, UINT_MAX, UINT_MAX-1
+// All binary literals are 32 bits long
+void limits_int() {
+  // FIXME: not recognize as Min
+  -214748'3'648;
+  // --CHECK-MESSAGES: :[[@LINE-1]]:4: warning: non-portable integer literal: hardcoded platform-specific minimum value [portability-non-portable-integer-constant]
+
+  -0x80'00'00'00;
+  // CHECK-MESSAGES: :[[@LINE-1]]:4: warning: non-portable integer literal: hardcoded platform-specific minimum value [portability-non-portable-integer-constant]
+
+  -020000000000;
+  // CHECK-MESSAGES: :[[@LINE-1]]:4: warning: non-portable integer literal: hardcoded platform-specific minimum value [portability-non-portable-integer-constant]
+
+  -0b10000000000000000000000000000000;
+  // CHECK-MESSAGES: :[[@LINE-1]]:4: warning: non-portable integer literal: hardcoded platform-specific minimum value [portability-non-portable-integer-constant]
+
+
+
+  21474'83647;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: hardcoded platform-specific maximum value [portability-non-portable-integer-constant]
+
+  0x7FFFFFFF;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: hardcoded platform-specific maximum value [portability-non-portable-integer-constant]
+
+  017777777777;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: hardcoded platform-specific maximum value [portability-non-portable-integer-constant]
+
+  429'4'96'7295u;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: hardcoded platform-specific maximum value [portability-non-portable-integer-constant]
+
+  0xFFFFFFFF;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: hardcoded platform-specific maximum value [portability-non-portable-integer-constant]
+
+  037777777777;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: hardcoded platform-specific maximum value [portability-non-portable-integer-constant]
+
+  0B11111111111111111111111111111111;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: hardcoded platform-specific maximum value [portability-non-portable-integer-constant]
+
+  4294967294;  // recognized as long ( Not UINT_MAX-1)
+  // --CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: hardcoded platform-specific maximum value [portability-non-portable-integer-constant]
+
+  0XFFFFFFFE;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: hardcoded platform-specific maximum value [portability-non-portable-integer-constant]
+
+  037777777776;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: hardcoded platform-specific maximum value [portability-non-portable-integer-constant]
+
+  0B11111111111111111111111111111110;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: hardcoded platform-specific maximum value [portability-non-portable-integer-constant]
+}
+
+// LLONG_MIN, LLONG_MAX, ULLONG_MAX, ULLONG_MAX-1
+// Most binary literals are 64 bits long
+void limits_llong() {
+  -9'22337203'6854775808LL;
+  // CHECK-MESSAGES: :[[@LINE-1]]:4: warning: non-portable integer literal: hardcoded platform-specific minimum value [portability-non-portable-integer-constant]
+
+  0x8000000000000000;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: hardcoded platform-specific minimum value [portability-non-portable-integer-constant]
+
+  01000000000000000000000;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: hardcoded platform-specific minimum value [portability-non-portable-integer-constant]
+
+  0b1000000000000000000000000000000000000000000000000000000000000000;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: hardcoded platform-specific minimum value [portability-non-portable-integer-constant]
+
+  9223372036854775807;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: hardcoded platform-specific maximum value [portability-non-portable-integer-constant]
+
+  0x7FFFFFFFFFFFFFFF;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: hardcoded platform-specific maximum value [portability-non-portable-integer-constant]
+
+  0777777777777777777777;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: hardcoded platform-specific maximum value [portability-non-portable-integer-constant]
+
+  // 63 bits
+  0b111111111111111111111111111111111111111111111111111111111111111;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: hardcoded platform-specific maximum value [portability-non-portable-integer-constant]
+
+  18446744073709551615llU;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: hardcoded platform-specific maximum value [portability-non-portable-integer-constant]
+
+  0xFFFFFFFFFFFFFFFF;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: hardcoded platform-specific maximum value [portability-non-portable-integer-constant]
+
+  01777777777777777777777;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: hardcoded platform-specific maximum value [portability-non-portable-integer-constant]
+
+  0b1111111111111111111111111111111111111111111111111111111111111111;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: hardcoded platform-specific maximum value [portability-non-portable-integer-constant]
+
+  18446744073709551614llU;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: hardcoded platform-specific maximum value [portability-non-portable-integer-constant]
+
+  0xFFFFFFFFFFFFFFFe;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: hardcoded platform-specific maximum value [portability-non-portable-integer-constant]
+
+  01777777777777777777776;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: hardcoded platform-specific maximum value [portability-non-portable-integer-constant]
+
+  0b1111111111111111111111111111111111111111111111111111111111111110;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: hardcoded platform-specific maximum value [portability-non-portable-integer-constant]
+}
+
+void full_patterns() {
+  0x7F'FF'FF'FF;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: hardcoded platform-specific maximum value [portability-non-portable-integer-constant]
+  -0x80'00'00'00;
+  // CHECK-MESSAGES: :[[@LINE-1]]:4: warning: non-portable integer literal: hardcoded platform-specific minimum value [portability-non-portable-integer-constant]
+  0xFFFFFFFFu;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: hardcoded platform-specific maximum value [portability-non-portable-integer-constant]
+  0xFF'FF'FF'Fe;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: hardcoded platform-specific maximum value [portability-non-portable-integer-constant]
+
+
+  0x7F'FF'FFFFFFFFFFFF;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: hardcoded platform-specific maximum value [portability-non-portable-integer-constant]
+  -0x80'0000000000000'0LL;
+  // CHECK-MESSAGES: :[[@LINE-1]]:4: warning: non-portable integer literal: hardcoded platform-specific minimum value [portability-non-portable-integer-constant]
+  0XFFffFFFffFFFFFFFllU;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: hardcoded platform-specific maximum value [portability-non-portable-integer-constant]
+}
+
+void most_significant_bits() {
+  0x80004000;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: should not rely on the most significant bit [portability-non-portable-integer-constant]
+
+  0xAFFFFFFF;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: should not rely on the most significant bit [portability-non-portable-integer-constant]
+
+  0x10000000;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: should not rely on bits of most significant byte [portability-non-portable-integer-constant]
+
+  0x3000200010004000;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: should not rely on bits of most significant byte [portability-non-portable-integer-constant]
+
+  0x00001000;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: integer literal with leading zeroes [portability-non-portable-integer-constant]
+
+  // In some cases, an integer literal represents a smaller type than its
+  // bitcount, which caused issues with MSBBit detection.
+  0x0000000000000001;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal: integer literal with leading zeroes [portability-non-portable-integer-constant]
+}
+
+template <int I> bool template_unused_reported() { return I < 0x7FFFFFFF; }
+// CHECK-MESSAGES: :[[@LINE-1]]:63: warning: non-portable integer literal
+
+template <int I> bool template_arg_not_reported() { return I < 0x7FFFFFFF; }
+// CHECK-MESSAGES: :[[@LINE-1]]:64: warning: non-portable integer literal
+// CHECK-MESSAGES-NOT: :[[@LINE-2]]:60: warning: non-portable integer literal
+
+template <int I = 0x7FFFFFFF > bool template_default_reported() { return I < 0; }
+// CHECK-MESSAGES: :[[@LINE-1]]:19: warning: non-portable integer literal
+// CHECK-MESSAGES-NOT: :[[@LINE-2]]:74: warning: non-portable integer literal
+
+void templates() {
+  // Should be reported only at the callsite.
+  template_arg_not_reported<0x7FFFFFFF>();
+  // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: non-portable integer literal
+
+  template_default_reported();
+
+  // Do not report same literal twice.
+  template_default_reported<0>();
+}
+
+// FIXME: Macros are currently not distinguished from the template arguments.
+void macros() {
+#define FULL_LITERAL 0x0100000000000000
+  FULL_LITERAL;
+  // --CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal
+  // --CHECK-MESSAGES: :[[@LINE-3]]:22: note: expanded from macro
+
+#define PARTIAL_LITERAL(start) start##00000000
+  PARTIAL_LITERAL(0x01000000);
+  // --CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal
+  // --CHECK-MESSAGES: :[[@LINE-3]]:32: note: expanded from macro
+
+  // FIXME: In this case, the integer literal token is 0 long due to a tokenizer issue.
+#define EMPTY_ARGUMENT(start) start##0x0100000000000000
+  EMPTY_ARGUMENT();
+  // --CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal
+  // --CHECK-MESSAGES: :[[@LINE-3]]:38: note: expanded from macro
+
+  // The following literals could be detected without reading the text representation.
+#define MAX_VALUE_LITERAL 0x7FFFFFFF
+  MAX_VALUE_LITERAL;
+  // --CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal
+  // --CHECK-MESSAGES: :[[@LINE-3]]:22: note: expanded from macro
+
+#define MAX_VALUE_PARTIAL_LITERAL(start) start##FFFF
+  MAX_VALUE_PARTIAL_LITERAL(0x7FFF);
+  // --CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal
+  // --CHECK-MESSAGES: :[[@LINE-3]]:32: note: expanded from macro
+
+#define MAX_VALUE_EMPTY_ARGUMENT(start) start##0x7FFFFFFF
+  MAX_VALUE_EMPTY_ARGUMENT();
+  // --CHECK-MESSAGES: :[[@LINE-1]]:3: warning: non-portable integer literal
+  // --CHECK-MESSAGES: :[[@LINE-3]]:38: note: expanded from macro
+}