clang-tools-extra/clang-tidy/performance/EnumSizeCheck.cpp

   1 //===--- EnumSizeCheck.cpp - clang-tidy -----------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "EnumSizeCheck.h"
  10 #include "../utils/Matchers.h"
  11 #include "../utils/OptionsUtils.h"
  12 #include "clang/AST/ASTContext.h"
  13 #include "clang/ASTMatchers/ASTMatchFinder.h"
  14 #include <algorithm>
  15 #include <cinttypes>
  16 #include <cstdint>
  17 #include <limits>
  18 #include <utility>
  19
  20 using namespace clang::ast_matchers;
  21
  22 namespace clang::tidy::performance {
  23
  24 namespace {
  25
  26 AST_MATCHER(EnumDecl, hasEnumerators) { return !Node.enumerators().empty(); }
  27
  28 const std::uint64_t Min8 =
  29     std::imaxabs(std::numeric_limits<std::int8_t>::min());
  30 const std::uint64_t Max8 = std::numeric_limits<std::int8_t>::max();
  31 const std::uint64_t Min16 =
  32     std::imaxabs(std::numeric_limits<std::int16_t>::min());
  33 const std::uint64_t Max16 = std::numeric_limits<std::int16_t>::max();
  34 const std::uint64_t Min32 =
  35     std::imaxabs(std::numeric_limits<std::int32_t>::min());
  36 const std::uint64_t Max32 = std::numeric_limits<std::int32_t>::max();
  37
  38 std::pair<const char *, std::uint32_t>
  39 getNewType(std::size_t Size, std::uint64_t Min, std::uint64_t Max) noexcept {
  40   if (Min) {
  41     if (Min <= Min8 && Max <= Max8) {
  42       return {"std::int8_t", sizeof(std::int8_t)};
  43     }
  44
  45     if (Min <= Min16 && Max <= Max16 && Size > sizeof(std::int16_t)) {
  46       return {"std::int16_t", sizeof(std::int16_t)};
  47     }
  48
  49     if (Min <= Min32 && Max <= Max32 && Size > sizeof(std::int32_t)) {
  50       return {"std::int32_t", sizeof(std::int32_t)};
  51     }
  52
  53     return {};
  54   }
  55
  56   if (Max) {
  57     if (Max <= std::numeric_limits<std::uint8_t>::max()) {
  58       return {"std::uint8_t", sizeof(std::uint8_t)};
  59     }
  60
  61     if (Max <= std::numeric_limits<std::uint16_t>::max() &&
  62         Size > sizeof(std::uint16_t)) {
  63       return {"std::uint16_t", sizeof(std::uint16_t)};
  64     }
  65
  66     if (Max <= std::numeric_limits<std::uint32_t>::max() &&
  67         Size > sizeof(std::uint32_t)) {
  68       return {"std::uint32_t", sizeof(std::uint32_t)};
  69     }
  70
  71     return {};
  72   }
  73
  74   // Zero case
  75   return {"std::uint8_t", sizeof(std::uint8_t)};
  76 }
  77
  78 } // namespace
  79
  80 EnumSizeCheck::EnumSizeCheck(StringRef Name, ClangTidyContext *Context)
  81     : ClangTidyCheck(Name, Context),
  82       EnumIgnoreList(
  83           utils::options::parseStringList(Options.get("EnumIgnoreList", ""))) {}
  84
  85 void EnumSizeCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
  86   Options.store(Opts, "EnumIgnoreList",
  87                 utils::options::serializeStringList(EnumIgnoreList));
  88 }
  89
  90 bool EnumSizeCheck::isLanguageVersionSupported(
  91     const LangOptions &LangOpts) const {
  92   return LangOpts.CPlusPlus11;
  93 }
  94
  95 void EnumSizeCheck::registerMatchers(MatchFinder *Finder) {
  96   Finder->addMatcher(
  97       enumDecl(unless(isExpansionInSystemHeader()), isDefinition(),
  98                hasEnumerators(),
  99                unless(matchers::matchesAnyListedName(EnumIgnoreList)))
 100           .bind("e"),
 101       this);
 102 }
 103
 104 void EnumSizeCheck::check(const MatchFinder::MatchResult &Result) {
 105   const auto *MatchedDecl = Result.Nodes.getNodeAs<EnumDecl>("e");
 106   const QualType BaseType = MatchedDecl->getIntegerType().getCanonicalType();
 107   if (!BaseType->isIntegerType())
 108     return;
 109
 110   const std::uint32_t Size = Result.Context->getTypeSize(BaseType) / 8U;
 111   if (1U == Size)
 112     return;
 113
 114   std::uint64_t MinV = 0U;
 115   std::uint64_t MaxV = 0U;
 116
 117   for (const auto &It : MatchedDecl->enumerators()) {
 118     const llvm::APSInt &InitVal = It->getInitVal();
 119     if ((InitVal.isUnsigned() || InitVal.isNonNegative())) {
 120       MaxV = std::max<std::uint64_t>(MaxV, InitVal.getZExtValue());
 121     } else {
 122       MinV = std::max<std::uint64_t>(MinV, InitVal.abs().getZExtValue());
 123     }
 124   }
 125
 126   auto NewType = getNewType(Size, MinV, MaxV);
 127   if (!NewType.first || Size <= NewType.second)
 128     return;
 129
 130   diag(MatchedDecl->getLocation(),
 131        "enum %0 uses a larger base type (%1, size: %2 %select{byte|bytes}5) "
 132        "than necessary for its value set, consider using '%3' (%4 "
 133        "%select{byte|bytes}6) as the base type to reduce its size")
 134       << MatchedDecl << MatchedDecl->getIntegerType() << Size << NewType.first
 135       << NewType.second << (Size > 1U) << (NewType.second > 1U);
 136 }
 137
 138 } // namespace clang::tidy::performance