| 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 |