[scudo] Fix static and unused function type annotations

[vitalybuka]

compiler-rt/lib/scudo/standalone/size_class_map.h

348

compiler-rt/lib/scudo/standalone/tests/checksum_test.cpp

35

it's inline as it's template, so why do we need static?

[ddcc]

Remove unneeded static

compiler-rt/lib/scudo/standalone/size_class_map.h

Buffer.append(
         SCMap::getClassIdBySize(S));
     TotalCached += Cached;
     PrevS = S;
   }
   Buffer.append("Total Cached: %zu\n", TotalCached);
   Buffer.output();
 }
 
-template <typename SCMap> static void validateMap() {
+template <typename SCMap> static UNUSED void validateMap() {
   for (uptr C = 0; C < SCMap::NumClasses; C++) {
     if (C == SCMap::BatchClassId)
       continue;
     const uptr S = SCMap::getSizeByClassId(C);
     CHECK_NE(S, 0U);
     CHECK_EQ(SCMap::getClassIdBySize(S), C);
     if (C < SCMap::LargestClassId)
       CHECK_EQ(SCMap::getClassIdBySize(S + 1), C + 1);

compiler-rt/lib/scudo/standalone/tests/checksum_test.cpp

 //===-- checksum_test.cpp ---------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "tests/scudo_unit_test.h"
 
 #include "checksum.h"
 
 #include <string.h>
 
-scudo::u16 computeSoftwareChecksum(scudo::u32 Seed, scudo::uptr *Array,
+static scudo::u16 computeSoftwareChecksum(scudo::u32 Seed, scudo::uptr *Array,
                                           scudo::uptr ArraySize) {
   scudo::u16 Checksum = static_cast<scudo::u16>(Seed & 0xffff);
   for (scudo::uptr I = 0; I < ArraySize; I++)
     Checksum = scudo::computeBSDChecksum(Checksum, Array[I]);
   return Checksum;
 }
 
-scudo::u16 computeHardwareChecksum(scudo::u32 Seed, scudo::uptr *Array,
+static scudo::u16 computeHardwareChecksum(scudo::u32 Seed, scudo::uptr *Array,
                                           scudo::uptr ArraySize) {
   scudo::u32 Crc = Seed;
   for (scudo::uptr I = 0; I < ArraySize; I++)
     Crc = scudo::computeHardwareCRC32(Crc, Array[I]);
   return static_cast<scudo::u16>((Crc & 0xffff) ^ (Crc >> 16));
 }
 
 typedef scudo::u16 (*ComputeChecksum)(scudo::u32, scudo::uptr *, scudo::uptr);
 
 // This verifies that flipping bits in the data being checksummed produces a
 // different checksum. We do not use random data to avoid flakyness.
-template <ComputeChecksum F> void verifyChecksumFunctionBitFlip() {
+template <ComputeChecksum F> static void verifyChecksumFunctionBitFlip() {
   scudo::uptr Array[sizeof(scudo::u64) / sizeof(scudo::uptr)];
   const scudo::uptr ArraySize = ARRAY_SIZE(Array);
   memset(Array, 0xaa, sizeof(Array));
   const scudo::u32 Seed = 0x41424343U;
   const scudo::u16 Reference = F(Seed, Array, ArraySize);
   scudo::u8 IdenticalChecksums = 0;
   for (scudo::uptr I = 0; I < ArraySize; I++) {
     for (scudo::uptr J = 0; J < SCUDO_WORDSIZE; J++) {

compiler-rt/lib/scudo/standalone/tsd_exclusive.h

template <class Allocator> struct TSDRegistryExT {
   }
 
   void enable() {
     atomic_store(&Disabled, 0U, memory_order_release);
     FallbackTSD.unlock();
     Mutex.unlock();
   }
 
-  bool setOption(Option O, UNUSED sptr Value) {
+  bool setOption(Option O, sptr Value) {
     if (O == Option::ThreadDisableMemInit)
       State.DisableMemInit = Value;
     if (O == Option::MaxTSDsCount)
       return false;
     return true;
   }
 
   bool getDisableMemInit() { return State.DisableMemInit; }